code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222
values | license stringclasses 20
values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#ifndef _U_INTERRUPT_H_
#define _U_INTERRUPT_H_
#include "aos/list.h"
#include <drivers/atomic.h>
#define U_IRQ_PASS_THROUGH 0
#define U_IRQ_LOCK_SPINLOCK 0
//TODO: irq description rbtree control marco
#define U_IRQ_DESC_LIST_RBTREE 0
#if U_IRQ_DESC_LIST_RBTREE
#include "k_rbtree.h"
#endif
/**
* enum irqreturn
* @IRQ_NONE interrupt was not from this device or was not handled
* @IRQ_HANDLED interrupt was handled by this device
* @IRQ_WAKE_THREAD handler requests to wake the handler thread
*/
typedef enum u_irqreturn {
IRQ_NONE = (0 << 0),
IRQ_HANDLED = (1 << 0),
IRQ_WAKE_THREAD = (1 << 1),
} u_irqreturn_t;
typedef u_irqreturn_t (*u_irq_handler_t)(int, void *);
int u_request_threaded_irq(
unsigned int irq, u_irq_handler_t handler, u_irq_handler_t thread_fn,
unsigned long flags, const char *name, void *data);
static inline int u_request_irq(
unsigned int irq, u_irq_handler_t handler,
unsigned long flags, const char *name, void *data) {
return u_request_threaded_irq(irq, handler, NULL, flags, name, data);
}
void disable_u_irq_nosync(unsigned int irq);
void disable_u_irq(unsigned int irq);
void enable_u_irq(unsigned int irq);
#if U_IRQ_DESC_LIST_RBTREE
typedef struct u_irq_node {
struct k_rbtree_node_t rbt_node; /* rbttree node */
void *data; /* data */
} u_irq_node_t;
#endif
#if U_IRQ_LOCK_SPINLOCK
typedef pthread_spinlock_t u_irq_lock_t;
#else
typedef pthread_mutex_t u_irq_lock_t;
#endif
typedef struct u_irq_thread {
unsigned int should_stop;
unsigned int stopped;
char name[16];
dlist_t irq_desc_head;
dlist_t irq_thread_node;
pthread_t thread;
pthread_cond_t cond;
pthread_condattr_t condattr;
pthread_mutex_t mutex;
u_irq_lock_t lock;
dlist_t msg_head;
} u_irq_thread_t;
typedef struct u_irq_desc {
const char *name;
unsigned int irq_id;
u_irq_handler_t irq_handler;
u_irq_handler_t thread_handler;
unsigned int irq_cnt;
unsigned int flags;
void *data;
u_irq_thread_t *p_irq_th;
#if U_IRQ_DESC_LIST_RBTREE
u_irq_node_t node;
#else
dlist_t irq_desc_node; // pointer to next u_irq_desc
dlist_t thread_node; // node in irq thread list
#endif
} u_irq_desc_t;
typedef struct u_irq_msg {
dlist_t node;
u_irq_desc_t *u_irq;
} u_irq_msg_t;
int u_irq_system_init(void);
int u_irq_system_deinit(void);
#endif //_U_INTERRUPT_H_
| YifuLiu/AliOS-Things | components/drivers/core/base/include/drivers/u_interrupt.h | C | apache-2.0 | 2,377 |
/**
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#ifndef _U_IO_H_
#define _U_IO_H_
/**
* BUS types
* */
typedef enum bus_type {
BUS_TYPE_PLATFORM,
BUS_TYPE_USB,
BUS_TYPE_MMC,
BUS_TYPE_SDIO,
BUS_TYPE_I2C,
BUS_TYPE_I2S,
BUS_TYPE_SPI,
BUS_TYPE_PCI,
BUS_TYPE_MIPI,
BUS_TYPE_PRE_MAX,
BUS_TYPE_MAX = 0xff,
} bus_type_e;
/**
* hardware resource type
* */
typedef enum res_type {
RES_TYPE_IO = 0x81, /* GPIO */
RES_TYPE_MEM, /* registers */
RES_TYPE_IRQ, /* interrupt */
RES_TYPE_MAX,
} res_type_e;
/**
* hardware resources, GPIO, IRQ and registers are all included
* */
typedef struct hw_res {
res_type_e res_type; /* IO, register, IRQ, etc. */
void *reg_start; /* register base address */
void *reg_end; /* register end address */
char *name; /* hardware resource name , optional */
struct hw_res *next; /* hw resource chain , optional */
} hw_res_t;
/**
* device resources
* */
typedef struct dev_res {
char *name; /* device name */
int id; /* device group id, usually combined with name, e.g. name = "uart", id = 0, device is "uart0" */
bus_type_e bus_type; /* device name */
unsigned int num; /* resource number */
hw_res_t p_res[5]; /* pointer to device resource */
} dev_res_t;
#endif //_U_IO_H_
| YifuLiu/AliOS-Things | components/drivers/core/base/include/drivers/u_io.h | C | apache-2.0 | 1,371 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#ifndef _U_LD_H_
#define _U_LD_H_
/**
* hardware registers' information
* @addr - register's base address of hw module
* @length - register region's length counted from base address of the hw module
*/
typedef struct hw_reg_info {
unsigned long addr;
int length;
} hw_reg_info_t;
/**
* hardware's register information array
* @size - array size of hw
* @hw - pointer to hw_reg_info_t
*/
typedef struct hw_reg_array_info {
int size;
hw_reg_info_t *hw[];
} hw_reg_array_info_t;
/**
* all driver entry declared with marcos in this file should be define with this prototype
*/
typedef int (*OS_DRIVER_ENTRY)(void);
/**
* function prototype used to get hardware module's register information
*/
typedef hw_reg_array_info_t* (*DEVICE_HW_REG_INFO)(void);
/**
* this is the only driver entry API, when a driver is selected, must call this API in proper place
*
* @string process identification
*
* @return 0 for success; negative error number for failure
*/
extern int u_driver_entry(char *string);
/**
* all driver entry declared with XXXX_DRIVER_ENTRY or XXXX_DRIVER_FULL_ENTRY will be called with specified
* sequence
*
* @return 0 for success; negative error no. for failure
*/
extern int _os_driver_entry(void);
/**
* unified driver initialization entry
* do register map prior to call driver's init entry in user space
*
* @param drv_name - driver's name
* @param drv_init_entry - pointer to driver's init entry
* @param get_hw_info - pointer to the function to get driver's register info
* @return 0 for success; negative for failure
*
*/
extern int _unify_driver_init(const char *drv_name, OS_DRIVER_ENTRY drv_init_entry, DEVICE_HW_REG_INFO get_hw_info);
#define TRACE_DRV_ENTRY() //printf("%s\r\n", __func__)
/* ld sections declaration */
#if defined (__CC_ARM) || defined (__GNUC__)
#define OS_CORE_DRIVER_ATT __attribute__((used, section(".core_driver_entry")))
#define OS_BUS_DRIVER_ATT __attribute__((used, section(".bus_driver_entry")))
#define OS_EARLY_DRIVER_ATT __attribute__((used, section(".early_driver_entry")))
#define OS_VFS_DRIVER_ATT __attribute__((used, section(".vfs_driver_entry")))
#define OS_LEVEL0_DRIVER_ATT __attribute__((used, section(".level0_driver_entry")))
#define OS_LEVEL1_DRIVER_ATT __attribute__((used, section(".level1_driver_entry")))
#define OS_LEVEL2_DRIVER_ATT __attribute__((used, section(".level2_driver_entry")))
#define OS_LEVEL3_DRIVER_ATT __attribute__((used, section(".level3_driver_entry")))
#define OS_POST_DRIVER_ATT __attribute__((used, section(".post_driver_entry")))
#elif defined (__ICCARM__)
#pragma OS_CORE_DRIVER_ATT = ".core_driver_entry"
#pragma OS_BUS_DRIVER_ATT = ".bus_driver_entry"
#pragma OS_EARLY_DRIVER_ATT = ".early_driver_entry"
#pragma OS_VFS_DRIVER_ATT = ".vfs_driver_entry"
#pragma OS_LEVEL0_DRIVER_ATT = ".level0_driver_entry"
#pragma OS_LEVEL1_DRIVER_ATT = ".level1_driver_entry"
#pragma OS_LEVEL2_DRIVER_ATT = ".level2_driver_entry"
#pragma OS_LEVEL3_DRIVER_ATT = ".level3_driver_entry"
#pragma OS_POST_DRIVER_ATT = ".post_driver_entry"
#endif
/**
* Usage: if vendor or developer want to define a new device driver
* you don't need to care how to call your driver initialization,
* just select proper marcos here and declara your driver init function
* by XXXX_DRIVER_ENTRY(YOUR_DRIVER_INIT_FUNCTION) or XXXX_DRIVER_FULL_ENTRY(YOUR_DRIVER_INIT_FUNCTION)
*
* basic concept of the following marcos is as follows:
* 1. define a new function named xxxx_##your_driver_init_function,
* and put this new API's entry into image's section named .xxxx_entry
* 2. when _os_driver_entry is called, it will read the functions pointers
* from .xxxx_entry image section and call them one by one
*
* */
#define CORE_DRIVER_ENTRY(x) int core_drv_##x(void) { \
TRACE_DRV_ENTRY(); \
return x(); \
} \
OS_CORE_DRIVER_ATT OS_DRIVER_ENTRY core_##x = core_drv_##x;
#define BUS_DRIVER_FULL_ENTRY(init, get_hw_info) int bus_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_BUS_DRIVER_ATT OS_DRIVER_ENTRY bus_##init = bus_drv_##init;
#define BUS_DRIVER_ENTRY(init) BUS_DRIVER_FULL_ENTRY(init, NULL)
#define VFS_DRIVER_FULL_ENTRY(init, get_hw_info) int vfs_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_VFS_DRIVER_ATT OS_DRIVER_ENTRY vfs_##init = vfs_drv_##init;
#define VFS_DRIVER_ENTRY(init) VFS_DRIVER_FULL_ENTRY(init, NULL)
#define EARLY_DRIVER_FULL_ENTRY(init, get_hw_info) int early_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_EARLY_DRIVER_ATT OS_DRIVER_ENTRY early_##init = early_drv_##init;
#define EARLY_DRIVER_ENTRY(init) EARLY_DRIVER_FULL_ENTRY(init, NULL)
#define LEVEL0_DRIVER_FULL_ENTRY(init, get_hw_info) int level0_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_LEVEL0_DRIVER_ATT OS_DRIVER_ENTRY level0_##init = level0_drv_##init;
#define LEVEL0_DRIVER_ENTRY(init) LEVEL0_DRIVER_FULL_ENTRY(init, NULL)
#define LEVEL1_DRIVER_FULL_ENTRY(init, get_hw_info) int level1_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_LEVEL1_DRIVER_ATT OS_DRIVER_ENTRY level1_##init = level1_drv_##init;
#define LEVEL1_DRIVER_ENTRY(init) LEVEL1_DRIVER_FULL_ENTRY(init, NULL)
#define LEVEL2_DRIVER_FULL_ENTRY(init, get_hw_info) int level2_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_LEVEL2_DRIVER_ATT OS_DRIVER_ENTRY level2_##init = level2_drv_##init;
#define LEVEL2_DRIVER_ENTRY(init) LEVEL2_DRIVER_FULL_ENTRY(init, NULL)
#define LEVEL3_DRIVER_FULL_ENTRY(init, get_hw_info) int level3_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_LEVEL3_DRIVER_ATT OS_DRIVER_ENTRY level3_##init = level3_drv_##init;
#define LEVEL3_DRIVER_ENTRY(init) LEVEL3_DRIVER_FULL_ENTRY(init, NULL)
#define POST_DRIVER_FULL_ENTRY(init, get_hw_info) int post_drv_##init(void) { \
return _unify_driver_init(__func__, init, get_hw_info); \
} \
OS_POST_DRIVER_ATT OS_DRIVER_ENTRY post_##init = post_drv_##init;
#define POST_DRIVER_ENTRY(init) POST_DRIVER_FULL_ENTRY(init, NULL)
#endif //_U_LD_H_
| YifuLiu/AliOS-Things | components/drivers/core/base/include/drivers/u_ld.h | C | apache-2.0 | 6,313 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#ifndef _U_MODE_H_
#define _U_MODE_H_
#endif //_U_MODE_H_ | YifuLiu/AliOS-Things | components/drivers/core/base/include/drivers/u_mode.h | C | apache-2.0 | 124 |
/**
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#ifndef _U_MODULE_H_
#define _U_MODULE_H_
#define u_module_init(x) \
int u_aos_module_init(void) \
{\
return x(); \
}
#define u_module_get_bus(x) \
u_bus_t *u_aos_module_get_bus(void) { \
return x();\
}
typedef int (*u_aos_driver_init)(void);
typedef u_bus_t *(*u_aos_get_current_bus)(void);
#endif //_U_MODULE_H_
| YifuLiu/AliOS-Things | components/drivers/core/base/include/drivers/u_module.h | C | apache-2.0 | 384 |
/**
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <errno.h>
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "aos/list.h"
#include <drivers/u_ld.h>
#include <drivers/char/u_device.h>
#include <drivers/char/u_driver.h>
#include <drivers/char/u_bus.h>
#include <drivers/platform/u_platform_bus.h>
#include <drivers/u_device_info.h>
#include <drivers/u_module.h>
static int u_platform_bus_match(struct u_device *dev, struct u_driver *drv);
static int u_platform_bus_init(struct u_device *_dev);
static int u_platform_bus_deinit(struct u_device *_dev);
static int u_platform_bus_pm(struct u_device *_dev, u_pm_ops_t state);
u_bus_t u_platform_bus = {
.name = "u_platform",
.p = NULL,
// legay driver ops
.match = u_platform_bus_match,
.init = u_platform_bus_init,
.deinit = u_platform_bus_deinit,
.pm = u_platform_bus_pm,
// linux-like driver ops
.probe = NULL,
.remove = NULL,
.shutdown = NULL,
.resume = NULL,
// heartbeat ops
.on_ping = NULL,
};
static u_platform_device_t u_platform_root_dev = {
.name = "u_platform",
};
/**
* try init u_platform device
*
* @param _dev - pointer to low level device struct
* @return 0 for success; negatiive for failure
*/
static int u_platform_bus_init(struct u_device *_dev) {
int ret = 0;
struct u_platform_driver *drv = NULL;
struct u_platform_device *dev = to_u_platform_device(_dev);
drv = to_u_platform_driver(_dev->drv);
ddkc_dbg("dev:%p, _dev->driver:%p, drv:%p\r\n", dev, _dev->drv, drv);
/* driver must provide either init or probe functions, otherwise return fail
* try init cb prior to probe cb
* */
if (drv->init) {
ret = drv->init(dev);
} else if (drv->probe) {
ret = drv->probe(dev);
} else
ret = -1;
/* reset _dev->drv to NULL if init procedure fails */
if (ret)
_dev->drv = NULL;
ddkc_dbg("ret:%d\r\n", ret);
return ret;
}
/**
* deinit u_platform device
*
* @param _dev - pointer to low level device struct
* @return 0 for success; negatiive for failure
*/
static int u_platform_bus_deinit(struct u_device *_dev) {
int ret = 0;
struct u_platform_driver *drv = NULL;
struct u_platform_device *dev = to_u_platform_device(_dev);
drv = to_u_platform_driver(_dev->drv);
ddkc_dbg("dev:%p, _dev->drv:%p, drv:%p\r\n", dev, _dev->drv, drv);
if (drv->deinit) {
ret = drv->deinit(dev);
} else if (drv->remove)
ret = drv->remove(dev);
ddkc_dbg("ret:%d\r\n", ret);
return 0;
}
/**
* do power managerment of target device
*
* @param _dev - pointer to low level device struct
* @param state
* @return 0 for success; negatiive for failure
*/
static int u_platform_bus_pm(struct u_device *_dev, u_pm_ops_t state) {
int ret = 0;
struct u_platform_driver *drv = NULL;
struct u_platform_device *dev = to_u_platform_device(_dev);
drv = to_u_platform_driver(_dev->drv);
ddkc_dbg("dev:%p, _dev->drv:%p, drv:%p, state:%d\r\n", dev, _dev->drv, drv, state.event);
/* try legacy pm prior to linux-like driver suspend/resume callback */
if (drv->pm) {
ret = drv->pm(dev, state);
} else {
if (drv->resume && (state.event == E_PM_EXIT)) {
ret = drv->resume(dev);
} else if (drv->suspend && (state.event != E_PM_EXIT)) {
ret = drv->suspend(dev, state.event);
} else
ret = -EINVAL;
}
ddkc_dbg("ret:%d\r\n", ret);
return ret;
}
/**
* try to match device with driver
*
* @param dev - pointer to low level device struct
* @param drv - pointer to low level driiver struct
* @return 1 for success; 0 for failure
*/
static int u_platform_bus_match(struct u_device *dev, struct u_driver *drv) {
struct u_platform_device *pdev = to_u_platform_device(dev);
struct u_platform_driver *pdrv = to_u_platform_driver(drv);
ddkc_dbg("dev:%p, drv:%p, pdev:%p, pdrv:%p, pdev->name:%p, drv->name:%p\r\n", dev, drv, pdev, pdrv, pdev->name, drv->name);
if (!pdev->name || !drv->name) {
return 0;
}
ddkc_dbg("pdev->name:%s, drv->name:%s\r\n", pdev->name, drv->name);
/* check whether device's name match with driver's name or not */
return (strcmp(pdev->name, drv->name) == 0);
}
/**
* register device into system
* @param dev - pointer to low level device struct
* @return 0 for success; negatiive for failure
*/
int u_platform_device_register(u_platform_device_t *dev) {
int r = -1;
ddkc_loud("u_platform bus device register start\r\n");
if (dev->dev.bus && dev->dev.bus != &u_platform_bus) {
ddkc_err("bus->bus[%p] with name[%s] does not equal to u_platform_bus:%p\r\n",
dev->dev.bus, dev->dev.bus->name, &u_platform_bus);
return -EINVAL;
} else
dev->dev.bus = &u_platform_bus;
if (!dev->dev.parent && dev != &u_platform_root_dev)
dev->dev.parent = &u_platform_root_dev.dev;
dev->dev.name = (char *)dev->name;
r = u_device_register(&dev->dev);
if (!r) {
// TODO: need to register to DM
ddkc_dbg("ALERT!!! this bypass device manager process, need to register to DM!!\r\n");
ddkc_dbg("dev[%s] register with bus[%s] succeed\r\n", dev->name, u_platform_bus.name);
} else {
ddkc_err("dev[%s] register with bus[%s] failed, ret:%d\r\n", dev->name, u_platform_bus.name, r);
}
return r;
}
/**
* register driver into system
* @param drv - pointer to low level driver struct
* @return 0 for success; negatiive for failure
*/
int u_platform_driver_register(u_platform_driver_t *drv) {
int r = -1;
if (!drv) {
ddkc_err("invalid drv\r\n");
return -EINVAL;
}
if (drv->bus && drv->bus != &u_platform_bus) {
ddkc_err("drv->bus[%p] with name[%s] does not equal to u_platform_bus:%p\r\n",
drv->bus, drv->bus->name, &u_platform_bus);
return -EINVAL;
} else
drv->bus = &u_platform_bus;
/* assign u_platform bus's init/deinit/pm callback to lowlevel driver's ops */
drv->driver.bus = &u_platform_bus;
drv->driver.init = u_platform_bus_init;
drv->driver.deinit = u_platform_bus_deinit;
drv->driver.pm = u_platform_bus_pm;
/* assign driver probe/remove, etc. to lower level driver's probe/remove, etc. */
drv->driver.probe = u_platform_bus_init;
drv->driver.remove = u_platform_bus_deinit;
drv->driver.on_ping = NULL;
/* register driver to system's device-driver model */
r = u_driver_register(&drv->driver);
ddkc_dbg("drv[%s] register with bus[%s] %s\r\n", drv->driver.name, u_platform_bus.name, !r ? "success" : "fail");
return r;
}
/**
* unregister device from system
* @param dev - pointer to low level device struct
* @return 0 for success; negatiive for failure
*/
int u_platform_device_unregister(u_platform_device_t *dev) {
if (!dev)
return -EINVAL;
u_bus_del_device(&dev->dev);
return u_device_unregister(&dev->dev);
}
/**
* unregister device from system
* @param drv - pointer to low level driver struct
* @return 0 for success; negatiive for failure
*/
int u_platform_driver_unregister(u_platform_driver_t *drv) {
if (!drv)
return -EINVAL;
return u_driver_unregister(&drv->driver);
}
/**
* delete u_platform_device from system
* @param pdev - pointer to target u_platform_device
*
*/
void u_platform_device_del(u_platform_device_t *pdev) {
if (pdev) {
u_device_unregister(&pdev->dev);
}
return;
}
/**
* allocate memory for u_platform_device - for device-tree function in the future
*
* @return pointer to the u_platform_device
*/
u_platform_device_t* u_platform_device_alloc(void) {
u_platform_device_t* new = (u_platform_device_t *)malloc(sizeof(u_platform_device_t));
if (!new) {
ddkc_err("malloc for u_platform_device_t failed\r\n");
return NULL;
}
memset(new, 0, sizeof(u_platform_device_t));
u_device_initialize(&new->dev);
return new;
}
/**
* module init entry of u_platform_bus
* declared with BUS_DRIVER_ENTRY, which is 2nd level driver init entry
* @return 0 for success; negatiive for failure
*/
static int u_platform_init(void)
{
int r = 0;
ddkc_dbg("u_platform_bus init\r\n");
r = u_bus_register(&u_platform_bus);
if (r) {
ddkc_err("u_platform_bus init failed, ret:%d\r\n", r);
return r;
}
r = u_platform_device_register(&u_platform_root_dev);
if (r) {
ddkc_err("u_platform_device_register failed, ret:%d\r\n", r);
u_bus_unregister(&u_platform_bus);
}
return r;
}
#if 0
u_bus_t *u_get_platform_bus(void) {
return &u_platform_bus;
}
u_driver_bin_info_t* u_aos_get_driver_info (void) {
static u_driver_bin_info_t g_drv_info;
ddkc_info("u_aos_get_driver_info\r\n");
g_drv_info.name = u_platform_bus.name;
g_drv_info.type = DRV_TYPE_BUS;
g_drv_info.bus_type = BUS_TYPE_PLATFORM;
return &g_drv_info;
}
static u_bus_t *get_current_bus(void) {
return &u_platform_bus;
}
#endif
BUS_DRIVER_ENTRY(u_platform_init)
| YifuLiu/AliOS-Things | components/drivers/core/base/platform/u_platform_bus.c | C | apache-2.0 | 8,638 |
/*
* Copyright (C) 2020-2021 Alibaba Group Holding Limited
*/
#include <aos/device_core.h>
#define REF_COUNT_PENDING UINT32_MAX
#define REF_COUNT_MAX (UINT32_MAX - 1)
static struct k_rbtree_root_t device_map = RBT_ROOT;
static aos_mutex_t device_map_mutex;
static aos_status_t device_core_init(void)
{
return aos_mutex_new(&device_map_mutex);
}
#if defined(CONFIG_DRV_CORE) && CONFIG_DRV_CORE != 0
static int dev_core_init(void)
{
return (int)device_core_init();
}
CORE_DRIVER_ENTRY(dev_core_init)
#else
aos_status_t aos_dev_core_init(void)
{
return device_core_init();
}
#endif
static void device_map_lock(void)
{
(void)aos_mutex_lock(&device_map_mutex, AOS_WAIT_FOREVER);
}
static void device_map_unlock(void)
{
(void)aos_mutex_unlock(&device_map_mutex);
}
static void device_forbid_removal(aos_dev_t *dev)
{
(void)aos_sem_wait(&dev->rb_sem, AOS_WAIT_FOREVER);
}
static void device_allow_removal(aos_dev_t *dev)
{
(void)aos_sem_signal(&dev->rb_sem);
}
static void device_wait_removal(aos_dev_t *dev)
{
(void)aos_sem_wait(&dev->rb_sem, AOS_WAIT_FOREVER);
}
static int compare_device(aos_dev_type_t a_type, uint32_t a_id, aos_dev_type_t b_type, uint32_t b_id)
{
if (a_type < b_type)
return -1;
if (a_type > b_type)
return 1;
if (a_id < b_id)
return -1;
if (a_id > b_id)
return 1;
return 0;
}
static aos_dev_t *find_device(aos_dev_type_t type, uint32_t id)
{
struct k_rbtree_node_t *node = device_map.rbt_node;
while (node) {
aos_dev_t *dev = k_rbtree_entry(node, aos_dev_t, rb_node);
int r = compare_device(type, id, dev->type, dev->id);
if (r < 0)
node = node->rbt_left;
else if (r > 0)
node = node->rbt_right;
else
break;
}
return node ? k_rbtree_entry(node, aos_dev_t, rb_node) : NULL;
}
static void insert_device(aos_dev_t *dev)
{
struct k_rbtree_node_t **link = &device_map.rbt_node;
struct k_rbtree_node_t *parent = NULL;
while (*link) {
aos_dev_t *tmp_dev;
int r;
parent = *link;
tmp_dev = k_rbtree_entry(*link, aos_dev_t, rb_node);
r = compare_device(dev->type, dev->id, tmp_dev->type, tmp_dev->id);
link = (r < 0) ? &(*link)->rbt_left : &(*link)->rbt_right;
}
k_rbtree_link_node(&dev->rb_node, parent, link);
k_rbtree_insert_color(&dev->rb_node, &device_map);
}
static void remove_device(aos_dev_t *dev)
{
k_rbtree_erase(&dev->rb_node, &device_map);
}
aos_status_t aos_dev_register(aos_dev_t *dev)
{
aos_status_t ret;
if (!dev)
return -EINVAL;
ret = aos_sem_new(&dev->rb_sem, 1);
if (ret)
return ret;
ret = aos_mutex_new(&dev->mutex);
if (ret) {
aos_sem_free(&dev->rb_sem);
return ret;
}
dev->ref_count = REF_COUNT_PENDING;
device_map_lock();
if (find_device(dev->type, dev->id)) {
device_map_unlock();
aos_mutex_free(&dev->mutex);
aos_sem_free(&dev->rb_sem);
return -EEXIST;
}
insert_device(dev);
device_map_unlock();
#ifdef AOS_COMP_DEVFS
if (aos_devfs_node_is_valid(&dev->devfs_node)) {
ret = aos_devfs_add_node(&dev->devfs_node);
if (ret) {
device_map_lock();
remove_device(dev);
device_map_unlock();
aos_mutex_free(&dev->mutex);
aos_sem_free(&dev->rb_sem);
return ret;
}
}
#endif
aos_dev_lock(dev);
dev->ref_count = 0;
aos_dev_unlock(dev);
return 0;
}
aos_status_t aos_dev_unregister(aos_dev_type_t type, uint32_t id)
{
aos_dev_t *dev;
device_map_lock();
dev = find_device(type, id);
if (!dev) {
device_map_unlock();
return -ENODEV;
}
device_forbid_removal(dev);
device_map_unlock();
aos_dev_lock(dev);
if (dev->ref_count == REF_COUNT_PENDING) {
aos_dev_unlock(dev);
device_allow_removal(dev);
return -ENODEV;
} else if (dev->ref_count > 0) {
aos_dev_unlock(dev);
device_allow_removal(dev);
return -EBUSY;
} else {
dev->ref_count = REF_COUNT_PENDING;
}
aos_dev_unlock(dev);
device_allow_removal(dev);
#ifdef AOS_COMP_DEVFS
if (aos_devfs_node_is_valid(&dev->devfs_node))
(void)aos_devfs_remove_node(&dev->devfs_node);
#endif
device_map_lock();
device_wait_removal(dev);
remove_device(dev);
device_map_unlock();
aos_mutex_free(&dev->mutex);
aos_sem_free(&dev->rb_sem);
if (dev->ops && dev->ops->unregister)
dev->ops->unregister(dev);
return 0;
}
aos_status_t aos_dev_ref(aos_dev_ref_t *ref, aos_dev_t *dev)
{
if (!ref)
return -EINVAL;
if (!dev) {
aos_dev_ref_init(ref);
return -EINVAL;
}
aos_dev_lock(dev);
if (dev->ref_count == REF_COUNT_PENDING) {
aos_dev_unlock(dev);
aos_dev_ref_init(ref);
return -ENODEV;
} else if (dev->ref_count == REF_COUNT_MAX) {
aos_dev_unlock(dev);
aos_dev_ref_init(ref);
return -EBUSY;
}
ref->dev = dev;
ref->pdata = NULL;
if (dev->ops && dev->ops->get) {
aos_status_t ret;
ret = dev->ops->get(ref);
if (ret) {
aos_dev_unlock(dev);
aos_dev_ref_init(ref);
return ret;
}
}
dev->ref_count++;
aos_dev_unlock(dev);
return 0;
}
aos_status_t aos_dev_get(aos_dev_ref_t *ref, aos_dev_type_t type, uint32_t id)
{
aos_dev_t *dev;
aos_status_t ret;
if (!ref)
return -EINVAL;
device_map_lock();
dev = find_device(type, id);
if (!dev) {
device_map_unlock();
aos_dev_ref_init(ref);
return -ENODEV;
}
device_forbid_removal(dev);
device_map_unlock();
ret = aos_dev_ref(ref, dev);
device_allow_removal(dev);
return ret;
}
void aos_dev_put(aos_dev_ref_t *ref)
{
if (!ref || !aos_dev_ref_is_valid(ref))
return;
aos_dev_lock(ref->dev);
ref->dev->ref_count--;
if (ref->dev->ops && ref->dev->ops->put)
ref->dev->ops->put(ref);
aos_dev_unlock(ref->dev);
aos_dev_ref_init(ref);
}
| YifuLiu/AliOS-Things | components/drivers/core/base/src/device.c | C | apache-2.0 | 6,257 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef FB_H
#define FB_H
/**
* @addtogroup aos_fbdev fbdev
* This is the brief description of the component.
*
* This is the detailed description, and it's optional.
* @{
*/
#include <fb_define.h>
#include <ulog/ulog.h>
#include <aos/kernel.h>
#ifdef CONFIG_BACKLIGHT_MODE_ENABLE
#include "backlight.h"
#endif
#include "aos/vfs.h"
/* Here is Macro and struct definition*/
#define FB_MAX 3
#define FB_STR "FB"
#define FB_MAX_NUM 16
#define FB_NAME_LEN 16
#define fb_node_path "/dev/fb"
#define FBDEV_STEP_DEBUG printf("[%s][%d]excute to here\n", __func__, __LINE__);
#define FBINFO_STATE_RUNNING 0
#define FBINFO_STATE_SUSPENDED 1
#define PAGE_SIZE 4096
#define fb_memcpy_fromfb memcpy
#define fb_memcpy_tofb memcpy
#ifndef unlikely
#if defined(__CC_ARM)
#define unlikely(x) __builtin_expect(!!(x), 0)
#elif defined(__ICCARM__)
#define unlikely(x) (x)
#elif defined(__GNUC__)
#define unlikely(x) __builtin_expect(!!(x), 0)
#else
#define unlikely(x) (x)
#endif
#endif
/* FBINFO_* = fb_info.flags bit flags */
#define FBINFO_DEFAULT 0
#define FBINFO_HWACCEL_DISABLED 0x0002
#define FBINFO_HWACCEL_NONE 0x0000
#define FBINFO_HWACCEL_COPYAREA 0x0100 /* required */
#define FBINFO_HWACCEL_FILLRECT 0x0200 /* required */
#define FBINFO_HWACCEL_IMAGEBLIT 0x0400 /* required */
#define FBINFO_HWACCEL_ROTATE 0x0800 /* optional */
#define FBINFO_HWACCEL_XPAN 0x1000 /* optional */
#define FBINFO_HWACCEL_YPAN 0x2000 /* optional */
#define FBINFO_HWACCEL_YWRAP 0x4000 /* optional */
struct _fb_ops_t;
#ifdef CONFIG_BACKLIGHT_MODE_ENABLE
struct _bl_device_t;
#endif
struct _fb_info_t;
typedef struct _fb_videomode_t {
const char *name; /* optional */
uint32_t refresh; /* optional */
uint32_t xres;
uint32_t yres;
uint32_t pixclock;
uint32_t left_margin;
uint32_t right_margin;
uint32_t upper_margin;
uint32_t lower_margin;
uint32_t hsync_len;
uint32_t vsync_len;
uint32_t sync;
uint32_t vmode;
uint32_t flag;
} fb_videomode_t;
struct fb_pixmap {
uint8_t *addr; /* pointer to memory */
uint32_t size; /* size of buffer in bytes */
uint32_t offset; /* current offset to buffer */
uint32_t buf_align; /* byte alignment of each bitmap */
uint32_t scan_align; /* alignment per scanline */
uint32_t access_align; /* alignment per read/write (bits) */
uint32_t flags; /* see FB_PIXMAP_* */
uint32_t blit_x; /* supported bit block dimensions (1-32)*/
uint32_t blit_y; /* Format: blit_x = 1 << (width - 1) */
/* blit_y = 1 << (height - 1) */
/* if 0, will be set to 0xffffffff (all)*/
/* access methods */
void (*writeio)(struct _fb_info_t *info, void *dst, void *src, unsigned int size);
void (*readio) (struct _fb_info_t *info, void *dst, void *src, unsigned int size);
};
typedef struct _fb_info_t {
char path[FB_NAME_LEN];
int ref;
int node;
int flags;
aos_mutex_t lock; /* Lock for open/release/ioctl funcs */
aos_mutex_t mm_lock; /* Lock for fb_mmap and smem_* fields */
fb_var_screeninfo_t var; /* Current var */
fb_fix_screeninfo_t fix; /* Current fix */
struct fb_pixmap pixmap; /* Image hardware mapper */
struct fb_pixmap sprite; /* Cursor hardware mapper */
// struct fb_cmap cmap; /* Current cmap */
uint8_t *prefb; /* Pre-frame buffer from user space*/
void *par; /* From here on everything is device dependent */
#ifdef CONFIG_BACKLIGHT_MODE_ENABLE
struct _bl_device_t *bl_dev; /*backlight device*/
uint8_t bl_curve[FB_BACKLIGHT_LEVELS];
#endif
uint32_t state; /* Hardware state i.e suspend */
const struct _fb_ops_t *fbops;
union {
uint8_t *screen_base; /* Virtual address */
uint8_t *screen_buffer;
};
unsigned long screen_size; /* Amount of ioremapped VRAM or 0 */
} fb_info_t;
typedef struct _fb_ops_t {
/* open/release and usage marking */
int (*fb_open)(fb_info_t *info, int user);
int (*fb_release)(fb_info_t *info, int user);
/* For framebuffers with strange non linear layouts or that do not
* work with normal memory mapped access
*/
ssize_t (*fb_read)(fb_info_t *info, char *buf,
size_t count);
ssize_t (*fb_write)(fb_info_t *info, const char *buf,
size_t count);
/* blank display */
int (*fb_blank)(int blank, fb_info_t *info);
/* pan display */
int (*fb_pan_display)(fb_var_screeninfo_t *var, fb_info_t *info);
/* set the video mode according to info->var */
int (*fb_set_par)(fb_info_t *info);
/* Rotates the display */
void (*fb_rotate)(fb_info_t *info, int angle);
/* wait for blit idle, optional */
int (*fb_sync)(fb_info_t *info);
/* perform fb specific ioctl (optional) */
int (*fb_ioctl)(fb_info_t *info, unsigned int cmd,
unsigned long arg);
/* perform fb specific mmap */
void *(*fb_mmap)(fb_info_t *info, size_t size);
#ifdef CONFIG_HW_ACCELERATION
/* Draws a rectangle */
void (*fb_fillrect) (fb_info_t *info, const fb_fillrect_t *rect);
/* Copy data from area to another */
void (*fb_copyarea) (fb_info_t *info, const fb_copyarea_t *region);
/* Draws a image to the display */
void (*fb_imageblit) (fb_info_t *info, const fb_image_t *image);
#endif
/* teardown any resources to do with this framebuffer */
void (*fb_destroy)(fb_info_t *info);
} fb_ops_t;
/* Here is API and callback definition*/
static inline void lock_fb_info(fb_info_t *info)
{
if (aos_mutex_lock(&info->lock, AOS_WAIT_FOREVER) != 0) {
LOGE(FB_STR, "Failed to lock mutex (%s).", __func__);
return;
}
}
static inline void unlock_fb_info(fb_info_t *info)
{
aos_mutex_unlock(&info->lock);
}
static inline inode_t *file_inode(const file_t *file)
{
if (!file)
return NULL;
return file->node;
}
int fb_init(void);
fb_info_t *framebuffer_alloc(size_t size);
int register_framebuffer(fb_info_t *info);
void unregister_framebuffer(fb_info_t *info);
void framebuffer_release(fb_info_t *info);
/** @} */
#endif
| YifuLiu/AliOS-Things | components/drivers/core/fbdev/include/fb.h | C | apache-2.0 | 6,481 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef COMP_FB_H
#define COMP_FB_H
#include <stdint.h>
#include <stddef.h>
#define FB_BACKLIGHT_LEVELS 128
#define FB_BACKLIGHT_MAX 0xFF
#ifdef CONFIG_64BIT
#define BITS_PER_LONG 64
#else
#define BITS_PER_LONG 32
#endif /* CONFIG_64BIT */
#define FB_SYNC 0x0001
#define FB_ASYNC 0x0010
// show normally
#define FB_ROTATE_UR 0
// rotate 90 degrees clockwise
#define FB_ROTATE_CW 1
// upside down
#define FB_ROTATE_UD 2
// rotate 90 degrees counterclockwise
#define FB_ROTATE_CCW 3
#define BYTES_PER_LONG (BITS_PER_LONG / 8)
#define PADDING (BYTES_PER_LONG - (sizeof(fb_info_t) % BYTES_PER_LONG))
#define FBIOGET_VSCREENINFO 0x4600
#define FBIOPUT_VSCREENINFO 0x4601
#define FBIOGET_FSCREENINFO 0x4602
#define FBIOGET_FRRAMEBUFFER 0x4603
#define FBIOGETCMAP 0x4604
#define FBIOPUTCMAP 0x4605
#define FBIOPAN_DISPLAY 0x4606
#define FBIO_WAITFORVSYNC 0x4607
#define FBIOPUT_PREFB_ADDR 0x4608
#define FBIOBLANK 0x4611
/*brightness ioctl*/
#define FBIOPUT_BRIGHTNESS 0x4612
#define FBIOGET_BRIGHTNESS 0x4613
#define FBIOENABLE_BACKLIGHT 0x4614
#define FBIODISABLE_BACKLIGHT 0x4615
typedef struct _fb_fix_screeninfo_t {
char id[16]; /* Identification string */
uint64_t smem_start; /* Start of frame buffer mem */
/* (physical address) */
uint32_t smem_len; /* Length of frame buffer mem */
uint16_t xpanstep; /* zero if no hardware panning */
uint16_t ypanstep; /* zero if no hardware panning */
uint16_t ywrapstep; /* zero if no hardware ywrap */
uint32_t line_length;
uint64_t mmio_start; /* Start of Memory Mapped I/O */
/* (physical address) */
size_t mmio_len; /* Length of Memory Mapped I/O */
uint16_t reserved[15];
} fb_fix_screeninfo_t;
typedef struct _fb_bitfield_t {
uint32_t offset;
uint32_t length;
uint32_t msb_right;
} fb_bitfield_t;
typedef struct _fb_var_screeninfo_t {
uint32_t xres; /* visible resolution */
uint32_t yres;
uint32_t xres_virtual; /* virtual resolution */
uint32_t yres_virtual;
uint32_t xoffset; /* offset from virtual to visible */
uint32_t yoffset;
uint32_t bits_per_pixel;
fb_bitfield_t red; /* bitfield in fb mem if true color */
fb_bitfield_t green;
fb_bitfield_t blue;
fb_bitfield_t transp; /* transparency */
uint32_t height; /* height of picture in mm */
uint32_t width; /* width of picture in mm */
uint32_t rotate; /* angle we rotate counter clockwise */
uint16_t reserved[10];
} fb_var_screeninfo_t;
#endif /* COMP_FB_H */
| YifuLiu/AliOS-Things | components/drivers/core/fbdev/include/fb_define.h | C | apache-2.0 | 2,786 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#ifndef FB_ROTATE_H
#define FB_ROTATE_H
/**
* @addtogroup rotate
* This is the brief description of the component.
*
* This is the detailed description, and it's optional.
* @{
*/
#include <stdio.h>
#include <stdint.h>
/* Here is Macro and struct definition*/
/* Here is API and callback definition*/
void rotate_cw(const uint8_t *in, uint8_t *out, uint32_t w, uint32_t h);
/** @} */
#endif
| YifuLiu/AliOS-Things | components/drivers/core/fbdev/include/fb_rotate.h | C | apache-2.0 | 470 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include <stdio.h>
#include <aos/kernel.h>
#include <errno.h>
#include <aos/vfs.h>
#include <string.h>
#include <fb.h>
#include <devicevfs/devicevfs.h>
#include <k_api.h>
// #include <k_shmm.h>
#define FBPIXMAPSIZE (1024 * 8)
fb_info_t *registered_fb[FB_MAX];
static int num_registered_fb = 0;
static aos_mutex_t fb_mutex;
static int fb_open(inode_t *inode, file_t *file);
static int fb_close(file_t *file);
static ssize_t fb_read(file_t *file, void *buf, size_t len);
static ssize_t fb_write(file_t *file, const void *buf, size_t len);
static int fb_ioctl(file_t *file, int cmd, unsigned long arg);
#ifdef CONFIG_AOS_MMAP_ENABLE
static void *fb_mmap(file_t *file, size_t size);
#endif
file_ops_t fb_fops = {
.open = fb_open,
.close = fb_close, // release
.read = fb_read,
.write = fb_write,
.ioctl = fb_ioctl,
#ifdef CONFIG_AOS_MMAP_ENABLE
.mmap = fb_mmap,
#endif
};
static fb_info_t *get_fb_info(char *path)
{
int i = 0;
fb_info_t *fb_info;
if (path == NULL) {
printf("[%s]path is null\n", __func__);
return NULL;
}
for (i = 0; i < FB_MAX; i++) {
if (strlen(path) != strlen(registered_fb[i]->path))
continue;
if (strncmp(registered_fb[i]->path, path, strlen(path)) == 0)
break;
}
if (i >= FB_MAX)
return NULL;
if (aos_mutex_lock(&fb_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(FB_STR, "Failed to lock mutex (%s).", __func__);
return NULL;
}
fb_info = registered_fb[i];
aos_mutex_unlock(&fb_mutex);
return fb_info;
}
static int fb_open(inode_t *inode, file_t *file)
{
fb_info_t *info;
int ret = 0;
info = get_fb_info(inode->i_name);
if (!info)
return -ENODEV;
lock_fb_info(info);
if (info->fbops->fb_open)
ret = info->fbops->fb_open(info, 1);
unlock_fb_info(info);
return ret;
}
static fb_info_t *file_fb_info(file_t *file)
{
inode_t *inode = file_inode(file);
fb_info_t *info;
if (!inode)
return NULL;
info = get_fb_info(inode->i_name);
if (!info)
return NULL;
return info;
}
static ssize_t fb_read(file_t *file, void *buf, size_t len)
{
fb_info_t *info = file_fb_info(file);
unsigned long total_size;
if (!info || !info->screen_base)
return -ENODEV;
if (info->state != FBINFO_STATE_RUNNING)
return -EPERM;
if (info->fbops->fb_read)
return info->fbops->fb_read(info, buf, len);
total_size = info->screen_size;
if (total_size == 0)
total_size = info->fix.smem_len;
if (len >= total_size)
len = total_size;
memcpy(buf, info->screen_base, len);
return len;
}
static ssize_t fb_write(file_t *file, const void *buf, size_t len)
{
fb_info_t *info = file_fb_info(file);
if (!info || !info->screen_base)
return -ENODEV;
if (info->fbops->fb_write)
return info->fbops->fb_write(info, buf, len);
if (!info->screen_base)
return -1;
memcpy(info->screen_base, buf, len);
return len;
}
static int fb_set_var(fb_info_t *info, fb_var_screeninfo_t *var)
{
int32_t ret = 0;
memcpy(&info->var, var, sizeof(fb_var_screeninfo_t));
if (info->fbops->fb_set_par)
ret = info->fbops->fb_set_par(info);
return ret;
}
static int fb_pan_display(fb_info_t *info, fb_var_screeninfo_t *var)
{
fb_fix_screeninfo_t *fix = &info->fix;
uint32_t yres = info->var.yres;
int err = 0;
if (!var)
return -EINVAL;
if (var->xoffset > 0 && (!fix->xpanstep ||
(var->xoffset % fix->xpanstep)))
err = -EINVAL;
if (err || !info->fbops->fb_pan_display ||
var->yoffset > info->var.yres_virtual - yres ||
var->xoffset > info->var.xres_virtual - info->var.xres)
return -EINVAL;
err = info->fbops->fb_pan_display(var, info);
if (err != 0)
return err;
info->var.xoffset = var->xoffset;
info->var.yoffset = var->yoffset;
return 0;
}
static int fb_blank(fb_info_t *info, int blank)
{
int ret = -EINVAL;
if (info->fbops->fb_blank)
ret = info->fbops->fb_blank(blank, info);
return ret;
}
static void printf_string(int cmd)
{
switch (cmd) {
case FBIOGET_VSCREENINFO:
printf("ioctl cmd : FBIOGET_VSCREENINFO\n");
break;
case FBIOPUT_VSCREENINFO:
// printf("ioctl cmd : FBIOPUT_VSCREENINFO\n");
break;
case FBIOGET_FSCREENINFO:
printf("ioctl cmd : FBIOGET_FSCREENINFO\n");
break;
case FBIOPAN_DISPLAY:
printf("ioctl cmd : FBIOPAN_DISPLAY\n");
break;
case FBIOPUT_PREFB_ADDR:
printf("ioctl cmd : FBIOPUT_PREFB_ADDR\n");
break;
// case FBIOPUT_PREFB_PARAMS:
// // printf("ioctl cmd: FBIOPUT_PREFB_PARAMS\n");
// break;
case FBIO_WAITFORVSYNC:
printf("ioctl cmd: FBIO_WAITFORVSYNC\n");
break;
case FBIOBLANK:
printf("ioctl cmd : FBIOBLANK\n");
break;
case FBIOPUT_BRIGHTNESS:
printf("ioctl cmd : FBIOPUT_BRIGHTNESS\n");
break;
case FBIOGET_BRIGHTNESS:
printf("ioctl cmd : FBIOGET_BRIGHTNESS\n");
break;
#ifdef CONFIG_BACKLIGHT_MODE_ENABLE
case FBIOENABLE_BACKLIGHT:
printf("ioctl cmd : FBIOENABLE_BACKLIGHT\n");
break;
case FBIODISABLE_BACKLIGHT:
printf("ioctl cmd : FBIODISABLE_BACKLIGHT\n");
break;
#endif
default:
// printf("ioctl cmd: unknown command\n");
break;
}
return;
}
static int fb_ioctl(file_t *file, int cmd, unsigned long arg)
{
int ret = 0;
fb_info_t *info = file_fb_info(file);
fb_var_screeninfo_t var;
printf_string(cmd);
switch (cmd) {
case FBIOGET_VSCREENINFO:
lock_fb_info(info);
memcpy((void *)arg, &info->var, sizeof(fb_var_screeninfo_t));
unlock_fb_info(info);
break;
case FBIOPUT_VSCREENINFO:
lock_fb_info(info);
ret = fb_set_var(info, (fb_var_screeninfo_t *)arg);
unlock_fb_info(info);
if (ret < 0)
ret = -EFAULT;
break;
case FBIOGET_FSCREENINFO:
lock_fb_info(info);
memcpy((void *)arg, &info->fix, sizeof(fb_fix_screeninfo_t));
unlock_fb_info(info);
break;
case FBIOGET_FRRAMEBUFFER:
info->screen_buffer = malloc((int32_t)arg);
break;
case FBIOPAN_DISPLAY:
lock_fb_info(info);
if (arg)
ret = fb_pan_display(info, (fb_var_screeninfo_t *)arg);
unlock_fb_info(info);
break;
case FBIOBLANK:
lock_fb_info(info);
ret = fb_blank(info, arg);
unlock_fb_info(info);
break;
#ifdef CONFIG_BACKLIGHT_MODE_ENABLE
case FBIOPUT_BRIGHTNESS:
if (info->bl_dev)
backlight_device_set_brightness(info->bl_dev, *(int32_t *)arg);
break;
case FBIOGET_BRIGHTNESS:
if (info->bl_dev) {
int32_t brightness;
brightness = backlight_device_get_brightness(info->bl_dev);
memcpy((void *)arg, &brightness, sizeof(brightness));
}
break;
case FBIOENABLE_BACKLIGHT:
if (info->bl_dev)
backlight_enable(info->bl_dev);
break;
case FBIODISABLE_BACKLIGHT:
if (info->bl_dev)
backlight_disable(info->bl_dev);
break;
#endif
#ifdef CONFIG_HW_ACCELERATION
case FBIO_ACCEL_FILLRECT:
lock_fb_info(info);
if (info->fbops->fb_fillrect) {
info->fbops->fb_fillrect(info, (const fb_fillrect_t *)arg);
ret = 0;
} else {
ret = -EIO;
}
unlock_fb_info(info);
break;
case FBIO_ACCEL_IMAGEBLIT:
lock_fb_info(info);
if (info->fbops->fb_imageblit) {
info->fbops->fb_imageblit(info, (const fb_image_t *)arg);
ret = 0;
} else {
ret = -EIO;
}
unlock_fb_info(info);
break;
case FBIO_ACCEL_COPYAREA:
lock_fb_info(info);
if (info->fbops->fb_copyarea) {
info->fbops->fb_copyarea(info, (const fb_copyarea_t *)arg);
ret = 0;
} else {
ret = -EIO;
}
unlock_fb_info(info);
break;
#endif
default:
lock_fb_info(info);
if (info->fbops->fb_ioctl)
ret = info->fbops->fb_ioctl(info, cmd, arg);
else
ret = -EIO;
unlock_fb_info(info);
break;
}
return ret;
}
#ifdef CONFIG_AOS_MMAP_ENABLE
static void *fb_mmap(file_t *file, size_t size)
{
fb_info_t *info = file_fb_info(file);
void *(*fb_mmap_fn)(fb_info_t *info, size_t size);
uint64_t *start;
uint32_t len;
if (!info)
return NULL;
if (aos_mutex_lock(&info->mm_lock, AOS_WAIT_FOREVER) != 0) {
LOGE(FB_STR, "Failed to lock mutex (%s).", __func__);
return NULL;
}
fb_mmap_fn = info->fbops->fb_mmap;
if (fb_mmap_fn) {
void *res;
// The framebuffer needs to be accessed decrypted, be sure
// SME protection is removed ahead of the call
res = fb_mmap_fn(info, size);
aos_mutex_unlock(&info->mm_lock);
return res;
}
start = (uint64_t *)&info->fix.smem_start; // pyshical address
len = info->fix.smem_len;
if (start == NULL || len == 0) {
info->fix.smem_start = (uint64_t)k_shmm_map_area(NULL, size);
if (info->screen_base == NULL) {
aos_mutex_unlock(&info->mm_lock);
return NULL;
}
info->screen_base = (uint8_t *)info->fix.smem_start;
info->fix.smem_len = size;
}
aos_mutex_unlock(&info->mm_lock);
return (void *)info->screen_base;
}
#endif
static void put_fb_info(fb_info_t *info)
{
if (info->fbops->fb_destroy)
info->fbops->fb_destroy(info);
}
static int fb_close(file_t *file)
{
fb_info_t *info = file_fb_info(file);
if (!info)
return -ENODEV;
lock_fb_info(info);
if (info->fbops->fb_release)
info->fbops->fb_release(info, 1);
unlock_fb_info(info);
put_fb_info(info);
return 0;
}
static int do_register_framebuffer(fb_info_t *fb_info)
{
int i = 0, ret = 0;
if (num_registered_fb == FB_MAX)
return -ENXIO;
/*set ENDIAN mode, TODO*/
num_registered_fb++;
for (i = 0; i < FB_MAX; i++)
if (!registered_fb[i])
break;
fb_info->node = i;
aos_mutex_new(&fb_info->lock);
aos_mutex_new(&fb_info->mm_lock);
/*register framebuffer device to vfs*/
ret = snprintf(fb_info->path, FB_NAME_LEN, "%s%d", fb_node_path, fb_info->node);
if (ret < 0) {
LOGE(FB_STR, "copy fb path fail (%s)\n", __func__);
return -1;
}
ret = aos_register_driver(fb_info->path, &fb_fops, NULL);
if (unlikely(ret))
return -1;
if (i < FB_MAX)
registered_fb[i] = fb_info;
else
LOGE(FB_STR, "out of bounds (%s)\n", __func__);
return ret;
}
static void do_unregister_framebuffer(fb_info_t *fb_info)
{
registered_fb[fb_info->node] = NULL;
num_registered_fb--;
/* this may free fb info */
put_fb_info(fb_info);
}
int register_framebuffer(fb_info_t *info)
{
int ret;
if (aos_mutex_lock(&fb_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(FB_STR, "Failed to lock mutex (%s).", __func__);
return -1;
}
ret = do_register_framebuffer(info);
aos_mutex_unlock(&fb_mutex);
return ret;
}
void unregister_framebuffer(fb_info_t *info)
{
if (aos_mutex_lock(&fb_mutex, AOS_WAIT_FOREVER) != 0) {
LOGE(FB_STR, "Failed to lock mutex (%s).", __func__);
return;
}
do_unregister_framebuffer(info);
aos_mutex_unlock(&fb_mutex);
}
int fb_init(void)
{
int i;
int ret = 0;
ret = aos_mutex_new((aos_mutex_t *)&fb_mutex);
if (unlikely(ret)) {
printf("create fb mutex failed\n");
return -1;
}
ret = aos_register_driver(fb_node_path, &fb_fops, NULL);
if (unlikely(ret))
return -1;
for (i = 0; i < FB_MAX; i++)
registered_fb[i] = NULL;
return ret;
}
fb_info_t *framebuffer_alloc(size_t size)
{
int fb_info_size = sizeof(fb_info_t);
fb_info_t *info;
char *p;
if (size)
fb_info_size += PADDING;
p = aos_malloc(fb_info_size + size);
if (!p)
return NULL;
info = (fb_info_t *) p;
if (size)
info->par = p + fb_info_size;
return info;
}
/**
* framebuffer_release - marks the structure available for freeing
*
* @info: frame buffer info structure
*
*/
void framebuffer_release(fb_info_t *info)
{
if (!info)
return;
aos_free(info);
}
LEVEL0_DRIVER_ENTRY(fb_init)
| YifuLiu/AliOS-Things | components/drivers/core/fbdev/src/fb.c | C | apache-2.0 | 13,330 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
// #include <fb.h>
#include <fb_rotate.h>
/*rotate 90 degrees clockwise*/
void rotate_cw(const uint8_t *in, uint8_t *out, uint32_t w, uint32_t h)
{
int32_t i, ix, iy, res; /* Default is RGBA8888 */
if (in && out) {
for (iy = 0; iy < h; iy++) {
for (ix = 0; ix < w; ix++)
((uint32_t *)out)[h - 1 - iy + h * ix] = ((uint32_t *)in)[ix + iy * w];
}
}
return;
}
| YifuLiu/AliOS-Things | components/drivers/core/fbdev/src/fb_rotate.c | C | apache-2.0 | 485 |
#ifndef _FT6336_H
#define _FT6336_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#define I2C_ADDR_FT6336 0x38
// Touch Parameter
#define FT6336_PRES_DOWN 0x2
#define FT6336_COORD_UD 0x1
// Registers
#define FT6336_ADDR_DEVICE_MODE 0x00
typedef enum
{
working_mode = 0b000,
factory_mode = 0b100,
} DEVICE_MODE_Enum;
#define FT6336_ADDR_GESTURE_ID 0x01
#define FT6336_ADDR_TD_STATUS 0x02
#define FT6336_ADDR_TOUCH1_EVENT 0x03
#define FT6336_ADDR_TOUCH1_ID 0x05
#define FT6336_ADDR_TOUCH1_X 0x03
#define FT6336_ADDR_TOUCH1_Y 0x05
#define FT6336_ADDR_TOUCH1_WEIGHT 0x07
#define FT6336_ADDR_TOUCH1_MISC 0x08
#define FT6336_ADDR_TOUCH2_EVENT 0x09
#define FT6336_ADDR_TOUCH2_ID 0x0B
#define FT6336_ADDR_TOUCH2_X 0x09
#define FT6336_ADDR_TOUCH2_Y 0x0B
#define FT6336_ADDR_TOUCH2_WEIGHT 0x0D
#define FT6336_ADDR_TOUCH2_MISC 0x0E
#define FT6336_ADDR_THRESHOLD 0x80
#define FT6336_ADDR_FILTER_COE 0x85
#define FT6336_ADDR_CTRL 0x86
typedef enum
{
keep_active_mode = 0,
switch_to_monitor_mode = 1,
} CTRL_MODE_Enum;
#define FT6336_ADDR_TIME_ENTER_MONITOR 0x87
#define FT6336_ADDR_ACTIVE_MODE_RATE 0x88
#define FT6336_ADDR_MONITOR_MODE_RATE 0x89
#define FT6336_ADDR_RADIAN_VALUE 0x91
#define FT6336_ADDR_OFFSET_LEFT_RIGHT 0x92
#define FT6336_ADDR_OFFSET_UP_DOWN 0x93
#define FT6336_ADDR_DISTANCE_LEFT_RIGHT 0x94
#define FT6336_ADDR_DISTANCE_UP_DOWN 0x95
#define FT6336_ADDR_DISTANCE_ZOOM 0x96
#define FT6336_ADDR_LIBRARY_VERSION_H 0xA1
#define FT6336_ADDR_LIBRARY_VERSION_L 0xA2
#define FT6336_ADDR_CHIP_ID 0xA3
#define FT6336_ADDR_G_MODE 0xA4
typedef enum
{
pollingMode = 0,
triggerMode = 1,
} G_MODE_Enum;
#define FT6336_ADDR_POWER_MODE 0xA5
#define FT6336_ADDR_FIRMARE_ID 0xA6
#define FT6336_ADDR_FOCALTECH_ID 0xA8
#define FT6336_ADDR_RELEASE_CODE_ID 0xAF
#define FT6336_ADDR_STATE 0xBC
// Function Specific Type
typedef enum
{
touch = 0,
stream,
release,
} TouchStatusEnum;
typedef struct
{
TouchStatusEnum status;
uint16_t x;
uint16_t y;
} TouchPointType;
typedef struct
{
uint8_t touch_count;
TouchPointType tp[2];
} FT6336_TouchPointType;
// Uncomment to enable debug messages
//#define FT6336_DEBUG
// Define where debug output will be printed
#define DEBUG_PRINTER Serial
// Setup debug printing macros
#ifdef FT6336_DEBUG
#define DEBUG_PRINT(...) \
{ \
printf(__VA_ARGS__); \
}
#define DEBUG_PRINTLN(...) \
{ \
printf(__VA_ARGS__); \
}
#else
#define DEBUG_PRINT(...) \
{ \
}
#define DEBUG_PRINTLN(...) \
{ \
}
#endif
/**************************************************************************/
/*!
@brief FT6336 I2C CTP controller driver
*/
/**************************************************************************/
void FT6336_init(void);
uint8_t FT6336_read_device_mode(void);
void FT6336_write_device_mode(DEVICE_MODE_Enum);
uint8_t FT6336_read_gesture_id(void);
uint8_t FT6336_read_td_status(void);
uint8_t FT6336_read_touch_number(void);
uint16_t FT6336_read_touch1_x(void);
uint16_t FT6336_read_touch1_y(void);
uint8_t FT6336_read_touch1_event(void);
uint8_t FT6336_read_touch1_id(void);
uint8_t FT6336_read_touch1_weight(void);
uint8_t FT6336_read_touch1_misc(void);
uint16_t FT6336_read_touch2_x(void);
uint16_t FT6336_read_touch2_y(void);
uint8_t FT6336_read_touch2_event(void);
uint8_t FT6336_read_touch2_id(void);
uint8_t FT6336_read_touch2_weight(void);
uint8_t FT6336_read_touch2_misc(void);
// Mode Parameter Register
uint8_t FT6336_read_touch_threshold(void);
uint8_t FT6336_read_filter_coefficient(void);
uint8_t FT6336_read_ctrl_mode(void);
void FT6336_write_ctrl_mode(CTRL_MODE_Enum mode);
uint8_t FT6336_read_time_period_enter_monitor(void);
uint8_t FT6336_read_active_rate(void);
uint8_t FT6336_read_monitor_rate(void);
// Gestrue Parameter Register
uint8_t FT6336_read_radian_value(void);
void FT6336_write_radian_value(uint8_t val);
uint8_t FT6336_read_offset_left_right(void);
void FT6336_write_offset_left_right(uint8_t val);
uint8_t FT6336_read_offset_up_down(void);
void FT6336_write_offset_up_down(uint8_t val);
uint8_t FT6336_read_distance_left_right(void);
void FT6336_write_distance_left_right(uint8_t val);
uint8_t FT6336_read_distance_up_down(void);
void FT6336_write_distance_up_down(uint8_t val);
uint8_t FT6336_read_distance_zoom(void);
void FT6336_write_distance_zoom(uint8_t val);
// System Information
uint16_t FT6336_read_library_version(void);
uint8_t FT6336_read_chip_id(void);
uint8_t FT6336_read_g_mode(void);
void FT6336_write_g_mode(G_MODE_Enum mode);
uint8_t FT6336_read_pwrmode(void);
uint8_t FT6336_read_firmware_id(void);
uint8_t FT6336_read_focaltech_id(void);
uint8_t FT6336_read_release_code_id(void);
uint8_t FT6336_read_state(void);
// Scan Function
FT6336_TouchPointType FT6336_scan(void);
typedef struct
{
int status;
uint16_t x;
uint16_t y;
} TouchPointEvent;
TouchPointEvent FT6336_read_point(void);
typedef void (*event_notify_cb)(TouchPointEvent *event);
int uinput_service_init(event_notify_cb func);
#ifdef __cplusplus
}
#endif
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/ft6336/include/ft6336.h | C | apache-2.0 | 5,165 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include "ft6336.h"
#include "aos/hal/i2c.h"
#include "aos/hal/gpio.h"
#include "hal_iomux_haas1000.h"
//#include "uinput.h"
#include "aos/kernel.h"
#define TOUCH_NONE_MAX 3
static i2c_dev_t i2c_dev;
static gpio_dev_t gpio_ft6336_reset;
static gpio_dev_t gpio_ft6336_irq;
static uint32_t ft6336_on_touch_count = 0;
static uint32_t ft6336_no_touch_count = TOUCH_NONE_MAX + 1;
static aos_hdl_t mutex;
event_notify_cb touch_notify;
static FT6336_TouchPointType tp;
// Private Function
uint8_t FT6336_readByte(uint8_t addr)
{
uint8_t data;
hal_i2c_master_send(&i2c_dev, i2c_dev.config.dev_addr, &addr, 1, 1000);
aos_msleep(2);
hal_i2c_master_recv(&i2c_dev, i2c_dev.config.dev_addr, &data, 1, 1000);
return data;
}
void FT6336_writeByte(uint8_t addr, uint8_t data)
{
DEBUG_PRINTLN("")
DEBUG_PRINT("writeI2C reg 0x")
DEBUG_PRINT(addr, HEX)
DEBUG_PRINT(" -> 0x")
DEBUG_PRINTLN(data, HEX)
hal_i2c_master_send(&i2c_dev, i2c_dev.config.dev_addr, &data, 1, 1000);
}
void ft6336_irq_fuc()
{
aos_mutex_lock(&mutex, 10);
ft6336_on_touch_count = 1;
aos_mutex_unlock(&mutex);
}
TouchPointEvent FT6336_read_point()
{
TouchPointEvent event;
event.status = -1;
event.x = 0;
event.y = 0;
if (ft6336_on_touch_count) // irq done
{
tp = FT6336_scan();
if (tp.tp[0].status == 1)
{ //最多支持两个触点
if (ft6336_no_touch_count > 1) // keep no touching
{
ft6336_no_touch_count = 0;
event.status = 1;
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
printf("touch down x %d y %d\n", tp.tp[0].x, tp.tp[0].y);
}
else if (ft6336_no_touch_count == 0 || ft6336_no_touch_count == 1)
{
ft6336_no_touch_count = 0;
event.status = 1;
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
printf("xtouch down x %d y %d\n", tp.tp[0].x, tp.tp[0].y);
}
}
aos_mutex_lock(&mutex, 10);
ft6336_on_touch_count = 0;
aos_mutex_unlock(&mutex);
}
if (ft6336_no_touch_count == TOUCH_NONE_MAX)
{
printf("touch up\n");
event.status = 0;
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
++ft6336_no_touch_count;
}
else if (ft6336_no_touch_count < TOUCH_NONE_MAX)
{
++ft6336_no_touch_count;
}
return event;
}
void ft6336_scan_task()
{
static uint8_t s_tp_down = 0;
while (1)
{
TouchPointEvent event;
event.status = -1;
event.x = 0;
event.y = 0;
if (ft6336_on_touch_count) // irq done
{
tp = FT6336_scan();
if (tp.tp[0].status == 1)
{ //最多支持两个触点
if (ft6336_no_touch_count > 1) // keep no touching
{
ft6336_no_touch_count = 0;
if (s_tp_down == 1)
{
event.status = 2;
}
else
{
event.status = 1;
s_tp_down = 1;
}
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
// printf("touch down x %d y %d\n", tp.tp[0].x, tp.tp[0].y);
// printf("touch down event x %d y %d\n", event.x, event.y);
}
else if (ft6336_no_touch_count == 0 || ft6336_no_touch_count == 1)
{
ft6336_no_touch_count = 0;
if (s_tp_down == 1)
{
event.status = 2;
}
else
{
event.status = 1;
s_tp_down = 1;
}
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
// printf("xtouch down x %d y %d\n", tp.tp[0].x, tp.tp[0].y);
// printf("xtouch down event x %d y %d\n", event.x, event.y);
}
}
aos_mutex_lock(&mutex, 10);
ft6336_on_touch_count = 0;
aos_mutex_unlock(&mutex);
}
if (ft6336_no_touch_count == TOUCH_NONE_MAX)
{
//printf("touch up\n");
event.status = 0;
event.y = 240 - tp.tp[0].x;
event.x = tp.tp[0].y;
++ft6336_no_touch_count;
s_tp_down = 0;
}
else if (ft6336_no_touch_count < TOUCH_NONE_MAX)
{
++ft6336_no_touch_count;
}
//printf("xxnotify event\n");
touch_notify(&event);
aos_msleep(32);
}
aos_mutex_free(&mutex);
}
int uinput_service_init(event_notify_cb func)
{
printf("set callback function\n");
touch_notify = func;
aos_task_new("ft6336_scan_task", ft6336_scan_task, NULL, 5120);
}
void FT6336_init(void)
{
// Initialize I2C
i2c_dev.port = 1;
i2c_dev.config.address_width = I2C_HAL_ADDRESS_WIDTH_7BIT;
i2c_dev.config.freq = I2C_BUS_BIT_RATES_400K;
i2c_dev.config.mode = I2C_MODE_MASTER;
i2c_dev.config.dev_addr = I2C_ADDR_FT6336;
hal_i2c_init(&i2c_dev);
// Int Pin Configuration
aos_mutex_new(&mutex);
gpio_ft6336_reset.port = HAL_IOMUX_PIN_P2_3;
gpio_ft6336_reset.config = OUTPUT_PUSH_PULL;
hal_gpio_init(&gpio_ft6336_reset);
hal_gpio_output_low(&gpio_ft6336_reset);
aos_msleep(10);
hal_gpio_output_high(&gpio_ft6336_reset);
aos_msleep(100);
gpio_ft6336_irq.port = HAL_IOMUX_PIN_P2_2;
gpio_ft6336_irq.config = IRQ_MODE;
hal_gpio_enable_irq(&gpio_ft6336_irq, IRQ_TRIGGER_RISING_EDGE, &ft6336_irq_fuc, NULL);
}
uint8_t FT6336_read_device_mode(void)
{
return (FT6336_readByte(FT6336_ADDR_DEVICE_MODE) & 0x70) >> 4;
}
void FT6336_write_device_mode(DEVICE_MODE_Enum mode)
{
FT6336_writeByte(FT6336_ADDR_DEVICE_MODE, (mode & 0x07) << 4);
}
uint8_t FT6336_read_gesture_id(void)
{
return FT6336_readByte(FT6336_ADDR_GESTURE_ID);
}
uint8_t FT6336_read_td_status(void)
{
return FT6336_readByte(FT6336_ADDR_TD_STATUS);
}
uint8_t FT6336_read_touch_number(void)
{
return FT6336_readByte(FT6336_ADDR_TD_STATUS) & 0x0F;
}
// Touch 1 functions
uint16_t FT6336_read_touch1_x(void)
{
uint8_t read_buf[2];
read_buf[0] = FT6336_readByte(FT6336_ADDR_TOUCH1_X);
read_buf[1] = FT6336_readByte(FT6336_ADDR_TOUCH1_X + 1);
return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
}
uint16_t FT6336_read_touch1_y(void)
{
uint8_t read_buf[2];
read_buf[0] = FT6336_readByte(FT6336_ADDR_TOUCH1_Y);
read_buf[1] = FT6336_readByte(FT6336_ADDR_TOUCH1_Y + 1);
return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
}
uint8_t FT6336_read_touch1_event(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH1_EVENT) >> 6;
}
uint8_t FT6336_read_touch1_id(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH1_ID) >> 4;
}
uint8_t FT6336_read_touch1_weight(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH1_WEIGHT);
}
uint8_t FT6336_read_touch1_misc(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH1_MISC) >> 4;
}
// Touch 2 functions
uint16_t FT6336_read_touch2_x(void)
{
uint8_t read_buf[2];
read_buf[0] = FT6336_readByte(FT6336_ADDR_TOUCH2_X);
read_buf[1] = FT6336_readByte(FT6336_ADDR_TOUCH2_X + 1);
return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
}
uint16_t FT6336_read_touch2_y(void)
{
uint8_t read_buf[2];
read_buf[0] = FT6336_readByte(FT6336_ADDR_TOUCH2_Y);
read_buf[1] = FT6336_readByte(FT6336_ADDR_TOUCH2_Y + 1);
return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
}
uint8_t FT6336_read_touch2_event(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH2_EVENT) >> 6;
}
uint8_t FT6336_read_touch2_id(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH2_ID) >> 4;
}
uint8_t FT6336_read_touch2_weight(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH2_WEIGHT);
}
uint8_t FT6336_read_touch2_misc(void)
{
return FT6336_readByte(FT6336_ADDR_TOUCH2_MISC) >> 4;
}
// Mode Parameter Register
uint8_t FT6336_read_touch_threshold(void)
{
return FT6336_readByte(FT6336_ADDR_THRESHOLD);
}
uint8_t FT6336_read_filter_coefficient(void)
{
return FT6336_readByte(FT6336_ADDR_FILTER_COE);
}
uint8_t FT6336_read_ctrl_mode(void)
{
return FT6336_readByte(FT6336_ADDR_CTRL);
}
void FT6336_write_ctrl_mode(CTRL_MODE_Enum mode)
{
FT6336_writeByte(FT6336_ADDR_CTRL, mode);
}
uint8_t FT6336_read_time_period_enter_monitor(void)
{
return FT6336_readByte(FT6336_ADDR_TIME_ENTER_MONITOR);
}
uint8_t FT6336_read_active_rate(void)
{
return FT6336_readByte(FT6336_ADDR_ACTIVE_MODE_RATE);
}
uint8_t FT6336_read_monitor_rate(void)
{
return FT6336_readByte(FT6336_ADDR_MONITOR_MODE_RATE);
}
// Gesture Parameters
uint8_t FT6336_read_radian_value(void)
{
return FT6336_readByte(FT6336_ADDR_RADIAN_VALUE);
}
void FT6336_write_radian_value(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_RADIAN_VALUE, val);
}
uint8_t FT6336_read_offset_left_right(void)
{
return FT6336_readByte(FT6336_ADDR_OFFSET_LEFT_RIGHT);
}
void FT6336_write_offset_left_right(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_OFFSET_LEFT_RIGHT, val);
}
uint8_t FT6336_read_offset_up_down(void)
{
return FT6336_readByte(FT6336_ADDR_OFFSET_UP_DOWN);
}
void FT6336_write_offset_up_down(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_OFFSET_UP_DOWN, val);
}
uint8_t FT6336_read_distance_left_right(void)
{
return FT6336_readByte(FT6336_ADDR_DISTANCE_LEFT_RIGHT);
}
void FT6336_write_distance_left_right(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_DISTANCE_LEFT_RIGHT, val);
}
uint8_t FT6336_read_distance_up_down(void)
{
return FT6336_readByte(FT6336_ADDR_DISTANCE_UP_DOWN);
}
void FT6336_write_distance_up_down(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_DISTANCE_UP_DOWN, val);
}
uint8_t FT6336_read_distance_zoom(void)
{
return FT6336_readByte(FT6336_ADDR_DISTANCE_ZOOM);
}
void FT6336_write_distance_zoom(uint8_t val)
{
FT6336_writeByte(FT6336_ADDR_DISTANCE_ZOOM, val);
}
// System Information
uint16_t FT6336_read_library_version(void)
{
uint8_t read_buf[2];
read_buf[0] = FT6336_readByte(FT6336_ADDR_LIBRARY_VERSION_H);
read_buf[1] = FT6336_readByte(FT6336_ADDR_LIBRARY_VERSION_L);
return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
}
uint8_t FT6336_read_chip_id(void)
{
return FT6336_readByte(FT6336_ADDR_CHIP_ID);
}
uint8_t FT6336_read_g_mode(void)
{
return FT6336_readByte(FT6336_ADDR_G_MODE);
}
void FT6336_write_g_mode(G_MODE_Enum mode)
{
FT6336_writeByte(FT6336_ADDR_G_MODE, mode);
}
uint8_t FT6336_read_pwrmode(void)
{
return FT6336_readByte(FT6336_ADDR_POWER_MODE);
}
uint8_t FT6336_read_firmware_id(void)
{
return FT6336_readByte(FT6336_ADDR_FIRMARE_ID);
}
uint8_t FT6336_read_focaltech_id(void)
{
return FT6336_readByte(FT6336_ADDR_FOCALTECH_ID);
}
uint8_t FT6336_read_release_code_id(void)
{
return FT6336_readByte(FT6336_ADDR_RELEASE_CODE_ID);
}
uint8_t FT6336_read_state(void)
{
return FT6336_readByte(FT6336_ADDR_STATE);
}
FT6336_TouchPointType FT6336_scan(void)
{
static FT6336_TouchPointType touchPoint;
touchPoint.touch_count = FT6336_read_td_status();
if (touchPoint.touch_count == 0)
{
touchPoint.tp[0].status = release;
touchPoint.tp[1].status = release;
}
// else if (touchPoint.touch_count == 1)
// {
uint8_t id1 = FT6336_read_touch1_id(); // id1 = 0 or 1
touchPoint.tp[id1].status = (touchPoint.tp[id1].status == release) ? touch : stream;
touchPoint.tp[id1].x = FT6336_read_touch1_x();
touchPoint.tp[id1].y = FT6336_read_touch1_y();
touchPoint.tp[~id1 & 0x01].status = release;
// printf("FT6336_read_touch1_event %d\n", FT6336_read_touch1_event());
// printf("FT6336_read_touch2_event %d\n", FT6336_read_touch2_event());
// }
// else
// {
// uint8_t id1 = FT6336_read_touch1_id(); // id1 = 0 or 1
// touchPoint.tp[id1].status = (touchPoint.tp[id1].status == release) ? touch : stream;
// touchPoint.tp[id1].x = FT6336_read_touch1_x();
// touchPoint.tp[id1].y = FT6336_read_touch1_y();
// uint8_t id2 = FT6336_read_touch2_id(); // id2 = 0 or 1(~id1 & 0x01)
// touchPoint.tp[id2].status = (touchPoint.tp[id2].status == release) ? touch : stream;
// touchPoint.tp[id2].x = FT6336_read_touch2_x();
// touchPoint.tp[id2].y = FT6336_read_touch2_y();
// printf("FT6336_read_touch1_event %d\n", FT6336_read_touch1_event());
// printf("FT6336_read_touch2_event %d\n", FT6336_read_touch2_event());
// }
return touchPoint;
}
| YifuLiu/AliOS-Things | components/drivers/external_device/ft6336/src/ft6336.c | C | apache-2.0 | 12,995 |
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
// example based on haaseduk1
#include "hal_iomux_haas1000.h"
#include "ili9341.h"
ili9341_dev_t my_ili9341 = {0};
static void example_ili9341_hw_init(int argc, char **argv)
{
my_ili9341.spi_port = 0;
my_ili9341.spi_freq = 26000000;
my_ili9341.gpio_bgl_id = HAL_GPIO_PIN_P0_6;
my_ili9341.gpio_dc_id = HAL_GPIO_PIN_P0_1;
my_ili9341.gpio_reset_id = HAL_GPIO_PIN_P0_0;
ili9341_hw_init(&my_ili9341);
return;
}
static void example_ili9341_draw_ract(int argc, char **argv)
{
uint16_t value;
value = strtoul(argv[1], NULL, 0);
// ili9341_draw_rect(my_ili9341, 0, 0, ILI9341_WIDTH, ILI9341_HEIGHT, 0xFFFF);
// ili9341_draw_rect(my_ili9341, rand() % 240, rand() % 240, rand() % 240, rand() % 240, rand());
ili9341_draw_rect(my_ili9341, rand() % 240, rand() % 240, rand() % 240, rand() % 240, value);
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(example_ili9341_hw_init, ili9341_hw_init_example, ili9341 init test example)
ALIOS_CLI_CMD_REGISTER(example_ili9341_draw_ract, ili9341_draw_ract_example, ili9341 display test example)
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/ili9341/example/ili9341_example.c | C | apache-2.0 | 1,172 |
#ifndef __ILI9341_H__
#define __ILI9341_H__
#include <stdbool.h>
#include <stdio.h>
#define ILI9341_HEIGHT 240
#define ILI9341_WIDTH 320
typedef struct _ili9341_dev_t {
int spi_port;
int spi_freq;
int gpio_dc_id;
int gpio_reset_id;
int gpio_bgl_id;
int spi_fd;
int gpio_fd;
} ili9341_dev_t;
// Set of commands described in ILI9341 datasheet.
#define ILI9341_NOP 0x00
#define ILI9341_SWRESET 0x01
#define ILI9341_RDDID 0x04
#define ILI9341_RDDST 0x09
#define ILI9341_SLPIN 0x10
#define ILI9341_SLPOUT 0x11
#define ILI9341_PTLON 0x12
#define ILI9341_NORON 0x13
#define ILI9341_RDMODE 0x0A
#define ILI9341_RDMADCTL 0x0B
#define ILI9341_RDPIXFMT 0x0C
#define ILI9341_RDIMGFMT 0x0D
#define ILI9341_RDSELFDIAG 0x0F
#define ILI9341_INVOFF 0x20
#define ILI9341_INVON 0x21
#define ILI9341_GAMMASET 0x26
#define ILI9341_DISPOFF 0x28
#define ILI9341_DISPON 0x29
#define ILI9341_CASET 0x2A
#define ILI9341_PASET 0x2B
#define ILI9341_RAMWR 0x2C
#define ILI9341_RAMRD 0x2E
#define ILI9341_PTLAR 0x30
#define ILI9341_MADCTL 0x36
#define ILI9341_PIXFMT 0x3A
#define ILI9341_FRMCTR1 0xB1
#define ILI9341_FRMCTR2 0xB2
#define ILI9341_FRMCTR3 0xB3
#define ILI9341_INVCTR 0xB4
#define ILI9341_DFUNCTR 0xB6
#define ILI9341_PWCTR1 0xC0
#define ILI9341_PWCTR2 0xC1
#define ILI9341_PWCTR3 0xC2
#define ILI9341_PWCTR4 0xC3
#define ILI9341_PWCTR5 0xC4
#define ILI9341_VMCTR1 0xC5
#define ILI9341_VMCTR2 0xC7
#define ILI9341_PWCTRSEQ 0xCB
#define ILI9341_PWCTRA 0xCD
#define ILI9341_PWCTRB 0xCF
#define ILI9341_RDID1 0xDA
#define ILI9341_RDID2 0xDB
#define ILI9341_RDID3 0xDC
#define ILI9341_RDID4 0xDD
#define ILI9341_GMCTRP1 0xE0
#define ILI9341_GMCTRN1 0xE1
#define ILI9341_DGMCTR1 0xE2
#define ILI9341_DGMCTR2 0xE3
#define ILI9341_TIMCTRA 0xE8
#define ILI9341_TIMCTRB 0xEA
#define ILI9341_ENGMCTR 0xF2
#define ILI9341_INCTR 0xF6
#define ILI9341_PUMP 0xF7
#define ILI9341_MADCTL_MY 0x80
#define ILI9341_MADCTL_MX 0x40
#define ILI9341_MADCTL_MV 0x20
#define ILI9341_MADCTL_ML 0x10
#define ILI9341_MADCTL_RGB 0x00
#define ILI9341_MADCTL_BGR 0x08
#define ILI9341_MADCTL_MH 0x04
int ili9341_hw_init(ili9341_dev_t *ili9341_dev);
static void ili9341_init_command(ili9341_dev_t ili9341_dev);
int ili9341_hw_uninit(ili9341_dev_t *ili9341_dev);
void ili9341_draw_pixel(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t color);
void ili9341_draw_area(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t width,
uint16_t height,
uint8_t *frame);
void ili9341_draw_rect(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t width,
uint16_t height,
uint32_t color);
void ili9341_draw_frame(ili9341_dev_t ili9341_dev, uint8_t *frame);
void ili9341_set_rotation(ili9341_dev_t ili9341_dev, uint16_t rotation);
void ili9341_set_invert(ili9341_dev_t ili9341_dev, uint8_t invert);
void ili9341_enter_sleep(ili9341_dev_t ili9341_dev);
void ili9341_exit_sleep(ili9341_dev_t ili9341_dev);
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/ili9341/include/ili9341.h | C | apache-2.0 | 3,503 |
#ifndef __ILI9341_FB_H__
#define __ILI9341_FB_H__
#include <stdio.h>
#include <stdbool.h>
#include <ili9341.h>
int ili9341_fb_init();
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/ili9341/include/ili9341_fb.h | C | apache-2.0 | 145 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include "ili9341.h"
#include "aos/vfs.h"
#include "vfsdev/gpio_dev.h"
#include "vfsdev/spi_dev.h"
#include <stdio.h>
#include <sys/ioctl.h>
#define SPI_MAX_BLOCK 60000
typedef enum {
CMD = 0,
DAT = 1,
} ili9341_dc_t;
static int gpio_output(int gpio_fd, int gpio_id, bool output)
{
struct gpio_io_config config = {0};
config.id = gpio_id;
config.config = GPIO_IO_OUTPUT | GPIO_IO_OUTPUT_PP;
config.data = output > 0;
int ret = ioctl(gpio_fd, IOC_GPIO_SET, (unsigned long)&config);
return ret;
}
static inline void spi_write(int spi_fd, const void *data, uint32_t size)
{
if (size > SPI_MAX_BLOCK) {
uint32_t rest = size;
uint32_t start = 0;
while (rest > SPI_MAX_BLOCK) {
write(spi_fd, (const void *)(data + start), SPI_MAX_BLOCK);
start += SPI_MAX_BLOCK;
rest -= SPI_MAX_BLOCK;
}
write(spi_fd, (const void *)(data + start), rest);
} else {
write(spi_fd, (const void *)data, (uint16_t)size);
}
}
static inline void ili9341_dc_write_bytes(ili9341_dev_t ili9341_dev,
ili9341_dc_t ili9341_dc,
uint8_t *bytes,
uint32_t size)
{
gpio_output(ili9341_dev.gpio_fd, ili9341_dev.gpio_dc_id, ili9341_dc);
spi_write(ili9341_dev.spi_fd, bytes, size);
}
static inline void ili9341_dc_write_byte(ili9341_dev_t ili9341_dev,
ili9341_dc_t ili9341_dc,
uint8_t byte)
{
gpio_output(ili9341_dev.gpio_fd, ili9341_dev.gpio_dc_id, ili9341_dc);
spi_write(ili9341_dev.spi_fd, &byte, 1);
}
int ili9341_hw_init(ili9341_dev_t *ili9341_dev)
{
int ret = 0;
char spi_dev_name[20] = {0};
sprintf(spi_dev_name, "/dev/spi%d", ili9341_dev->spi_port);
ili9341_dev->spi_fd = open(spi_dev_name, 0);
if (ili9341_dev->spi_fd > 0) {
ret |= ioctl(ili9341_dev->spi_fd, IOC_SPI_SET_CFLAG,
SPI_MODE_3 | SPI_MSB | SPI_MASTER | SPI_DATA_8BIT);
ret |=
ioctl(ili9341_dev->spi_fd, IOC_SPI_SET_FREQ, ili9341_dev->spi_freq);
ret |= ioctl(ili9341_dev->spi_fd, IOC_SPI_SET_SERIAL_LEN, 8);
} else {
printf(
"ili9341 hardware_init fail, open /dev/spi%d fiail, spi_fd is %d\n",
ili9341_dev->spi_port, ili9341_dev->spi_fd);
return 1;
}
ili9341_dev->gpio_fd = open("/dev/gpio", 0);
if (ili9341_dev->gpio_fd > 0) {
ret |= gpio_output(ili9341_dev->gpio_fd, ili9341_dev->gpio_reset_id, 0);
usleep(50 * 1000);
ret |= gpio_output(ili9341_dev->gpio_fd, ili9341_dev->gpio_reset_id, 1);
} else {
printf(
"ili9341 hardware_init fail, open /dev/gpio fail, gpio_fd is %d\n",
ili9341_dev->gpio_fd);
return 1;
}
ili9341_init_command(*ili9341_dev);
printf("ili9341 hardware_init %s\n", ret == 0 ? "success" : "fail");
return ret;
}
static void ili9341_init_command(ili9341_dev_t ili9341_dev)
{
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_SWRESET);
usleep(1000 * 120);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_DISPOFF);
usleep(1000 * 120);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PWCTRB);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0XC1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0X30);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_TIMCTRA);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x85);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x78);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PWCTRSEQ);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x39);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x2C);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x34);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x02);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PUMP);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x20);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_TIMCTRB);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PWCTR1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x23);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PWCTR2);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x10);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_VMCTR1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x3e);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x28);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_VMCTR2);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x86);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_MADCTL);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x48);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PIXFMT);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x55);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_FRMCTR1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x18);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_DFUNCTR);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x08);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x82);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x27);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_ENGMCTR);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_GAMMASET);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x01);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_GMCTRP1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0F);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x31);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x2B);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0C);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0E);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x08);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x4E);
ili9341_dc_write_byte(ili9341_dev, DAT, 0xF1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x37);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x07);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x10);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x03);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0E);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x09);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_GMCTRN1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x00);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0E);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x14);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x03);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x11);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x07);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x31);
ili9341_dc_write_byte(ili9341_dev, DAT, 0xC1);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x48);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x08);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0F);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0C);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x31);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x36);
ili9341_dc_write_byte(ili9341_dev, DAT, 0x0F);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_SLPOUT);
usleep(1000 * 120);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_DISPON);
}
int ili9341_hw_uninit(ili9341_dev_t *ili9341_dev)
{
int ret = 0;
ret |= close(ili9341_dev->spi_fd);
ret |= close(ili9341_dev->gpio_fd);
return ret;
}
static void set_addr_window(ili9341_dev_t ili9341_dev,
uint16_t x_0,
uint16_t y_0,
uint16_t x_1,
uint16_t y_1)
{
uint8_t data[4] = {0};
if (x_0 < x_1) {
data[0] = x_0 >> 8;
data[1] = x_0;
data[2] = x_1 >> 8;
data[3] = x_1;
} else {
data[0] = x_1 >> 8;
data[1] = x_1;
data[2] = x_0 >> 8;
data[3] = x_0;
}
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_CASET);
ili9341_dc_write_bytes(ili9341_dev, DAT, data, 4);
if (y_0 < y_1) {
data[0] = y_0 >> 8;
data[1] = y_0;
data[2] = y_1 >> 8;
data[3] = y_1;
} else {
data[0] = y_1 >> 8;
data[1] = y_1;
data[2] = y_0 >> 8;
data[3] = y_0;
}
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_PASET);
ili9341_dc_write_bytes(ili9341_dev, DAT, data, 4);
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_RAMWR);
}
void ili9341_draw_pixel(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t color)
{
set_addr_window(ili9341_dev, x, y, x, y);
uint8_t data[2] = {color >> 8, color};
ili9341_dc_write_bytes(ili9341_dev, DAT, data, 2);
}
void ili9341_draw_area(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t width,
uint16_t height,
uint8_t *frame)
{
uint16_t *rgb565_frame = (uint16_t *)frame;
set_addr_window(ili9341_dev, x, y, x + width - 1, y + height - 1);
uint32_t bufferSize = width * height * sizeof(uint16_t);
unsigned char *burst_buffer = (unsigned char *)malloc(bufferSize);
for (uint32_t i = 0; i < bufferSize; i++) {
burst_buffer[i] =
(bufferSize % 2) ? rgb565_frame[i] : rgb565_frame[i] >> 8;
}
ili9341_dc_write_bytes(ili9341_dev, DAT, burst_buffer, bufferSize);
free(burst_buffer);
}
void ili9341_draw_rect(ili9341_dev_t ili9341_dev,
uint16_t x,
uint16_t y,
uint16_t width,
uint16_t height,
uint32_t color)
{
set_addr_window(ili9341_dev, x, y, x + width - 1, y + height - 1);
uint32_t bufferSize = width * height * sizeof(uint16_t);
unsigned char *burst_buffer = (unsigned char *)malloc(bufferSize);
for (uint32_t i = 0; i < bufferSize; i++) {
burst_buffer[i] = (bufferSize % 2) ? color : color >> 8;
}
ili9341_dc_write_bytes(ili9341_dev, DAT, burst_buffer, bufferSize);
free(burst_buffer);
}
void ili9341_draw_frame(ili9341_dev_t ili9341_dev, uint8_t *frame)
{
uint16_t *rgb565_frame = (uint16_t *)frame;
uint32_t bufferSize = ILI9341_HEIGHT * ILI9341_WIDTH * sizeof(uint16_t);
unsigned char *burst_buffer = (unsigned char *)malloc(bufferSize);
set_addr_window(ili9341_dev, 0, 0, ILI9341_WIDTH - 1, ILI9341_HEIGHT - 1);
for (uint32_t i = 0; i < bufferSize / 2; i++) {
burst_buffer[2 * i] = rgb565_frame[i] >> 8;
burst_buffer[2 * i + 1] = rgb565_frame[i];
}
ili9341_dc_write_bytes(ili9341_dev, DAT, burst_buffer, bufferSize);
free(burst_buffer);
}
void ili9341_set_rotation(ili9341_dev_t ili9341_dev, uint16_t rotation)
{
ili9341_dc_write_byte(ili9341_dev, CMD, ILI9341_MADCTL);
switch (rotation) {
case 0:
ili9341_dc_write_byte(ili9341_dev, DAT,
ILI9341_MADCTL_MX | ILI9341_MADCTL_BGR);
break;
case 90:
ili9341_dc_write_byte(ili9341_dev, DAT,
ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR);
break;
case 180:
ili9341_dc_write_byte(ili9341_dev, DAT,
ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR);
break;
case 270:
ili9341_dc_write_byte(ili9341_dev, DAT,
ILI9341_MADCTL_MX | ILI9341_MADCTL_MY |
ILI9341_MADCTL_BGR);
break;
default:
break;
}
}
void ili9341_set_invert(ili9341_dev_t ili9341_dev, uint8_t invert)
{
ili9341_dc_write_byte(ili9341_dev, CMD,
invert ? ILI9341_INVON : ILI9341_INVOFF);
}
void ili9341_enter_sleep(ili9341_dev_t ili9341_dev)
{
ili9341_dc_write_byte(ili9341_dev, CMD, 0x28);
usleep(20 * 1000);
ili9341_dc_write_byte(ili9341_dev, CMD, 0x10);
}
void ili9341_exit_sleep(ili9341_dev_t ili9341_dev)
{
ili9341_dc_write_byte(ili9341_dev, CMD, 0x11);
usleep(120 * 1000);
ili9341_dc_write_byte(ili9341_dev, CMD, 0x29);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/ili9341/src/ili9341.c | C | apache-2.0 | 12,659 |
/*
* Copyright (C) 2015-2020 Alibaba Group Holding Limited
*/
#include "ili9341_fb.h"
#include "hal_iomux_haas1000.h"
#include <stdio.h>
#include <sys/ioctl.h>
#include <fb.h>
#include <devicevfs/devicevfs.h>
#define ILI9341_DEVICE_NAME "ili9341_fb"
#define CLCD_WIDTH (ILI9341_WIDTH)
#define CLCD_HEIGHT (ILI9341_HEIGHT)
ili9341_dev_t dev_ili9341 = {0};
struct drv_clcd_device {
uint32_t width;
uint32_t height;
uint8_t *fb;
};
struct drv_clcd_device _lcd;
static int ili9341_open(fb_info_t *info, int user);
static int ili9341_release(fb_info_t *info, int user);
static ssize_t ili9341_read(fb_info_t *info, char *buf, size_t count);
static ssize_t ili9341_write(fb_info_t *info, const char *buf, size_t count);
static int ili9341_blank(int blank, fb_info_t *info);
static int ili9341_pan_display(fb_var_screeninfo_t *var, fb_info_t *info);
static ili9341_ioctl(fb_info_t *info, unsigned int cmd, unsigned long arg);
static int ili9341_mmap(fb_info_t *info, size_t size);
static const fb_ops_t ili9341_ops = {
.fb_open = ili9341_open,
.fb_release = ili9341_release,
.fb_read = ili9341_read,
.fb_write = ili9341_write,
.fb_pan_display = ili9341_pan_display,
.fb_mmap = ili9341_mmap,
.fb_sync = NULL,
.fb_blank = ili9341_blank,
.fb_ioctl = ili9341_ioctl,
};
static const fb_fix_screeninfo_t ili9341_fix = {
.id = ILI9341_DEVICE_NAME,
.xpanstep = 0,
.ypanstep = 0,
.ywrapstep = 0,
.line_length = 0,
.mmio_start = 0, /* Not implemented for char. special, so */
.mmio_len = 0 /* these are set to 0 */
};
static int ili9341_open(fb_info_t *info, int user)
{
return 0;
}
static int ili9341_release(fb_info_t *info, int user)
{
return 0;
}
static ssize_t ili9341_read(fb_info_t *info, char *buf, size_t count)
{
return 0;
}
static ssize_t ili9341_write(fb_info_t *info, const char *buf, size_t count)
{
return 0;
}
static int ili9341_blank(int blank, fb_info_t *info)
{
return 0;
}
static int ili9341_pan_display(fb_var_screeninfo_t *var, fb_info_t *info)
{
printf("ili9341 pan display function:0xp\n", info->screen_buffer);
ili9341_draw_frame(dev_ili9341, info->screen_buffer);
printf("ili9341_draw_frame done\n");
return 0;
}
static int ili9341_mmap(fb_info_t *info, size_t size)
{
// AOS3.3 no need mmap buffer
return 0;
}
static ili9341_ioctl(fb_info_t *info, unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
case FBIO_WAITFORVSYNC:
// ret = aos_sem_wait((aos_sem_t *)&vsync_sem, AOS_WAIT_FOREVER);
// if (unlikely(ret)) {
// printf("input semaphore wait err\n");
// }
break;
case FBIOPUT_PREFB_ADDR:
printf("fbioput buffer setting\n");
info->screen_buffer = (uint8_t *)arg;
printf("ili9341 ili9341_ioctl function:0xp\n", info->screen_buffer);
if (info->screen_buffer == NULL)
return -ENOMEM;
break;
}
return ret;
}
int ili9341_fb_init(void)
{
int ret = 0;
// set fb params to init
dev_ili9341.spi_port = 0;
dev_ili9341.spi_freq = 26000000;
dev_ili9341.gpio_bgl_id = HAL_GPIO_PIN_P0_6;
dev_ili9341.gpio_dc_id = HAL_GPIO_PIN_P0_1;
dev_ili9341.gpio_reset_id = HAL_GPIO_PIN_P0_0;
ili9341_hw_init(&dev_ili9341);
// set rotation
ili9341_set_rotation(dev_ili9341, 90);
// create fbdev params
fb_info_t *info = NULL;
/* memset _lcd to zero */
memset(&_lcd, 0x0, sizeof(_lcd));
_lcd.width = CLCD_WIDTH;
_lcd.height = CLCD_HEIGHT;
info = framebuffer_alloc(0);
/*set var screeninfo*/
memset(&info->var, 0, sizeof(fb_var_screeninfo_t));
info->var.xres = _lcd.width;
info->var.yres = _lcd.height;
info->var.xres_virtual = _lcd.width;
info->var.yres_virtual = _lcd.height;
info->var.width = _lcd.width;
info->var.height = _lcd.height;
info->var.rotate = FB_ROTATE_UD; // rotate 0 degrees wiseclock
#ifdef RGB_888_FORMAT
info->var.bits_per_pixel = 4 * 8;
#endif
#ifdef RGB_565_FORMAT
info->var.bits_per_pixel = 2 * 8;
#endif
info->screen_size = info->var.xres * info->var.yres * info->var.bits_per_pixel / 8;
info->screen_base = _lcd.fb;
/*set fb ops function*/
info->fbops = &ili9341_ops;
/*set fix screeninfo*/
info->fix = ili9341_fix;
info->fix.line_length = info->var.xres * info->var.bits_per_pixel / 8;
ret = register_framebuffer(info);
printf("ili9341 hardware_init %s\n", ret == 0 ? "success" : "fail");
return ret;
}
LEVEL1_DRIVER_ENTRY(ili9341_fb_init)
| YifuLiu/AliOS-Things | components/drivers/external_device/ili9341/src/ili9341_fb.c | C | apache-2.0 | 4,719 |
if (ESP_PLATFORM)
idf_component_register(
SRCS "axp192.c"
INCLUDE_DIRS "."
)
add_definitions("-DAXP192_INCLUDE_SDKCONFIG_H")
endif()
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/axp192/CMakeLists.txt | CMake | apache-2.0 | 161 |
/*
MIT License
Copyright (c) 2019-2021 Mika Tuupola
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-cut-
This file is part of hardware agnostic I2C driver for AXP192:
https://github.com/tuupola/axp192
SPDX-License-Identifier: MIT
Version: 0.6.0-dev
*/
#include <stdarg.h>
#include <stdint.h>
#include "axp192_config.h"
#include "axp192.h"
static axp192_err_t read_coloumb_counter(const axp192_t *axp, float *buffer);
static axp192_err_t read_battery_power(const axp192_t *axp, float *buffer);
static const axp192_init_command_t init_commands[] = {
#ifdef AXP192_INCLUDE_SDKCONFIG_H
/* Currently you have to use menuconfig to be able to use axp192_init() */
{AXP192_DCDC1_VOLTAGE, {CONFIG_AXP192_DCDC1_VOLTAGE}, 1},
{AXP192_DCDC3_VOLTAGE, {CONFIG_AXP192_DCDC3_VOLTAGE}, 1},
{AXP192_LDO23_VOLTAGE, {CONFIG_AXP192_LDO23_VOLTAGE}, 1},
{AXP192_GPIO0_LDOIO0_VOLTAGE, {CONFIG_AXP192_GPIO0_LDOIO0_VOLTAGE}, 1},
{AXP192_DCDC13_LDO23_CONTROL, {CONFIG_AXP192_DCDC13_LDO23_CONTROL}, 1},
{AXP192_EXTEN_DCDC2_CONTROL, {CONFIG_AXP192_EXTEN_DCDC2_CONTROL}, 1},
{AXP192_GPIO0_CONTROL, {CONFIG_AXP192_GPIO0_CONTROL}, 1},
{AXP192_GPIO1_CONTROL, {CONFIG_AXP192_GPIO1_CONTROL}, 1},
{AXP192_GPIO2_CONTROL, {CONFIG_AXP192_GPIO2_CONTROL}, 1},
{AXP192_GPIO43_FUNCTION_CONTROL, {CONFIG_AXP192_GPIO43_FUNCTION_CONTROL}, 1},
{AXP192_ADC_ENABLE_1, {CONFIG_AXP192_ADC_ENABLE_1}, 1},
{AXP192_CHARGE_CONTROL_1, {CONFIG_AXP192_CHARGE_CONTROL_1}, 1},
{AXP192_BATTERY_CHARGE_CONTROL, {CONFIG_AXP192_BATTERY_CHARGE_CONTROL}, 1},
#endif /* AXP192_INCLUDE_SDKCONFIG_H */
/* End of commands. */
{0, {0}, 0xff},
};
axp192_err_t axp192_init(const axp192_t *axp)
{
uint8_t cmd = 0;
axp192_err_t status;
/* Send all the commands. */
while (init_commands[cmd].count != 0xff) {
status = axp->write(
axp->handle,
AXP192_ADDRESS,
init_commands[cmd].command,
init_commands[cmd].data,
init_commands[cmd].count & 0x1f
);
if (AXP192_OK != status) {
return status;
}
cmd++;
}
return AXP192_OK;
}
static axp192_err_t axp192_read_adc(const axp192_t *axp, uint8_t reg, float *buffer)
{
uint8_t tmp[4];
float sensitivity = 1.0;
float offset = 0.0;
axp192_err_t status;
switch (reg) {
case AXP192_ACIN_VOLTAGE:
case AXP192_VBUS_VOLTAGE:
/* 1.7mV per LSB */
sensitivity = 1.7 / 1000;
break;
case AXP192_ACIN_CURRENT:
/* 0.375mA per LSB */
sensitivity = 0.625 / 1000;
break;
case AXP192_VBUS_CURRENT:
/* 0.375mA per LSB */
sensitivity = 0.375 / 1000;
break;
case AXP192_TEMP:
/* 0.1C per LSB, 0x00 = -144.7C */
sensitivity = 0.1;
offset = -144.7;
break;
case AXP192_TS_INPUT:
/* 0.8mV per LSB */
sensitivity = 0.8 / 1000;
break;
case AXP192_BATTERY_POWER:
/* 1.1mV * 0.5mA per LSB */
return read_battery_power(axp, buffer);
break;
case AXP192_BATTERY_VOLTAGE:
/* 1.1mV per LSB */
sensitivity = 1.1 / 1000;
break;
case AXP192_CHARGE_CURRENT:
case AXP192_DISCHARGE_CURRENT:
/* 0.5mV per LSB */
sensitivity = 0.5 / 1000;
break;
case AXP192_APS_VOLTAGE:
/* 1.4mV per LSB */
sensitivity = 1.4 / 1000;
break;
case AXP192_COULOMB_COUNTER:
/* This is currently untested. */
return read_coloumb_counter(axp, buffer);
break;
}
status = axp->read(axp->handle, AXP192_ADDRESS, reg, tmp, 2);
if (AXP192_OK != status) {
return status;
}
*buffer = (((tmp[0] << 4) + tmp[1]) * sensitivity) + offset;
return AXP192_OK;
}
axp192_err_t axp192_read(const axp192_t *axp, uint8_t reg, void *buffer) {
switch (reg) {
case AXP192_ACIN_VOLTAGE:
case AXP192_VBUS_VOLTAGE:
case AXP192_ACIN_CURRENT:
case AXP192_VBUS_CURRENT:
case AXP192_TEMP:
case AXP192_TS_INPUT:
case AXP192_BATTERY_POWER:
case AXP192_BATTERY_VOLTAGE:
case AXP192_CHARGE_CURRENT:
case AXP192_DISCHARGE_CURRENT:
case AXP192_APS_VOLTAGE:
case AXP192_COULOMB_COUNTER:
/* Return ADC value. */
return axp192_read_adc(axp, reg, buffer);
break;
default:
/* Return raw register value. */
return axp->read(axp->handle, AXP192_ADDRESS, reg, buffer, 1);
}
}
axp192_err_t axp192_write(const axp192_t *axp, uint8_t reg, const uint8_t *buffer) {
switch (reg) {
case AXP192_ACIN_VOLTAGE:
case AXP192_VBUS_VOLTAGE:
case AXP192_ACIN_CURRENT:
case AXP192_VBUS_CURRENT:
case AXP192_TEMP:
case AXP192_TS_INPUT:
case AXP192_BATTERY_POWER:
case AXP192_BATTERY_VOLTAGE:
case AXP192_CHARGE_CURRENT:
case AXP192_DISCHARGE_CURRENT:
case AXP192_APS_VOLTAGE:
case AXP192_COULOMB_COUNTER:
/* Read only register. */
return AXP192_ERROR_ENOTSUP;
break;
default:
/* Write raw register value. */
return axp->write(axp->handle, AXP192_ADDRESS, reg, buffer, 1);
}
}
axp192_err_t axp192_ioctl(const axp192_t *axp, int command, ...)
{
uint8_t reg = command >> 8;
uint8_t tmp;
uint16_t argument;
va_list ap;
switch (command) {
case AXP192_COULOMB_COUNTER_ENABLE:
tmp = 0b10000000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_COULOMB_COUNTER_DISABLE:
tmp = 0b00000000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_COULOMB_COUNTER_SUSPEND:
tmp = 0b11000000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_COULOMB_COUNTER_CLEAR:
tmp = 0b10100000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_LDOIO0_ENABLE:
/* 0x02 = LDO */
tmp = 0b00000010;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_LDOIO0_DISABLE:
/* 0x07 = float */
tmp = 0b00000111;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_LDO2_ENABLE:
/* This is currently untested. */
case AXP192_EXTEN_ENABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp |= 0b00000100;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_LDO2_DISABLE:
/* This is currently untested. */
case AXP192_EXTEN_DISABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0b00000100;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_GPIO2_SET_LEVEL:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
va_start(ap, command);
argument = (uint8_t) va_arg(ap, int);
va_end(ap);
if (argument) {
tmp |= 0b00000100;
} else {
tmp &= ~0b00000100;
}
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_LDO3_ENABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp |= 0b00001000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_LDO3_DISABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0b00001000;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_DCDC1_ENABLE:
/* This is currently untested. */
case AXP192_DCDC2_ENABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp |= 0b00000001;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_DCDC1_DISABLE:
/* This is currently untested. */
case AXP192_DCDC2_DISABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0b00000001;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_DCDC3_ENABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp |= 0b00000010;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_DCDC3_DISABLE:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0b00000010;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_GPIO1_SET_LEVEL:
case AXP192_GPIO4_SET_LEVEL:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
va_start(ap, command);
argument = (uint8_t) va_arg(ap, int);
va_end(ap);
if (argument) {
tmp |= 0b00000010;
} else {
tmp &= ~0b00000010;
}
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_GPIO0_SET_LEVEL:
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
va_start(ap, command);
argument = (uint8_t) va_arg(ap, int);
va_end(ap);
if (argument) {
tmp |= 0b00000001;
} else {
tmp &= ~0b00000001;
}
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
case AXP192_DCDC1_SET_VOLTAGE:
case AXP192_DCDC3_SET_VOLTAGE:
va_start(ap, command);
argument = (uint16_t) va_arg(ap, int);
va_end(ap);
/* 700-3500mv 25mV per step */
if ((argument < 700) || (argument > 3500)) {
return AXP192_ERROR_EINVAL;
}
tmp = (argument - 700) / 25;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_DCDC2_SET_VOLTAGE:
va_start(ap, command);
argument = (uint16_t) va_arg(ap, int);
va_end(ap);
/* 700-2275mV 25mV per step */
if ((argument < 700) || (argument > 2275)) {
return AXP192_ERROR_EINVAL;
}
tmp = (argument - 700) / 25;
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_LDO2_SET_VOLTAGE:
va_start(ap, command);
argument = (uint16_t) va_arg(ap, int);
va_end(ap);
/* 1800-3300mV 100mV per step */
if ((argument < 1800) || (argument > 3300)) {
return AXP192_ERROR_EINVAL;
}
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0xf0;
tmp |= (((argument - 1800) / 100) << 4);
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_LDO3_SET_VOLTAGE:
va_start(ap, command);
argument = (uint16_t) va_arg(ap, int);
va_end(ap);
/* 1800-3300mV 100mV per step */
if ((argument < 1800) || (argument > 3300)) {
return AXP192_ERROR_EINVAL;
}
axp->read(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
tmp &= ~0x0f;
tmp |= ((argument - 1800) / 100);
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
/* This is currently untested. */
case AXP192_LDOIO0_SET_VOLTAGE:
va_start(ap, command);
argument = (uint16_t) va_arg(ap, int);
va_end(ap);
/* 1800-3300mV 100mV per step, 2800mV default. */
if ((argument < 1800) || (argument > 3300)) {
return AXP192_ERROR_EINVAL;
}
tmp = (((argument - 1800) / 100) << 4);
return axp->write(axp->handle, AXP192_ADDRESS, reg, &tmp, 1);
break;
}
return AXP192_ERROR_NOTTY;
}
static axp192_err_t read_coloumb_counter(const axp192_t *axp, float *buffer)
{
uint8_t tmp[4];
int32_t coin, coout;
axp192_err_t status;
status = axp->read(axp->handle, AXP192_ADDRESS, AXP192_CHARGE_COULOMB, tmp, sizeof(coin));
if (AXP192_OK != status) {
return status;
}
coin = (tmp[0] << 24) + (tmp[1] << 16) + (tmp[2] << 8) + tmp[3];
status = axp->read(axp->handle, AXP192_ADDRESS, AXP192_DISCHARGE_COULOMB, tmp, sizeof(coout));
if (AXP192_OK != status) {
return status;
}
coout = (tmp[0] << 24) + (tmp[1] << 16) + (tmp[2] << 8) + tmp[3];
/* CmAh = 65536 * 0.5mA *（coin - cout) / 3600 / ADC sample rate */
*buffer = 32768 * (coin - coout) / 3600 / 25;
return AXP192_OK;
}
static axp192_err_t read_battery_power(const axp192_t *axp, float *buffer)
{
uint8_t tmp[4];
float sensitivity;
axp192_err_t status;
/* 1.1mV * 0.5mA per LSB */
sensitivity = 1.1 * 0.5 / 1000;
status = axp->read(axp->handle, AXP192_ADDRESS, AXP192_BATTERY_POWER, tmp, 3);
if (AXP192_OK != status) {
return status;
}
*buffer = (((tmp[0] << 16) + (tmp[1] << 8) + tmp[2]) * sensitivity);
return AXP192_OK;
} | YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/axp192/axp192.c | C | apache-2.0 | 14,282 |
/*
MIT License
Copyright (c) 2019-2021 Mika Tuupola
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-cut-
This file is part of hardware agnostic I2C driver for AXP192:
https://github.com/tuupola/axp192
SPDX-License-Identifier: MIT
Version: 0.6.0-dev
*/
#ifndef _AXP192_H
#define _AXP192_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#define AXP192_ADDRESS (0x34)
/* Power control registers */
#define AXP192_POWER_STATUS (0x00)
#define AXP192_CHARGE_STATUS (0x01)
#define AXP192_OTG_VBUS_STATUS (0x04)
#define AXP192_DATA_BUFFER0 (0x06)
#define AXP192_DATA_BUFFER1 (0x07)
#define AXP192_DATA_BUFFER2 (0x08)
#define AXP192_DATA_BUFFER3 (0x09)
#define AXP192_DATA_BUFFER4 (0x0a)
#define AXP192_DATA_BUFFER5 (0x0b)
/* Output control: 2 EXTEN, 0 DCDC2 */
#define AXP192_EXTEN_DCDC2_CONTROL (0x10)
/* Power output control: 6 EXTEN, 4 DCDC2, 3 LDO3, 2 LDO2, 1 DCDC3, 0 DCDC1 */
#define AXP192_DCDC13_LDO23_CONTROL (0x12)
#define AXP192_DCDC2_VOLTAGE (0x23)
#define AXP192_DCDC2_SLOPE (0x25)
#define AXP192_DCDC1_VOLTAGE (0x26)
#define AXP192_DCDC3_VOLTAGE (0x27)
/* Output voltage control: 7-4 LDO2, 3-0 LDO3 */
#define AXP192_LDO23_VOLTAGE (0x28)
#define AXP192_VBUS_IPSOUT_CHANNEL (0x30)
#define AXP192_SHUTDOWN_VOLTAGE (0x31)
#define AXP192_SHUTDOWN_BATTERY_CHGLED_CONTROL (0x32)
#define AXP192_CHARGE_CONTROL_1 (0x33)
#define AXP192_CHARGE_CONTROL_2 (0x34)
#define AXP192_BATTERY_CHARGE_CONTROL (0x35)
#define AXP192_PEK (0x36)
#define AXP192_DCDC_FREQUENCY (0x37)
#define AXP192_BATTERY_CHARGE_LOW_TEMP (0x38)
#define AXP192_BATTERY_CHARGE_HIGH_TEMP (0x39)
#define AXP192_APS_LOW_POWER1 (0x3A)
#define AXP192_APS_LOW_POWER2 (0x3B)
#define AXP192_BATTERY_DISCHARGE_LOW_TEMP (0x3c)
#define AXP192_BATTERY_DISCHARGE_HIGH_TEMP (0x3d)
#define AXP192_DCDC_MODE (0x80)
#define AXP192_ADC_ENABLE_1 (0x82)
#define AXP192_ADC_ENABLE_2 (0x83)
#define AXP192_ADC_RATE_TS_PIN (0x84)
#define AXP192_GPIO30_INPUT_RANGE (0x85)
#define AXP192_GPIO0_ADC_IRQ_RISING (0x86)
#define AXP192_GPIO0_ADC_IRQ_FALLING (0x87)
#define AXP192_TIMER_CONTROL (0x8a)
#define AXP192_VBUS_MONITOR (0x8b)
#define AXP192_TEMP_SHUTDOWN_CONTROL (0x8f)
/* GPIO control registers */
#define AXP192_GPIO0_CONTROL (0x90)
#define AXP192_GPIO0_LDOIO0_VOLTAGE (0x91)
#define AXP192_GPIO1_CONTROL (0x92)
#define AXP192_GPIO2_CONTROL (0x93)
#define AXP192_GPIO20_SIGNAL_STATUS (0x94)
#define AXP192_GPIO43_FUNCTION_CONTROL (0x95)
#define AXP192_GPIO43_SIGNAL_STATUS (0x96)
#define AXP192_GPIO20_PULLDOWN_CONTROL (0x97)
#define AXP192_PWM1_FREQUENCY (0x98)
#define AXP192_PWM1_DUTY_CYCLE_1 (0x99)
#define AXP192_PWM1_DUTY_CYCLE_2 (0x9a)
#define AXP192_PWM2_FREQUENCY (0x9b)
#define AXP192_PWM2_DUTY_CYCLE_1 (0x9c)
#define AXP192_PWM2_DUTY_CYCLE_2 (0x9d)
#define AXP192_N_RSTO_GPIO5_CONTROL (0x9e)
/* Interrupt control registers */
#define AXP192_ENABLE_CONTROL_1 (0x40)
#define AXP192_ENABLE_CONTROL_2 (0x41)
#define AXP192_ENABLE_CONTROL_3 (0x42)
#define AXP192_ENABLE_CONTROL_4 (0x43)
#define AXP192_ENABLE_CONTROL_5 (0x4a)
#define AXP192_IRQ_STATUS_1 (0x44)
#define AXP192_IRQ_STATUS_2 (0x45)
#define AXP192_IRQ_STATUS_3 (0x46)
#define AXP192_IRQ_STATUS_4 (0x47)
#define AXP192_IRQ_STATUS_5 (0x4d)
/* ADC data registers */
#define AXP192_ACIN_VOLTAGE (0x56)
#define AXP192_ACIN_CURRENT (0x58)
#define AXP192_VBUS_VOLTAGE (0x5a)
#define AXP192_VBUS_CURRENT (0x5c)
#define AXP192_TEMP (0x5e)
#define AXP192_TS_INPUT (0x62)
#define AXP192_GPIO0_VOLTAGE (0x64)
#define AXP192_GPIO1_VOLTAGE (0x66)
#define AXP192_GPIO2_VOLTAGE (0x68)
#define AXP192_GPIO3_VOLTAGE (0x6a)
#define AXP192_BATTERY_POWER (0x70)
#define AXP192_BATTERY_VOLTAGE (0x78)
#define AXP192_CHARGE_CURRENT (0x7a)
#define AXP192_DISCHARGE_CURRENT (0x7c)
#define AXP192_APS_VOLTAGE (0x7e)
#define AXP192_CHARGE_COULOMB (0xb0)
#define AXP192_DISCHARGE_COULOMB (0xb4)
#define AXP192_COULOMB_COUNTER_CONTROL (0xb8)
/* Computed ADC */
#define AXP192_COULOMB_COUNTER (0xff)
/* IOCTL commands */
#define AXP192_READ_POWER_STATUS (0x0001)
#define AXP192_READ_CHARGE_STATUS (0x0101)
#define AXP192_COULOMB_COUNTER_ENABLE (0xb801)
#define AXP192_COULOMB_COUNTER_DISABLE (0xb802)
#define AXP192_COULOMB_COUNTER_SUSPEND (0xb803)
#define AXP192_COULOMB_COUNTER_CLEAR (0xb804)
#define AXP192_LDOIO0_ENABLE (0x9000)
#define AXP192_LDOIO0_DISABLE (0x9001)
#define AXP192_DCDC2_ENABLE (0x1000)
#define AXP192_DCDC2_DISABLE (0x1001)
#define AXP192_EXTEN_ENABLE (0x1002)
#define AXP192_EXTEN_DISABLE (0x1003)
#define AXP192_LDO2_ENABLE (0x1200)
#define AXP192_LDO2_DISABLE (0x1201)
#define AXP192_LDO3_ENABLE (0x1202)
#define AXP192_LDO3_DISABLE (0x1203)
#define AXP192_DCDC1_ENABLE (0x1204)
#define AXP192_DCDC1_DISABLE (0x1205)
#define AXP192_DCDC3_ENABLE (0x1206)
#define AXP192_DCDC3_DISABLE (0x1207)
#define AXP192_DCDC1_SET_VOLTAGE (0x2600)
#define AXP192_DCDC2_SET_VOLTAGE (0x2300)
#define AXP192_DCDC3_SET_VOLTAGE (0x2700)
#define AXP192_LDO2_SET_VOLTAGE (0x2800)
#define AXP192_LDO3_SET_VOLTAGE (0x2801)
#define AXP192_LDOIO0_SET_VOLTAGE (0x9100)
#define AXP192_LOW (0)
#define AXP192_HIGH (1)
#define AXP192_GPIO0_SET_LEVEL (0x9400)
#define AXP192_GPIO1_SET_LEVEL (0x9401)
#define AXP192_GPIO2_SET_LEVEL (0x9402)
#define AXP192_GPIO4_SET_LEVEL (0x9601)
/* Error codes */
#define AXP192_OK (0)
#define AXP192_ERROR_NOTTY (-1)
#define AXP192_ERROR_EINVAL (-22)
#define AXP192_ERROR_ENOTSUP (-95)
typedef struct {
uint8_t command;
uint8_t data[2];
uint8_t count;
} axp192_init_command_t;
/* These should be provided by the HAL. */
typedef struct {
int32_t (* read)(void *handle, uint8_t address, uint8_t reg, uint8_t *buffer, uint16_t size);
int32_t (* write)(void *handle, uint8_t address, uint8_t reg, const uint8_t *buffer, uint16_t size);
void *handle;
} axp192_t;
typedef int32_t axp192_err_t;
axp192_err_t axp192_init(const axp192_t *axp);
axp192_err_t axp192_read(const axp192_t *axp, uint8_t reg, void *buffer);
axp192_err_t axp192_write(const axp192_t *axp, uint8_t reg, const uint8_t *buffer);
axp192_err_t axp192_ioctl(const axp192_t *axp, int command, ...);
#ifdef __cplusplus
}
#endif
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/axp192/axp192.h | C | apache-2.0 | 8,174 |
/*
MIT License
Copyright (c) 2019-2021 Mika Tuupola
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-cut-
This file is part of hardware agnostic I2C driver for AXP192:
https://github.com/tuupola/axp192
SPDX-License-Identifier: MIT
Version: 0.6.0-dev
*/
#ifndef _AXP192_CONFIG_H
#define _AXP192_CONFIG_H
#ifdef __cplusplus
extern "C" {
#endif
#ifdef AXP192_INCLUDE_SDKCONFIG_H
#include "sdkconfig.h"
/* This requires you to run menuconfig first. */
#define CONFIG_AXP192_EXTEN_DCDC2_CONTROL ( \
CONFIG_AXP192_EXTEN_DCDC2_CONTROL_BIT2 | \
CONFIG_AXP192_EXTEN_DCDC2_CONTROL_BIT0 \
)
#define CONFIG_AXP192_DCDC13_LDO23_CONTROL ( \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT6 | \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT4 | \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT3 | \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT2 | \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT1 | \
CONFIG_AXP192_DCDC13_LDO23_CONTROL_BIT0 \
)
#define CONFIG_AXP192_LDO23_VOLTAGE ( \
CONFIG_AXP192_LDO23_VOLTAGE_BIT74 | \
CONFIG_AXP192_LDO23_VOLTAGE_BIT30 \
)
#define CONFIG_AXP192_DCDC1_VOLTAGE ( \
CONFIG_AXP192_DCDC1_VOLTAGE_BIT60 \
)
#define CONFIG_AXP192_DCDC3_VOLTAGE ( \
CONFIG_AXP192_DCDC3_VOLTAGE_BIT60 \
)
#define CONFIG_AXP192_ADC_ENABLE_1 ( \
CONFIG_AXP192_ADC_ENABLE_1_BIT7 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT6 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT5 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT4 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT3 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT2 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT1 | \
CONFIG_AXP192_ADC_ENABLE_1_BIT0 \
)
#define CONFIG_AXP192_CHARGE_CONTROL_1 ( \
CONFIG_AXP192_CHARGE_CONTROL_1_BIT7 | \
CONFIG_AXP192_CHARGE_CONTROL_1_BIT65 | \
CONFIG_AXP192_CHARGE_CONTROL_1_BIT4 | \
CONFIG_AXP192_CHARGE_CONTROL_1_BIT30 \
)
#define CONFIG_AXP192_BATTERY_CHARGE_CONTROL ( \
CONFIG_AXP192_BATTERY_CHARGE_CONTROL_BIT7 | \
CONFIG_AXP192_BATTERY_CHARGE_CONTROL_BIT65 | \
CONFIG_AXP192_BATTERY_CHARGE_CONTROL_BIT10 \
)
#define CONFIG_AXP192_GPIO0_CONTROL ( \
CONFIG_AXP192_GPIO0_CONTROL_BIT20 \
)
#define CONFIG_AXP192_GPIO1_CONTROL ( \
CONFIG_AXP192_GPIO1_CONTROL_BIT20 \
)
#define CONFIG_AXP192_GPIO2_CONTROL ( \
CONFIG_AXP192_GPIO2_CONTROL_BIT20 \
)
#define CONFIG_AXP192_GPIO43_FUNCTION_CONTROL ( \
CONFIG_AXP192_GPIO43_FUNCTION_CONTROL_BIT7 | \
CONFIG_AXP192_GPIO43_FUNCTION_CONTROL_BIT32 | \
CONFIG_AXP192_GPIO43_FUNCTION_CONTROL_BIT10 \
)
#define CONFIG_AXP192_GPIO0_LDOIO0_VOLTAGE ( \
CONFIG_AXP192_GPIO0_LDOIO0_VOLTAGE_BIT74 \
)
#endif /* AXP192_INCLUDE_SDKCONFIG_H */
#ifdef __cplusplus
}
#endif
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/axp192/axp192_config.h | C | apache-2.0 | 3,615 |
COMPONENT_SRCDIRS:=./
COMPONENT_ADD_INCLUDEDIRS:=./
CFLAGS += -DAXP192_INCLUDE_SDKCONFIG_H
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/axp192/component.mk | Makefile | apache-2.0 | 91 |
set(SOURCES "i2c_manager/i2c_manager.c")
set(INCLUDES "i2c_manager")
if (CONFIG_I2C_MANAGER_I2CDEV)
list(APPEND SOURCES "i2cdev/i2cdev.c")
list(APPEND INCLUDES "i2cdev")
endif()
idf_component_register(
SRCS ${SOURCES}
INCLUDE_DIRS ${INCLUDES}
)
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/CMakeLists.txt | CMake | apache-2.0 | 263 |
COMPONENT_SRCDIRS := i2c_manager
COMPONENT_ADD_INCLUDEDIRS := i2c_manager
ifdef CONFIG_I2C_MANAGER_I2CDEV
COMPONENT_ADD_INCLUDEDIRS += i2cdev
COMPONENT_SRCDIRS += i2cdev
endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/component.mk | Makefile | apache-2.0 | 180 |
/*
SPDX-License-Identifier: MIT
MIT License
Copyright (c) 2021 Rop Gonggrijp. Based on esp_i2c_helper by Mika Tuupola.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <stdint.h>
#include <stddef.h>
#include <esp_log.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include <driver/i2c.h>
#include "sdkconfig.h"
#include "i2c_manager.h"
#if defined __has_include
#if __has_include ("esp_idf_version.h")
#include "esp_idf_version.h"
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0)
#define HAS_CLK_FLAGS
#endif
#endif
#endif
static const char* TAG = I2C_TAG;
static SemaphoreHandle_t I2C_FN(_local_mutex)[2] = { NULL, NULL };
static SemaphoreHandle_t* I2C_FN(_mutex) = &I2C_FN(_local_mutex)[0];
static const uint8_t ACK_CHECK_EN = 1;
#if defined (I2C_NUM_0) && defined (CONFIG_I2C_MANAGER_0_ENABLED)
#define I2C_ZERO I2C_NUM_0
#if defined (CONFIG_I2C_MANAGER_0_PULLUPS)
#define I2C_MANAGER_0_PULLUPS true
#else
#define I2C_MANAGER_0_PULLUPS false
#endif
#define I2C_MANAGER_0_TIMEOUT ( CONFIG_I2C_MANAGER_0_TIMEOUT / portTICK_RATE_MS )
#define I2C_MANAGER_0_LOCK_TIMEOUT ( CONFIG_I2C_MANAGER_0_LOCK_TIMEOUT / portTICK_RATE_MS )
#endif
#if defined (I2C_NUM_1) && defined (CONFIG_I2C_MANAGER_1_ENABLED)
#define I2C_ONE I2C_NUM_1
#if defined (CONFIG_I2C_MANAGER_1_PULLUPS)
#define I2C_MANAGER_1_PULLUPS true
#else
#define I2C_MANAGER_1_PULLUPS false
#endif
#define I2C_MANAGER_1_TIMEOUT ( CONFIG_I2C_MANAGER_1_TIMEOUT / portTICK_RATE_MS )
#define I2C_MANAGER_1_LOCK_TIMEOUT ( CONFIG_I2C_MANAGER_1_LOCK_TIMEOUT / portTICK_RATE_MS )
#endif
#define ERROR_PORT(port, fail) { \
ESP_LOGE(TAG, "Invalid port or not configured for I2C Manager: %d", (int)port); \
return fail; \
}
#if defined(I2C_ZERO) && defined (I2C_ONE)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_0 && port != I2C_NUM_1) ERROR_PORT(port, fail);
#else
#if defined(I2C_ZERO)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_0) ERROR_PORT(port, fail);
#elif defined(I2C_ONE)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_1) ERROR_PORT(port, fail);
#else
#define I2C_PORT_CHECK(port, fail) \
ERROR_PORT(port, fail);
#endif
#endif
static void i2c_send_address(i2c_cmd_handle_t cmd, uint16_t addr, i2c_rw_t rw) {
if (addr & I2C_ADDR_10) {
i2c_master_write_byte(cmd, 0xF0 | ((addr & 0x3FF) >> 7) | rw, ACK_CHECK_EN);
i2c_master_write_byte(cmd, addr & 0xFF, ACK_CHECK_EN);
} else {
i2c_master_write_byte(cmd, (addr << 1) | rw, ACK_CHECK_EN);
}
}
static void i2c_send_register(i2c_cmd_handle_t cmd, uint32_t reg) {
if (reg & I2C_REG_16) {
i2c_master_write_byte(cmd, (reg & 0xFF00) >> 8, ACK_CHECK_EN);
}
i2c_master_write_byte(cmd, reg & 0xFF, ACK_CHECK_EN);
}
esp_err_t I2C_FN(_init)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t ret = ESP_OK;
if (I2C_FN(_mutex)[port] == 0) {
ESP_LOGI(TAG, "Starting I2C master at port %d.", (int)port);
I2C_FN(_mutex)[port] = xSemaphoreCreateMutex();
i2c_config_t conf = {0};
#ifdef HAS_CLK_FLAGS
conf.clk_flags = 0;
#endif
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
conf.sda_io_num = CONFIG_I2C_MANAGER_0_SDA;
conf.scl_io_num = CONFIG_I2C_MANAGER_0_SCL;
conf.sda_pullup_en = I2C_MANAGER_0_PULLUPS ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
conf.scl_pullup_en = conf.sda_pullup_en;
conf.master.clk_speed = CONFIG_I2C_MANAGER_0_FREQ_HZ;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
conf.sda_io_num = CONFIG_I2C_MANAGER_1_SDA;
conf.scl_io_num = CONFIG_I2C_MANAGER_1_SCL;
conf.sda_pullup_en = I2C_MANAGER_1_PULLUPS ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
conf.scl_pullup_en = conf.sda_pullup_en;
conf.master.clk_speed = CONFIG_I2C_MANAGER_1_FREQ_HZ;
}
#endif
conf.mode = I2C_MODE_MASTER;
ret = i2c_param_config(port, &conf);
ret |= i2c_driver_install(port, conf.mode, 0, 0, 0);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialise I2C port %d.", (int)port);
ESP_LOGW(TAG, "If it was already open, we'll use it with whatever settings were used "
"to open it. See I2C Manager README for details.");
} else {
ESP_LOGI(TAG, "Initialised port %d (SDA: %d, SCL: %d, speed: %d Hz.)",
port, conf.sda_io_num, conf.scl_io_num, conf.master.clk_speed);
}
}
return ret;
}
esp_err_t I2C_FN(_read)(i2c_port_t port, uint16_t addr, uint32_t reg, uint8_t *buffer, uint16_t size) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t result;
// May seem weird, but init starts with a check if it's needed, no need for that check twice.
I2C_FN(_init)(port);
ESP_LOGV(TAG, "Reading port %d, addr 0x%03x, reg 0x%04x", port, addr, reg);
TickType_t timeout = 0;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = I2C_MANAGER_0_TIMEOUT;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = I2C_MANAGER_1_TIMEOUT;
}
#endif
if (I2C_FN(_lock)((int)port) == ESP_OK) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
if (!(reg & I2C_NO_REG)) {
/* When reading specific register set the addr pointer first. */
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_WRITE);
i2c_send_register(cmd, reg);
}
/* Read size bytes from the current pointer. */
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_READ);
i2c_master_read(cmd, buffer, size, I2C_MASTER_LAST_NACK);
i2c_master_stop(cmd);
result = i2c_master_cmd_begin(port, cmd, timeout);
i2c_cmd_link_delete(cmd);
I2C_FN(_unlock)((int)port);
} else {
ESP_LOGE(TAG, "Lock could not be obtained for port %d.", (int)port);
return ESP_ERR_TIMEOUT;
}
if (result != ESP_OK) {
ESP_LOGW(TAG, "Error: %d", result);
}
ESP_LOG_BUFFER_HEX_LEVEL(TAG, buffer, size, ESP_LOG_VERBOSE);
return result;
}
esp_err_t I2C_FN(_write)(i2c_port_t port, uint16_t addr, uint32_t reg, const uint8_t *buffer, uint16_t size) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t result;
// May seem weird, but init starts with a check if it's needed, no need for that check twice.
I2C_FN(_init)(port);
ESP_LOGV(TAG, "Writing port %d, addr 0x%03x, reg 0x%04x", port, addr, reg);
TickType_t timeout = 0;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = (CONFIG_I2C_MANAGER_0_TIMEOUT) / portTICK_RATE_MS;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = (CONFIG_I2C_MANAGER_1_TIMEOUT) / portTICK_RATE_MS;
}
#endif
if (I2C_FN(_lock)((int)port) == ESP_OK) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_WRITE);
if (!(reg & I2C_NO_REG)) {
i2c_send_register(cmd, reg);
}
i2c_master_write(cmd, (uint8_t *)buffer, size, ACK_CHECK_EN);
i2c_master_stop(cmd);
result = i2c_master_cmd_begin( port, cmd, timeout);
i2c_cmd_link_delete(cmd);
I2C_FN(_unlock)((int)port);
} else {
ESP_LOGE(TAG, "Lock could not be obtained for port %d.", (int)port);
return ESP_ERR_TIMEOUT;
}
if (result != ESP_OK) {
ESP_LOGW(TAG, "Error: %d", result);
}
ESP_LOG_BUFFER_HEX_LEVEL(TAG, buffer, size, ESP_LOG_VERBOSE);
return result;
}
esp_err_t I2C_FN(_close)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
vSemaphoreDelete(I2C_FN(_mutex)[port]);
I2C_FN(_mutex)[port] = NULL;
ESP_LOGI(TAG, "Closing I2C master at port %d", port);
return i2c_driver_delete(port);
}
esp_err_t I2C_FN(_lock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
ESP_LOGV(TAG, "Mutex lock set for %d.", (int)port);
TickType_t timeout;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = (CONFIG_I2C_MANAGER_0_LOCK_TIMEOUT) / portTICK_RATE_MS;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = (CONFIG_I2C_MANAGER_1_LOCK_TIMEOUT) / portTICK_RATE_MS;
}
#endif
if (xSemaphoreTake(I2C_FN(_mutex)[port], timeout) == pdTRUE) {
return ESP_OK;
} else {
ESP_LOGE(TAG, "Removing stale mutex lock from port %d.", (int)port);
I2C_FN(_force_unlock)(port);
return (xSemaphoreTake(I2C_FN(_mutex)[port], timeout) == pdTRUE ? ESP_OK : ESP_FAIL);
}
}
esp_err_t I2C_FN(_unlock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
ESP_LOGV(TAG, "Mutex lock removed for %d.", (int)port);
return (xSemaphoreGive(I2C_FN(_mutex)[port]) == pdTRUE) ? ESP_OK : ESP_FAIL;
}
esp_err_t I2C_FN(_force_unlock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
if (I2C_FN(_mutex)[port]) {
vSemaphoreDelete(I2C_FN(_mutex)[port]);
}
I2C_FN(_mutex)[port] = xSemaphoreCreateMutex();
return ESP_OK;
}
#ifdef I2C_OEM
void I2C_FN(_locking)(void* leader) {
if (leader) {
ESP_LOGI(TAG, "Now following I2C Manager for locking");
I2C_FN(_mutex) = (SemaphoreHandle_t*)leader;
}
}
#else
void* i2c_manager_locking() {
return (void*)i2c_manager_mutex;
}
int32_t i2c_hal_read(void *handle, uint8_t address, uint8_t reg, uint8_t *buffer, uint16_t size) {
return i2c_manager_read(*(i2c_port_t*)handle, address, reg, buffer, size);
}
int32_t i2c_hal_write(void *handle, uint8_t address, uint8_t reg, const uint8_t *buffer, uint16_t size) {
return i2c_manager_write(*(i2c_port_t*)handle, address, reg, buffer, size);
}
static i2c_port_t port_zero = (i2c_port_t)0;
static i2c_port_t port_one = (i2c_port_t)1;
static i2c_hal_t _i2c_hal[2] = {
{&i2c_hal_read, &i2c_hal_write, &port_zero},
{&i2c_hal_read, &i2c_hal_write, &port_one}
};
void* i2c_hal(i2c_port_t port) {
I2C_PORT_CHECK(port, NULL);
return (void*)&_i2c_hal[port];
}
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/i2c_manager/i2c_manager.c | C | apache-2.0 | 10,692 |
#ifndef _I2C_MANAGER_H
#define _I2C_MANAGER_H
#ifdef __cplusplus
extern "C" {
#endif
/*
If you copy the i2c_manager files to your own component instead of
depending on i2c_manager, you MUST uncomment the define below
and put in some short string that identifies your component (such
as 'xyz'). This will cause i2c_manager to create functions named
xyz_i2c_* instead of i2c_manager_*. See README.md for details.
*/
// #define I2C_OEM xyz
// Only here to get the I2C_NUM_0 and I2C_NUM_1 defines.
#include <driver/i2c.h>
#define CONCATX(A, B) A ## B
#define CONCAT(A, B) CONCATX(A, B)
#define STR_LITERAL(s) # s
#define STR_EXPAND(s) STR_LITERAL(s)
#define STR_QUOTE(s) STR_EXPAND(STR_EXPAND(s))
#ifdef I2C_OEM
#define I2C_NAME_PREFIX CONCAT(I2C_OEM, _i2c)
#else
#define I2C_NAME_PREFIX i2c_manager
#endif
#define I2C_TAG STR_EXPAND(I2C_NAME_PREFIX)
#define I2C_FN(s) CONCAT(I2C_NAME_PREFIX, s)
#define I2C_ADDR_10 ( 1 << 15 )
#define I2C_REG_16 ( 1 << 31 )
#define I2C_NO_REG ( 1 << 30 )
esp_err_t I2C_FN(_init)(i2c_port_t port);
esp_err_t I2C_FN(_read)(i2c_port_t port, uint16_t addr, uint32_t reg, uint8_t *buffer, uint16_t size);
esp_err_t I2C_FN(_write)(i2c_port_t port, uint16_t addr, uint32_t reg, const uint8_t *buffer, uint16_t size);
esp_err_t I2C_FN(_close)(i2c_port_t port);
esp_err_t I2C_FN(_lock)(i2c_port_t port);
esp_err_t I2C_FN(_unlock)(i2c_port_t port);
esp_err_t I2C_FN(_force_unlock)(i2c_port_t port);
#ifdef I2C_OEM
void I2C_FN(_locking)(void* leader);
#else
void* i2c_manager_locking();
typedef struct {
int32_t (* read)(void *handle, uint8_t address, uint8_t reg, uint8_t *buffer, uint16_t size);
int32_t (* write)(void *handle, uint8_t address, uint8_t reg, const uint8_t *buffer, uint16_t size);
void *handle;
} i2c_hal_t;
void* i2c_hal(i2c_port_t port);
#endif
#ifdef __cplusplus
}
#endif
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/i2c_manager/i2c_manager.h | C | apache-2.0 | 1,918 |
/*
SPDX-License-Identifier: MIT
MIT License
Copyright (c) 2021 Rop Gonggrijp.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <i2c_manager.h>
#include "i2cdev.h"
#include <esp_log.h>
static const char *TAG = I2C_TAG;
esp_err_t i2cdev_init() {
return ESP_OK;
}
esp_err_t i2cdev_done() {
return ESP_OK;
}
esp_err_t i2c_dev_create_mutex(i2c_dev_t *dev) {
return ESP_OK;
}
esp_err_t i2c_dev_delete_mutex(i2c_dev_t *dev) {
return ESP_OK;
}
esp_err_t i2c_dev_take_mutex(i2c_dev_t *dev) {
return i2c_manager_lock(dev->port);
}
esp_err_t i2c_dev_give_mutex(i2c_dev_t *dev) {
return i2c_manager_unlock(dev->port);
}
esp_err_t i2c_dev_read(const i2c_dev_t *dev, const void *out_data, size_t out_size, void *in_data, size_t in_size) {
if (!dev || !in_data || !in_size) return ESP_ERR_INVALID_ARG;
uint32_t reg;
switch(out_size) {
case 0:
reg = I2C_NO_REG;
break;
case 1:
reg = *(uint8_t*)out_data;
break;
case 2:
reg = *(uint16_t*)out_data | I2C_REG_16;
break;
default:
ESP_LOGE(TAG, "i2cdev emulation only supports 0, 8 and 16-bit registers");
return ESP_ERR_INVALID_ARG;
}
return i2c_manager_read(dev->port, dev->addr, reg, in_data, (uint16_t)in_size);
}
esp_err_t i2c_dev_write(const i2c_dev_t *dev, const void *out_reg, size_t out_reg_size, const void *out_data, size_t out_size) {
if (!dev || !out_data || !out_size) return ESP_ERR_INVALID_ARG;
uint32_t reg;
switch(out_reg_size) {
case 0:
reg = I2C_NO_REG;
break;
case 1:
reg = *(uint8_t*)out_reg;
break;
case 2:
reg = *(uint16_t*)out_reg | I2C_REG_16;
break;
default:
ESP_LOGE(TAG, "i2cdev emulation only supports 0, 8 and 16-bit registers");
return ESP_ERR_INVALID_ARG;
}
return i2c_manager_write(dev->port, dev->addr, reg, out_data, (uint16_t)out_size);
}
esp_err_t i2c_dev_read_reg(const i2c_dev_t *dev, uint8_t reg, void *in_data, size_t in_size) {
return i2c_manager_read(dev->port, dev->addr, reg, in_data, (uint16_t)in_size);
}
esp_err_t i2c_dev_write_reg(const i2c_dev_t *dev, uint8_t reg, const void *out_data, size_t out_size) {
return i2c_manager_write(dev->port, dev->addr, reg, out_data, (uint16_t)out_size);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/i2cdev/i2cdev.c | C | apache-2.0 | 3,403 |
/*
SPDX-License-Identifier: MIT
MIT License
Copyright (c) 2021 Rop Gonggrijp.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef __I2CDEV_H__
#define __I2CDEV_H__
#ifdef __cplusplus
extern "C" {
#endif
// i2cdev-compatible I2C device descriptor.
// Everything but the port and addr is ignored, port properties handled by I2C Manager
typedef struct
{
i2c_port_t port;
i2c_config_t cfg;
uint8_t addr;
SemaphoreHandle_t mutex;
uint32_t timeout_ticks;
} i2c_dev_t;
esp_err_t i2cdev_init();
esp_err_t i2cdev_done();
esp_err_t i2c_dev_create_mutex(i2c_dev_t *dev);
esp_err_t i2c_dev_delete_mutex(i2c_dev_t *dev);
esp_err_t i2c_dev_take_mutex(i2c_dev_t *dev);
esp_err_t i2c_dev_give_mutex(i2c_dev_t *dev);
esp_err_t i2c_dev_read(const i2c_dev_t *dev, const void *out_data,
size_t out_size, void *in_data, size_t in_size);
esp_err_t i2c_dev_write(const i2c_dev_t *dev, const void *out_reg,
size_t out_reg_size, const void *out_data, size_t out_size);
esp_err_t i2c_dev_read_reg(const i2c_dev_t *dev, uint8_t reg,
void *in_data, size_t in_size);
esp_err_t i2c_dev_write_reg(const i2c_dev_t *dev, uint8_t reg,
const void *out_data, size_t out_size);
#ifdef __cplusplus
}
#endif
#endif /* __I2CDEV_H__ */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/i2c_manager/i2cdev/i2cdev.h | C | apache-2.0 | 2,243 |
if(ESP_PLATFORM)
file(GLOB SOURCES *.c)
set(LVGL_INCLUDE_DIRS . lvgl_tft)
list(APPEND SOURCES "lvgl_tft/disp_driver.c")
list(APPEND SOURCES "lvgl_tft/esp_lcd_backlight.c")
# Include only the source file of the selected
# display controller.
if(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341)
list(APPEND SOURCES "lvgl_tft/ili9341.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481)
list(APPEND SOURCES "lvgl_tft/ili9481.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486)
list(APPEND SOURCES "lvgl_tft/ili9486.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488)
list(APPEND SOURCES "lvgl_tft/ili9488.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789)
list(APPEND SOURCES "lvgl_tft/st7789.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S)
list(APPEND SOURCES "lvgl_tft/st7735s.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S)
list(APPEND SOURCES "lvgl_tft/st7796s.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357)
list(APPEND SOURCES "lvgl_tft/hx8357.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107)
list(APPEND SOURCES "lvgl_tft/sh1107.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306)
list(APPEND SOURCES "lvgl_tft/ssd1306.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
list(APPEND SOURCES "lvgl_tft/EVE_commands.c")
list(APPEND SOURCES "lvgl_tft/FT81x.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820)
list(APPEND SOURCES "lvgl_tft/il3820.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A)
list(APPEND SOURCES "lvgl_tft/jd79653a.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D)
list(APPEND SOURCES "lvgl_tft/uc8151d.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875)
list(APPEND SOURCES "lvgl_tft/ra8875.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01)
list(APPEND SOURCES "lvgl_tft/GC9A01.c")
elseif(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C)
list(APPEND SOURCES "lvgl_tft/ili9163c.c")
else()
message(WARNING "LVGL ESP32 drivers: Display controller not defined.")
endif()
if(CONFIG_LV_TFT_DISPLAY_PROTOCOL_SPI)
list(APPEND SOURCES "lvgl_tft/disp_spi.c")
endif()
# Add touch driver to compilation only if it is selected in menuconfig
if(CONFIG_LV_TOUCH_CONTROLLER)
list(APPEND SOURCES "lvgl_touch/touch_driver.c")
list(APPEND LVGL_INCLUDE_DIRS lvgl_touch)
# Include only the source file of the selected
# touch controller.
if(CONFIG_LV_TOUCH_CONTROLLER_XPT2046)
list(APPEND SOURCES "lvgl_touch/xpt2046.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_FT6X06)
list(APPEND SOURCES "lvgl_touch/ft6x36.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_STMPE610)
list(APPEND SOURCES "lvgl_touch/stmpe610.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_ADCRAW)
list(APPEND SOURCES "lvgl_touch/adcraw.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_FT81X)
list(APPEND SOURCES "lvgl_touch/FT81x.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_RA8875)
list(APPEND SOURCES "lvgl_touch/ra8875_touch.c")
elseif(CONFIG_LV_TOUCH_CONTROLLER_GT911)
list(APPEND SOURCES "lvgl_touch/gt911.c")
endif()
if(CONFIG_LV_TOUCH_DRIVER_PROTOCOL_SPI)
list(APPEND SOURCES "lvgl_touch/tp_spi.c")
endif()
endif()
if(CONFIG_LV_I2C)
list(APPEND SOURCES "lvgl_i2c/i2c_manager.c")
endif()
idf_component_register(SRCS ${SOURCES}
INCLUDE_DIRS ${LVGL_INCLUDE_DIRS}
REQUIRES lvgl)
target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_LVGL_H_INCLUDE_SIMPLE")
else()
message(FATAL_ERROR "LVGL ESP32 drivers: ESP_PLATFORM is not defined. Try reinstalling ESP-IDF.")
endif()
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/CMakeLists.txt | CMake | apache-2.0 | 3,579 |
# LVGL ESP32 drivers
# Define sources and include dirs
COMPONENT_SRCDIRS := . lvgl_tft lvgl_touch lvgl_i2c
COMPONENT_ADD_INCLUDEDIRS := .
# LVGL is supposed to be used as a ESP-IDF component
# -> lvlg is already in the include path
# -> we use simple include
CFLAGS += -DLV_LVGL_H_INCLUDE_SIMPLE
# TFT display drivers
COMPONENT_ADD_INCLUDEDIRS += lvgl_tft
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341),lvgl_tft/ili9341.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481),lvgl_tft/ili9481.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486),lvgl_tft/ili9486.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488),lvgl_tft/ili9488.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789),lvgl_tft/st7789.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S),lvgl_tft/st7735s.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S),lvgl_tft/st7796s.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357),lvgl_tft/hx8357.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107),lvgl_tft/sh1107.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306),lvgl_tft/ssd1306.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X),lvgl_tft/EVE_commands.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X),lvgl_tft/FT81x.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820),lvgl_tft/il3820.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A),lvgl_tft/jd79653a.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D),lvgl_tft/uc8151d.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875),lvgl_tft/ra8875.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01),lvgl_tft/GC9A01.o)
$(call compile_only_if,$(CONFIG_LV_TFT_DISPLAY_PROTOCOL_SPI),lvgl_tft/disp_spi.o)
# Touch controller drivers
COMPONENT_ADD_INCLUDEDIRS += lvgl_touch
$(call compile_only_if,$(CONFIG_LV_TOUCH_CONTROLLER),lvgl_touch/touch_driver.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_XPT2046)), lvgl_touch/xpt2046.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_FT6X06)), lvgl_touch/ft6x36.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_STMPE610)), lvgl_touch/stmpe610.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_ADCRAW)), lvgl_touch/adcraw.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_FT81X)), lvgl_touch/FT81x.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_CONTROLLER_RA8875)), lvgl_touch/ra8875_touch.o)
$(call compile_only_if,$(and $(CONFIG_LV_TOUCH_CONTROLLER),$(CONFIG_LV_TOUCH_DRIVER_PROTOCOL_SPI)), lvgl_touch/tp_spi.o)
# I2C Manager
$(call compile_only_if,$(CONFIG_LV_I2C), lvgl_i2c/i2c_manager.o)
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/component.mk | Makefile | apache-2.0 | 2,986 |
/**
* @file lvgl_helpers.c
*
*/
/*********************
* INCLUDES
*********************/
#include "sdkconfig.h"
#include "lvgl_helpers.h"
#include "esp_log.h"
#include "lvgl_tft/disp_spi.h"
#include "lvgl_touch/tp_spi.h"
#include "lvgl_spi_conf.h"
#include "lvgl_i2c/i2c_manager.h"
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
#define TAG "lvgl_helpers"
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/* Interface and driver initialization */
void lvgl_driver_init(void)
{
/* Since LVGL v8 LV_HOR_RES_MAX and LV_VER_RES_MAX are not defined, so
* print it only if they are defined. */
#if (LVGL_VERSION_MAJOR < 8)
ESP_LOGI(TAG, "Display hor size: %d, ver size: %d", LV_HOR_RES_MAX, LV_VER_RES_MAX);
#endif
ESP_LOGI(TAG, "Display buffer size: %d", DISP_BUF_SIZE);
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
ESP_LOGI(TAG, "Initializing SPI master for FT81X");
lvgl_spi_driver_init(TFT_SPI_HOST,
DISP_SPI_MISO, DISP_SPI_MOSI, DISP_SPI_CLK,
SPI_BUS_MAX_TRANSFER_SZ, 1,
DISP_SPI_IO2, DISP_SPI_IO3);
disp_spi_add_device(TFT_SPI_HOST);
disp_driver_init();
#if defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
touch_driver_init();
#endif
return;
#endif
#if defined (SHARED_SPI_BUS)
ESP_LOGI(TAG, "Initializing shared SPI master");
lvgl_spi_driver_init(TFT_SPI_HOST,
TP_SPI_MISO, DISP_SPI_MOSI, DISP_SPI_CLK,
SPI_BUS_MAX_TRANSFER_SZ, 1,
-1, -1);
disp_spi_add_device(TFT_SPI_HOST);
tp_spi_add_device(TOUCH_SPI_HOST);
disp_driver_init();
touch_driver_init();
return;
#endif
/* Display controller initialization */
#if defined CONFIG_LV_TFT_DISPLAY_PROTOCOL_SPI
ESP_LOGI(TAG, "Initializing SPI master for display");
lvgl_spi_driver_init(TFT_SPI_HOST,
DISP_SPI_MISO, DISP_SPI_MOSI, DISP_SPI_CLK,
SPI_BUS_MAX_TRANSFER_SZ, 1,
DISP_SPI_IO2, DISP_SPI_IO3);
disp_spi_add_device(TFT_SPI_HOST);
disp_driver_init();
#elif defined (CONFIG_LV_I2C_DISPLAY)
disp_driver_init();
#else
#error "No protocol defined for display controller"
#endif
/* Touch controller initialization */
#if CONFIG_LV_TOUCH_CONTROLLER != TOUCH_CONTROLLER_NONE
#if defined (CONFIG_LV_TOUCH_DRIVER_PROTOCOL_SPI)
ESP_LOGI(TAG, "Initializing SPI master for touch");
lvgl_spi_driver_init(TOUCH_SPI_HOST,
TP_SPI_MISO, TP_SPI_MOSI, TP_SPI_CLK,
0 /* Defaults to 4094 */, 2,
-1, -1);
tp_spi_add_device(TOUCH_SPI_HOST);
touch_driver_init();
#elif defined (CONFIG_LV_I2C_TOUCH)
touch_driver_init();
#elif defined (CONFIG_LV_TOUCH_DRIVER_ADC)
touch_driver_init();
#elif defined (CONFIG_LV_TOUCH_DRIVER_DISPLAY)
touch_driver_init();
#else
#error "No protocol defined for touch controller"
#endif
#else
#endif
}
/* Initialize spi bus master
*
* NOTE: dma_chan type and value changed to int instead of spi_dma_chan_t
* for backwards compatibility with ESP-IDF versions prior v4.3.
*
* We could use the ESP_IDF_VERSION_VAL macro available in the "esp_idf_version.h"
* header available since ESP-IDF v4.
*/
bool lvgl_spi_driver_init(int host,
int miso_pin, int mosi_pin, int sclk_pin,
int max_transfer_sz,
int dma_channel,
int quadwp_pin, int quadhd_pin)
{
int dma_chan = 0 /* SPI_DMA_DISABLED */;
#if defined (CONFIG_IDF_TARGET_ESP32)
assert((SPI_HOST <= host) && (VSPI_HOST >= host));
const char *spi_names[] = {
"SPI_HOST", "HSPI_HOST", "VSPI_HOST"
};
dma_chan = dma_channel;
#elif defined (CONFIG_IDF_TARGET_ESP32S2)
assert((SPI_HOST <= host) && (HSPI_HOST >= host));
const char *spi_names[] = {
"SPI_HOST", "", ""
};
dma_chan = dma_channel;
#elif defined (CONFIG_IDF_TARGET_ESP32C3)
assert((SPI1_HOST <= host) && (SPI3_HOST >= host));
const char *spi_names[] = {
"SPI1_HOST", "SPI2_HOST", "SPI3_HOST"
};
dma_chan = 3 /* SPI_DMA_CH_AUTO */;
#else
#error "Target chip not selected"
#endif
ESP_LOGI(TAG, "Configuring SPI host %s (%d)", spi_names[host], host);
ESP_LOGI(TAG, "MISO pin: %d, MOSI pin: %d, SCLK pin: %d, IO2/WP pin: %d, IO3/HD pin: %d",
miso_pin, mosi_pin, sclk_pin, quadwp_pin, quadhd_pin);
ESP_LOGI(TAG, "Max transfer size: %d (bytes)", max_transfer_sz);
spi_bus_config_t buscfg = {
.miso_io_num = miso_pin,
.mosi_io_num = mosi_pin,
.sclk_io_num = sclk_pin,
.quadwp_io_num = quadwp_pin,
.quadhd_io_num = quadhd_pin,
.max_transfer_sz = max_transfer_sz
};
ESP_LOGI(TAG, "Initializing SPI bus...");
esp_err_t ret = spi_bus_initialize(host, &buscfg, dma_chan);
assert(ret == ESP_OK);
return ESP_OK != ret;
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_helpers.c | C | apache-2.0 | 5,157 |
/**
* @file lvgl_helpers.h
*/
#ifndef LVGL_HELPERS_H
#define LVGL_HELPERS_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include "lvgl_spi_conf.h"
#include "lvgl_tft/disp_driver.h"
#include "lvgl_tft/esp_lcd_backlight.h"
#include "lvgl_touch/touch_driver.h"
/*********************
* DEFINES
*********************/
/* DISP_BUF_SIZE value doesn't have an special meaning, but it's the size
* of the buffer(s) passed to LVGL as display buffers. The default values used
* were the values working for the contributor of the display controller.
*
* As LVGL supports partial display updates the DISP_BUF_SIZE doesn't
* necessarily need to be equal to the display size.
*
* When using RGB displays the display buffer size will also depends on the
* color format being used, for RGB565 each pixel needs 2 bytes.
* When using the mono theme, the display pixels can be represented in one bit,
* so the buffer size can be divided by 8, e.g. see SSD1306 display size. */
#if defined (CONFIG_CUSTOM_DISPLAY_BUFFER_SIZE)
#define DISP_BUF_SIZE CONFIG_CUSTOM_DISPLAY_BUFFER_BYTES
#else
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789)
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * LV_VER_RES_MAX)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
#if defined (CONFIG_LV_THEME_MONO)
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * (LV_VER_RES_MAX / 8))
#else
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * LV_VER_RES_MAX)
#endif
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
#define DISP_BUF_LINES 40
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * DISP_BUF_LINES)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820)
#define DISP_BUF_SIZE (LV_VER_RES_MAX * IL3820_COLUMNS)
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01)
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A)
#define DISP_BUF_SIZE ((LV_VER_RES_MAX * LV_VER_RES_MAX) / 8) // 5KB
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D)
#define DISP_BUF_SIZE ((LV_VER_RES_MAX * LV_VER_RES_MAX) / 8) // 2888 bytes
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#else
#error "No display controller selected"
#endif
#endif
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void lvgl_i2c_locking(void* leader);
/* Initialize detected SPI and I2C bus and devices */
void lvgl_driver_init(void);
/* Initialize SPI master */
bool lvgl_spi_driver_init(int host, int miso_pin, int mosi_pin, int sclk_pin,
int max_transfer_sz, int dma_channel, int quadwp_pin, int quadhd_pin);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LVGL_HELPERS_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_helpers.h | C | apache-2.0 | 3,763 |
/*
SPDX-License-Identifier: MIT
MIT License
Copyright (c) 2021 Rop Gonggrijp. Based on esp_i2c_helper by Mika Tuupola.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include <stdint.h>
#include <stddef.h>
#include <esp_log.h>
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include <driver/i2c.h>
#include "sdkconfig.h"
#include "i2c_manager.h"
#if defined __has_include
#if __has_include ("esp_idf_version.h")
#include "esp_idf_version.h"
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0)
#define HAS_CLK_FLAGS
#endif
#endif
#endif
static const char* TAG = I2C_TAG;
static SemaphoreHandle_t I2C_FN(_local_mutex)[2] = { NULL, NULL };
static SemaphoreHandle_t* I2C_FN(_mutex) = &I2C_FN(_local_mutex)[0];
static const uint8_t ACK_CHECK_EN = 1;
#if defined (I2C_NUM_0) && defined (CONFIG_I2C_MANAGER_0_ENABLED)
#define I2C_ZERO I2C_NUM_0
#if defined (CONFIG_I2C_MANAGER_0_PULLUPS)
#define I2C_MANAGER_0_PULLUPS true
#else
#define I2C_MANAGER_0_PULLUPS false
#endif
#define I2C_MANAGER_0_TIMEOUT ( CONFIG_I2C_MANAGER_0_TIMEOUT / portTICK_RATE_MS )
#define I2C_MANAGER_0_LOCK_TIMEOUT ( CONFIG_I2C_MANAGER_0_LOCK_TIMEOUT / portTICK_RATE_MS )
#endif
#if defined (I2C_NUM_1) && defined (CONFIG_I2C_MANAGER_1_ENABLED)
#define I2C_ONE I2C_NUM_1
#if defined (CONFIG_I2C_MANAGER_1_PULLUPS)
#define I2C_MANAGER_1_PULLUPS true
#else
#define I2C_MANAGER_1_PULLUPS false
#endif
#define I2C_MANAGER_1_TIMEOUT ( CONFIG_I2C_MANAGER_1_TIMEOUT / portTICK_RATE_MS )
#define I2C_MANAGER_1_LOCK_TIMEOUT ( CONFIG_I2C_MANAGER_1_LOCK_TIMEOUT / portTICK_RATE_MS )
#endif
#define ERROR_PORT(port, fail) { \
ESP_LOGE(TAG, "Invalid port or not configured for I2C Manager: %d", (int)port); \
return fail; \
}
#if defined(I2C_ZERO) && defined (I2C_ONE)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_0 && port != I2C_NUM_1) ERROR_PORT(port, fail);
#else
#if defined(I2C_ZERO)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_0) ERROR_PORT(port, fail);
#elif defined(I2C_ONE)
#define I2C_PORT_CHECK(port, fail) \
if (port != I2C_NUM_1) ERROR_PORT(port, fail);
#else
#define I2C_PORT_CHECK(port, fail) \
ERROR_PORT(port, fail);
#endif
#endif
static void i2c_send_address(i2c_cmd_handle_t cmd, uint16_t addr, i2c_rw_t rw) {
if (addr & I2C_ADDR_10) {
i2c_master_write_byte(cmd, 0xF0 | ((addr & 0x3FF) >> 7) | rw, ACK_CHECK_EN);
i2c_master_write_byte(cmd, addr & 0xFF, ACK_CHECK_EN);
} else {
i2c_master_write_byte(cmd, (addr << 1) | rw, ACK_CHECK_EN);
}
}
static void i2c_send_register(i2c_cmd_handle_t cmd, uint32_t reg) {
if (reg & I2C_REG_16) {
i2c_master_write_byte(cmd, (reg & 0xFF00) >> 8, ACK_CHECK_EN);
}
i2c_master_write_byte(cmd, reg & 0xFF, ACK_CHECK_EN);
}
esp_err_t I2C_FN(_init)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t ret = ESP_OK;
if (I2C_FN(_mutex)[port] == 0) {
ESP_LOGI(TAG, "Starting I2C master at port %d.", (int)port);
I2C_FN(_mutex)[port] = xSemaphoreCreateMutex();
i2c_config_t conf = {0};
#ifdef HAS_CLK_FLAGS
conf.clk_flags = 0;
#endif
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
conf.sda_io_num = CONFIG_I2C_MANAGER_0_SDA;
conf.scl_io_num = CONFIG_I2C_MANAGER_0_SCL;
conf.sda_pullup_en = I2C_MANAGER_0_PULLUPS ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
conf.scl_pullup_en = conf.sda_pullup_en;
conf.master.clk_speed = CONFIG_I2C_MANAGER_0_FREQ_HZ;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
conf.sda_io_num = CONFIG_I2C_MANAGER_1_SDA;
conf.scl_io_num = CONFIG_I2C_MANAGER_1_SCL;
conf.sda_pullup_en = I2C_MANAGER_1_PULLUPS ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
conf.scl_pullup_en = conf.sda_pullup_en;
conf.master.clk_speed = CONFIG_I2C_MANAGER_1_FREQ_HZ;
}
#endif
conf.mode = I2C_MODE_MASTER;
ret = i2c_param_config(port, &conf);
ret |= i2c_driver_install(port, conf.mode, 0, 0, 0);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialise I2C port %d.", (int)port);
ESP_LOGW(TAG, "If it was already open, we'll use it with whatever settings were used "
"to open it. See I2C Manager README for details.");
} else {
ESP_LOGI(TAG, "Initialised port %d (SDA: %d, SCL: %d, speed: %d Hz.)",
port, conf.sda_io_num, conf.scl_io_num, conf.master.clk_speed);
}
}
return ret;
}
esp_err_t I2C_FN(_read)(i2c_port_t port, uint16_t addr, uint32_t reg, uint8_t *buffer, uint16_t size) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t result;
// May seem weird, but init starts with a check if it's needed, no need for that check twice.
I2C_FN(_init)(port);
ESP_LOGV(TAG, "Reading port %d, addr 0x%03x, reg 0x%04x", port, addr, reg);
TickType_t timeout = 0;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = I2C_MANAGER_0_TIMEOUT;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = I2C_MANAGER_1_TIMEOUT;
}
#endif
if (I2C_FN(_lock)((int)port) == ESP_OK) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
if (!(reg & I2C_NO_REG)) {
/* When reading specific register set the addr pointer first. */
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_WRITE);
i2c_send_register(cmd, reg);
}
/* Read size bytes from the current pointer. */
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_READ);
i2c_master_read(cmd, buffer, size, I2C_MASTER_LAST_NACK);
i2c_master_stop(cmd);
result = i2c_master_cmd_begin(port, cmd, timeout);
i2c_cmd_link_delete(cmd);
I2C_FN(_unlock)((int)port);
} else {
ESP_LOGE(TAG, "Lock could not be obtained for port %d.", (int)port);
return ESP_ERR_TIMEOUT;
}
if (result != ESP_OK) {
ESP_LOGW(TAG, "Error: %d", result);
}
ESP_LOG_BUFFER_HEX_LEVEL(TAG, buffer, size, ESP_LOG_VERBOSE);
return result;
}
esp_err_t I2C_FN(_write)(i2c_port_t port, uint16_t addr, uint32_t reg, const uint8_t *buffer, uint16_t size) {
I2C_PORT_CHECK(port, ESP_FAIL);
esp_err_t result;
// May seem weird, but init starts with a check if it's needed, no need for that check twice.
I2C_FN(_init)(port);
ESP_LOGV(TAG, "Writing port %d, addr 0x%03x, reg 0x%04x", port, addr, reg);
TickType_t timeout = 0;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = (CONFIG_I2C_MANAGER_0_TIMEOUT) / portTICK_RATE_MS;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = (CONFIG_I2C_MANAGER_1_TIMEOUT) / portTICK_RATE_MS;
}
#endif
if (I2C_FN(_lock)((int)port) == ESP_OK) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_send_address(cmd, addr, I2C_MASTER_WRITE);
if (!(reg & I2C_NO_REG)) {
i2c_send_register(cmd, reg);
}
i2c_master_write(cmd, (uint8_t *)buffer, size, ACK_CHECK_EN);
i2c_master_stop(cmd);
result = i2c_master_cmd_begin( port, cmd, timeout);
i2c_cmd_link_delete(cmd);
I2C_FN(_unlock)((int)port);
} else {
ESP_LOGE(TAG, "Lock could not be obtained for port %d.", (int)port);
return ESP_ERR_TIMEOUT;
}
if (result != ESP_OK) {
ESP_LOGW(TAG, "Error: %d", result);
}
ESP_LOG_BUFFER_HEX_LEVEL(TAG, buffer, size, ESP_LOG_VERBOSE);
return result;
}
esp_err_t I2C_FN(_close)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
vSemaphoreDelete(I2C_FN(_mutex)[port]);
I2C_FN(_mutex)[port] = NULL;
ESP_LOGI(TAG, "Closing I2C master at port %d", port);
return i2c_driver_delete(port);
}
esp_err_t I2C_FN(_lock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
ESP_LOGV(TAG, "Mutex lock set for %d.", (int)port);
TickType_t timeout;
#if defined (I2C_ZERO)
if (port == I2C_NUM_0) {
timeout = (CONFIG_I2C_MANAGER_0_LOCK_TIMEOUT) / portTICK_RATE_MS;
}
#endif
#if defined (I2C_ONE)
if (port == I2C_NUM_1) {
timeout = (CONFIG_I2C_MANAGER_1_LOCK_TIMEOUT) / portTICK_RATE_MS;
}
#endif
if (xSemaphoreTake(I2C_FN(_mutex)[port], timeout) == pdTRUE) {
return ESP_OK;
} else {
ESP_LOGE(TAG, "Removing stale mutex lock from port %d.", (int)port);
I2C_FN(_force_unlock)(port);
return (xSemaphoreTake(I2C_FN(_mutex)[port], timeout) == pdTRUE ? ESP_OK : ESP_FAIL);
}
}
esp_err_t I2C_FN(_unlock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
ESP_LOGV(TAG, "Mutex lock removed for %d.", (int)port);
return (xSemaphoreGive(I2C_FN(_mutex)[port]) == pdTRUE) ? ESP_OK : ESP_FAIL;
}
esp_err_t I2C_FN(_force_unlock)(i2c_port_t port) {
I2C_PORT_CHECK(port, ESP_FAIL);
if (I2C_FN(_mutex)[port]) {
vSemaphoreDelete(I2C_FN(_mutex)[port]);
}
I2C_FN(_mutex)[port] = xSemaphoreCreateMutex();
return ESP_OK;
}
#ifdef I2C_OEM
void I2C_FN(_locking)(void* leader) {
if (leader) {
ESP_LOGI(TAG, "Now following I2C Manager for locking");
I2C_FN(_mutex) = (SemaphoreHandle_t*)leader;
}
}
#else
void* i2c_manager_locking() {
return (void*)i2c_manager_mutex;
}
int32_t i2c_hal_read(void *handle, uint8_t address, uint8_t reg, uint8_t *buffer, uint16_t size) {
return i2c_manager_read(*(i2c_port_t*)handle, address, reg, buffer, size);
}
int32_t i2c_hal_write(void *handle, uint8_t address, uint8_t reg, const uint8_t *buffer, uint16_t size) {
return i2c_manager_write(*(i2c_port_t*)handle, address, reg, buffer, size);
}
static i2c_port_t port_zero = (i2c_port_t)0;
static i2c_port_t port_one = (i2c_port_t)1;
static i2c_hal_t _i2c_hal[2] = {
{&i2c_hal_read, &i2c_hal_write, &port_zero},
{&i2c_hal_read, &i2c_hal_write, &port_one}
};
void* i2c_hal(i2c_port_t port) {
I2C_PORT_CHECK(port, NULL);
return (void*)&_i2c_hal[port];
}
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_i2c/i2c_manager.c | C | apache-2.0 | 10,692 |
#ifndef _I2C_MANAGER_H
#define _I2C_MANAGER_H
#ifdef __cplusplus
extern "C" {
#endif
/*
If you copy the i2c_manager files to your own component instead of
depending on i2c_manager, you MUST uncomment the define below
and put in some short string that identifies your component (such
as 'xyz'). This will cause i2c_manager to create functions named
xyz_i2c_* instead of i2c_manager_*. See README.md for details.
*/
#define I2C_OEM lvgl
// Only here to get the I2C_NUM_0 and I2C_NUM_1 defines.
#include <driver/i2c.h>
#define CONCATX(A, B) A ## B
#define CONCAT(A, B) CONCATX(A, B)
#define STR_LITERAL(s) # s
#define STR_EXPAND(s) STR_LITERAL(s)
#define STR_QUOTE(s) STR_EXPAND(STR_EXPAND(s))
#ifdef I2C_OEM
#define I2C_NAME_PREFIX CONCAT(I2C_OEM, _i2c)
#else
#define I2C_NAME_PREFIX i2c_manager
#endif
#define I2C_TAG STR_EXPAND(I2C_NAME_PREFIX)
#define I2C_FN(s) CONCAT(I2C_NAME_PREFIX, s)
#define I2C_ADDR_10 ( 1 << 15 )
#define I2C_REG_16 ( 1 << 31 )
#define I2C_NO_REG ( 1 << 30 )
esp_err_t I2C_FN(_init)(i2c_port_t port);
esp_err_t I2C_FN(_read)(i2c_port_t port, uint16_t addr, uint32_t reg, uint8_t *buffer, uint16_t size);
esp_err_t I2C_FN(_write)(i2c_port_t port, uint16_t addr, uint32_t reg, const uint8_t *buffer, uint16_t size);
esp_err_t I2C_FN(_close)(i2c_port_t port);
esp_err_t I2C_FN(_lock)(i2c_port_t port);
esp_err_t I2C_FN(_unlock)(i2c_port_t port);
esp_err_t I2C_FN(_force_unlock)(i2c_port_t port);
#ifdef I2C_OEM
void I2C_FN(_locking)(void* leader);
#else
void* i2c_manager_locking();
typedef struct {
int32_t (* read)(void *handle, uint8_t address, uint8_t reg, uint8_t *buffer, uint16_t size);
int32_t (* write)(void *handle, uint8_t address, uint8_t reg, const uint8_t *buffer, uint16_t size);
void *handle;
} i2c_hal_t;
void* i2c_hal(i2c_port_t port);
#endif
#ifdef __cplusplus
}
#endif
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_i2c/i2c_manager.h | C | apache-2.0 | 1,916 |
/**
* @file lvgl_spi_conf.h
*
*/
#ifndef LVGL_SPI_CONF_H
#define LVGL_SPI_CONF_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
/*********************
* DEFINES
*********************/
// DISPLAY PINS
#define DISP_SPI_MOSI CONFIG_LV_DISP_SPI_MOSI
#if defined (CONFIG_LV_DISPLAY_USE_SPI_MISO)
#define DISP_SPI_MISO CONFIG_LV_DISP_SPI_MISO
#define DISP_SPI_INPUT_DELAY_NS CONFIG_LV_DISP_SPI_INPUT_DELAY_NS
#else
#define DISP_SPI_MISO (-1)
#define DISP_SPI_INPUT_DELAY_NS (0)
#endif
#if defined(CONFIG_LV_DISP_SPI_IO2)
#define DISP_SPI_IO2 CONFIG_LV_DISP_SPI_IO2
#else
#define DISP_SPI_IO2 (-1)
#endif
#if defined(CONFIG_LV_DISP_SPI_IO3)
#define DISP_SPI_IO3 CONFIG_LV_DISP_SPI_IO3
#else
#define DISP_SPI_IO3 (-1)
#endif
#define DISP_SPI_CLK CONFIG_LV_DISP_SPI_CLK
#if defined (CONFIG_LV_DISPLAY_USE_SPI_CS)
#define DISP_SPI_CS CONFIG_LV_DISP_SPI_CS
#else
#define DISP_SPI_CS (-1)
#endif
/* Define TOUCHPAD PINS when selecting a touch controller */
#if !defined (CONFIG_LV_TOUCH_CONTROLLER_NONE)
/* Handle FT81X special case */
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X) && \
defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
#define TP_SPI_MOSI CONFIG_LV_DISP_SPI_MOSI
#define TP_SPI_MISO CONFIG_LV_DISP_SPI_MISO
#define TP_SPI_CLK CONFIG_LV_DISP_SPI_CLK
#define TP_SPI_CS CONFIG_LV_DISP_SPI_CS
#else
#define TP_SPI_MOSI CONFIG_LV_TOUCH_SPI_MOSI
#define TP_SPI_MISO CONFIG_LV_TOUCH_SPI_MISO
#define TP_SPI_CLK CONFIG_LV_TOUCH_SPI_CLK
#define TP_SPI_CS CONFIG_LV_TOUCH_SPI_CS
#endif
#endif
#define ENABLE_TOUCH_INPUT CONFIG_LV_ENABLE_TOUCH
#if defined (CONFIG_LV_TFT_DISPLAY_SPI_HSPI)
#if defined (CONFIG_IDF_TARGET_ESP32C3)
#define TFT_SPI_HOST SPI2_HOST
#else
#define TFT_SPI_HOST HSPI_HOST
#endif
#elif defined (CONFIG_LV_TFT_DISPLAY_SPI_VSPI)
#define TFT_SPI_HOST VSPI_HOST
#elif defined (CONFIG_LV_TFT_DISPLAY_SPI_FSPI)
#define TFT_SPI_HOST FSPI_HOST
#endif
#if defined (CONFIG_LV_TFT_DISPLAY_SPI_HALF_DUPLEX)
#define DISP_SPI_HALF_DUPLEX
#else
#define DISP_SPI_FULL_DUPLEX
#endif
#if defined (CONFIG_LV_TFT_DISPLAY_SPI_TRANS_MODE_DIO)
#define DISP_SPI_TRANS_MODE_DIO
#elif defined (CONFIG_LV_TFT_DISPLAY_SPI_TRANS_MODE_QIO)
#define DISP_SPI_TRANS_MODE_QIO
#else
#define DISP_SPI_TRANS_MODE_SIO
#endif
#if defined (CONFIG_LV_TOUCH_CONTROLLER_SPI_HSPI)
#define TOUCH_SPI_HOST HSPI_HOST
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_SPI_VSPI)
#define TOUCH_SPI_HOST VSPI_HOST
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_SPI_FSPI)
#define TOUCH_SPI_HOST FSPI_HOST
#endif
/* Handle the FT81X Special case */
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
#if defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
#define SHARED_SPI_BUS
#else
/* Empty */
#endif
#else
// Detect the use of a shared SPI Bus and verify the user specified the same SPI bus for both touch and tft
#if defined (CONFIG_LV_TOUCH_DRIVER_PROTOCOL_SPI) && TP_SPI_MOSI == DISP_SPI_MOSI && TP_SPI_CLK == DISP_SPI_CLK
#if TFT_SPI_HOST != TOUCH_SPI_HOST
#error You must specify the same SPI host (HSPI, VSPI or FSPI) for both display and touch driver
#endif
#define SHARED_SPI_BUS
#endif
#endif
/**********************
* TYPEDEFS
**********************/
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488)
#define SPI_BUS_MAX_TRANSFER_SZ (DISP_BUF_SIZE * 3)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A) || \
defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C)
#define SPI_BUS_MAX_TRANSFER_SZ (DISP_BUF_SIZE * 2)
#else
#define SPI_BUS_MAX_TRANSFER_SZ (DISP_BUF_SIZE * 2)
#endif
#if defined (CONFIG_LV_TFT_USE_CUSTOM_SPI_CLK_DIVIDER)
#define SPI_TFT_CLOCK_SPEED_HZ ((80 * 1000 * 1000) / CONFIG_LV_TFT_CUSTOM_SPI_CLK_DIVIDER)
#else
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789)
#define SPI_TFT_CLOCK_SPEED_HZ (20*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S)
#define SPI_TFT_CLOCK_SPEED_HZ (40*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357)
#define SPI_TFT_CLOCK_SPEED_HZ (26*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107)
#define SPI_TFT_CLOCK_SPEED_HZ (8*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481)
#define SPI_TFT_CLOCK_SPEED_HZ (16*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486)
#define SPI_TFT_CLOCK_SPEED_HZ (20*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488)
#define SPI_TFT_CLOCK_SPEED_HZ (40*1000*1000)
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341)
#define SPI_TFT_CLOCK_SPEED_HZ (40*1000*1000)
#elif defined(CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C)
#define SPI_TFT_CLOCK_SPEED_HZ (40 * 1000 * 1000)
#elif defined(CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
#define SPI_TFT_CLOCK_SPEED_HZ (32*1000*1000)
#else
#define SPI_TFT_CLOCK_SPEED_HZ (40*1000*1000)
#endif
#endif
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789)
#define SPI_TFT_SPI_MODE (2)
#else
#define SPI_TFT_SPI_MODE (0)
#endif
/* Touch driver */
#if (CONFIG_LV_TOUCH_CONTROLLER == TOUCH_CONTROLLER_STMPE610)
#define SPI_TOUCH_CLOCK_SPEED_HZ (1*1000*1000)
#define SPI_TOUCH_SPI_MODE (1)
#else
#define SPI_TOUCH_CLOCK_SPEED_HZ (2*1000*1000)
#define SPI_TOUCH_SPI_MODE (0)
#endif
/**********************
* GLOBAL PROTOTYPES
**********************/
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*LVGL_SPI_CONF_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_spi_conf.h | C | apache-2.0 | 6,006 |
/*
@file EVE.h
@brief Contains FT80x/FT81x/BT81x API definitions
@version 4.1 LvGL edition
@date 2020-04-15
@author Rudolph Riedel, David Jade
@section LICENSE
MIT License
Copyright (c) 2016-2020 Rudolph Riedel and David Jade
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@section History
4.1 LvGL edition
- This version is a heavily modified version of the MIT licensed FT81x code from https://github.com/RudolphRiedel/FT800-FT813
This version is based on a fork by David Jade that added native SPI DMA support and stripped out non-ESP32 code.
It has also been trimmed down to suit LvGL's needs. Extra features can be enabled by defining FT81X_FULL
*/
#if defined (ESP_PLATFORM)
#include <stddef.h>
#include <stdint.h>
#endif
#include "EVE_config.h"
#ifndef EVE_H_
#define EVE_H_
#define DL_CLEAR 0x26000000UL /* requires OR'd arguments */
#define DL_CLEAR_RGB 0x02000000UL /* requires OR'd arguments */
#define DL_COLOR_RGB 0x04000000UL /* requires OR'd arguments */
#define DL_POINT_SIZE 0x0D000000UL /* requires OR'd arguments */
#define DL_END 0x21000000UL
#define DL_BEGIN 0x1F000000UL /* requires OR'd arguments */
#define DL_DISPLAY 0x00000000UL
#define CLR_COL 0x4
#define CLR_STN 0x2
#define CLR_TAG 0x1
/* SPI SIO/DIO/QIO tranfer widths */
#define SPI_WIDTH_SIO 0x0
#define SPI_WIDTH_DIO 0x1
#define SPI_WIDTH_QIO 0x2
/* Host commands */
#define EVE_ACTIVE 0x00 /* place FT8xx in active state */
#define EVE_STANDBY 0x41 /* place FT8xx in Standby (clk running) */
#define EVE_SLEEP 0x42 /* place FT8xx in Sleep (clk off) */
#define EVE_PWRDOWN 0x50 /* place FT8xx in Power Down (core off) */
#define EVE_CLKEXT 0x44 /* select external clock source */
#define EVE_CLKINT 0x48 /* select internal clock source */
#define EVE_CORERST 0x68 /* reset core - all registers default and processors reset */
#define EVE_CLK48M 0x62 /* select 48MHz PLL output */
#define EVE_CLK36M 0x61 /* select 36MHz PLL output */
/* defines used for graphics commands */
#define EVE_NEVER 0UL
#define EVE_LESS 1UL
#define EVE_LEQUAL 2UL
#define EVE_GREATER 3UL
#define EVE_GEQUAL 4UL
#define EVE_EQUAL 5UL
#define EVE_NOTEQUAL 6UL
#define EVE_ALWAYS 7UL
/* Bitmap formats */
#define EVE_ARGB1555 0UL
#define EVE_L1 1UL
#define EVE_L4 2UL
#define EVE_L8 3UL
#define EVE_RGB332 4UL
#define EVE_ARGB2 5UL
#define EVE_ARGB4 6UL
#define EVE_RGB565 7UL
#define EVE_PALETTED 8UL
#define EVE_TEXT8X8 9UL
#define EVE_TEXTVGA 10UL
#define EVE_BARGRAPH 11UL
/* Bitmap filter types */
#define EVE_NEAREST 0UL
#define EVE_BILINEAR 1UL
/* Bitmap wrap types */
#define EVE_BORDER 0UL
#define EVE_REPEAT 1UL
/* Stencil defines */
#define EVE_KEEP 1UL
#define EVE_REPLACE 2UL
#define EVE_INCR 3UL
#define EVE_DECR 4UL
#define EVE_INVERT 5UL
/* Graphics display list swap defines */
#define EVE_DLSWAP_DONE 0UL
#define EVE_DLSWAP_LINE 1UL
#define EVE_DLSWAP_FRAME 2UL
/* Interrupt bits */
#define EVE_INT_SWAP 0x01
#define EVE_INT_TOUCH 0x02
#define EVE_INT_TAG 0x04
#define EVE_INT_SOUND 0x08
#define EVE_INT_PLAYBACK 0x10
#define EVE_INT_CMDEMPTY 0x20
#define EVE_INT_CMDFLAG 0x40
#define EVE_INT_CONVCOMPLETE 0x80
/* Touch mode */
#define EVE_TMODE_OFF 0
#define EVE_TMODE_ONESHOT 1
#define EVE_TMODE_FRAME 2
#define EVE_TMODE_CONTINUOUS 3
/* Alpha blending */
#define EVE_ZERO 0UL
#define EVE_ONE 1UL
#define EVE_SRC_ALPHA 2UL
#define EVE_DST_ALPHA 3UL
#define EVE_ONE_MINUS_SRC_ALPHA 4UL
#define EVE_ONE_MINUS_DST_ALPHA 5UL
/* Graphics primitives */
#define EVE_BITMAPS 1UL
#define EVE_POINTS 2UL
#define EVE_LINES 3UL
#define EVE_LINE_STRIP 4UL
#define EVE_EDGE_STRIP_R 5UL
#define EVE_EDGE_STRIP_L 6UL
#define EVE_EDGE_STRIP_A 7UL
#define EVE_EDGE_STRIP_B 8UL
#define EVE_RECTS 9UL
/* Widget command */
#define EVE_OPT_MONO 1
#define EVE_OPT_NODL 2
#define EVE_OPT_FLAT 256
#define EVE_OPT_CENTERX 512
#define EVE_OPT_CENTERY 1024
#define EVE_OPT_CENTER (EVE_OPT_CENTERX | EVE_OPT_CENTERY)
#define EVE_OPT_NOBACK 4096
#define EVE_OPT_NOTICKS 8192
#define EVE_OPT_NOHM 16384
#define EVE_OPT_NOPOINTER 16384
#define EVE_OPT_NOSECS 32768
#define EVE_OPT_NOHANDS 49152
#define EVE_OPT_RIGHTX 2048
#define EVE_OPT_SIGNED 256
/* Defines related to inbuilt font */
#define EVE_NUMCHAR_PERFONT (128L) /* number of font characters per bitmap handle */
#define EVE_FONT_TABLE_SIZE (148L) /* size of the font table - utilized for loopup by the graphics engine */
#define EVE_FONT_TABLE_POINTER (0xFFFFCUL) /* pointer to the inbuilt font tables starting from bitmap handle 16 */
/* Audio sample type defines */
#define EVE_LINEAR_SAMPLES 0UL /* 8bit signed samples */
#define EVE_ULAW_SAMPLES 1UL /* 8bit ulaw samples */
#define EVE_ADPCM_SAMPLES 2UL /* 4bit ima adpcm samples */
/* Synthesized sound */
#define EVE_SILENCE 0x00
#define EVE_SQUAREWAVE 0x01
#define EVE_SINEWAVE 0x02
#define EVE_SAWTOOTH 0x03
#define EVE_TRIANGLE 0x04
#define EVE_BEEPING 0x05
#define EVE_ALARM 0x06
#define EVE_WARBLE 0x07
#define EVE_CAROUSEL 0x08
#define EVE_PIPS(n) (0x0F + (n))
#define EVE_HARP 0x40
#define EVE_XYLOPHONE 0x41
#define EVE_TUBA 0x42
#define EVE_GLOCKENSPIEL 0x43
#define EVE_ORGAN 0x44
#define EVE_TRUMPET 0x45
#define EVE_PIANO 0x46
#define EVE_CHIMES 0x47
#define EVE_MUSICBOX 0x48
#define EVE_BELL 0x49
#define EVE_CLICK 0x50
#define EVE_SWITCH 0x51
#define EVE_COWBELL 0x52
#define EVE_NOTCH 0x53
#define EVE_HIHAT 0x54
#define EVE_KICKDRUM 0x55
#define EVE_POP 0x56
#define EVE_CLACK 0x57
#define EVE_CHACK 0x58
#define EVE_MUTE 0x60
#define EVE_UNMUTE 0x61
/* Synthesized sound frequencies, midi note */
#define EVE_MIDI_A0 21
#define EVE_MIDI_A_0 22
#define EVE_MIDI_B0 23
#define EVE_MIDI_C1 24
#define EVE_MIDI_C_1 25
#define EVE_MIDI_D1 26
#define EVE_MIDI_D_1 27
#define EVE_MIDI_E1 28
#define EVE_MIDI_F1 29
#define EVE_MIDI_F_1 30
#define EVE_MIDI_G1 31
#define EVE_MIDI_G_1 32
#define EVE_MIDI_A1 33
#define EVE_MIDI_A_1 34
#define EVE_MIDI_B1 35
#define EVE_MIDI_C2 36
#define EVE_MIDI_C_2 37
#define EVE_MIDI_D2 38
#define EVE_MIDI_D_2 39
#define EVE_MIDI_E2 40
#define EVE_MIDI_F2 41
#define EVE_MIDI_F_2 42
#define EVE_MIDI_G2 43
#define EVE_MIDI_G_2 44
#define EVE_MIDI_A2 45
#define EVE_MIDI_A_2 46
#define EVE_MIDI_B2 47
#define EVE_MIDI_C3 48
#define EVE_MIDI_C_3 49
#define EVE_MIDI_D3 50
#define EVE_MIDI_D_3 51
#define EVE_MIDI_E3 52
#define EVE_MIDI_F3 53
#define EVE_MIDI_F_3 54
#define EVE_MIDI_G3 55
#define EVE_MIDI_G_3 56
#define EVE_MIDI_A3 57
#define EVE_MIDI_A_3 58
#define EVE_MIDI_B3 59
#define EVE_MIDI_C4 60
#define EVE_MIDI_C_4 61
#define EVE_MIDI_D4 62
#define EVE_MIDI_D_4 63
#define EVE_MIDI_E4 64
#define EVE_MIDI_F4 65
#define EVE_MIDI_F_4 66
#define EVE_MIDI_G4 67
#define EVE_MIDI_G_4 68
#define EVE_MIDI_A4 69
#define EVE_MIDI_A_4 70
#define EVE_MIDI_B4 71
#define EVE_MIDI_C5 72
#define EVE_MIDI_C_5 73
#define EVE_MIDI_D5 74
#define EVE_MIDI_D_5 75
#define EVE_MIDI_E5 76
#define EVE_MIDI_F5 77
#define EVE_MIDI_F_5 78
#define EVE_MIDI_G5 79
#define EVE_MIDI_G_5 80
#define EVE_MIDI_A5 81
#define EVE_MIDI_A_5 82
#define EVE_MIDI_B5 83
#define EVE_MIDI_C6 84
#define EVE_MIDI_C_6 85
#define EVE_MIDI_D6 86
#define EVE_MIDI_D_6 87
#define EVE_MIDI_E6 88
#define EVE_MIDI_F6 89
#define EVE_MIDI_F_6 90
#define EVE_MIDI_G6 91
#define EVE_MIDI_G_6 92
#define EVE_MIDI_A6 93
#define EVE_MIDI_A_6 94
#define EVE_MIDI_B6 95
#define EVE_MIDI_C7 96
#define EVE_MIDI_C_7 97
#define EVE_MIDI_D7 98
#define EVE_MIDI_D_7 99
#define EVE_MIDI_E7 100
#define EVE_MIDI_F7 101
#define EVE_MIDI_F_7 102
#define EVE_MIDI_G7 103
#define EVE_MIDI_G_7 104
#define EVE_MIDI_A7 105
#define EVE_MIDI_A_7 106
#define EVE_MIDI_B7 107
#define EVE_MIDI_C8 108
/* GPIO bits */
#define EVE_GPIO0 0
#define EVE_GPIO1 1 /* default gpio pin for audio shutdown, 1 - enable, 0 - disable */
#define EVE_GPIO7 7 /* default gpio pin for display enable, 1 - enable, 0 - disable */
/* Display rotation */
#define EVE_DISPLAY_0 0 /* 0 degrees rotation */
#define EVE_DISPLAY_180 1 /* 180 degrees rotation */
/* commands common to EVE/EVE2/EVE3 */
#define CMD_APPEND 0xFFFFFF1E
#define CMD_BGCOLOR 0xFFFFFF09
#define CMD_BUTTON 0xFFFFFF0D
#define CMD_CALIBRATE 0xFFFFFF15
#define CMD_CLOCK 0xFFFFFF14
#define CMD_COLDSTART 0xFFFFFF32
#define CMD_DIAL 0xFFFFFF2D
#define CMD_DLSTART 0xFFFFFF00
#define CMD_FGCOLOR 0xFFFFFF0A
#define CMD_GAUGE 0xFFFFFF13
#define CMD_GETMATRIX 0xFFFFFF33
#define CMD_GETPROPS 0xFFFFFF25
#define CMD_GETPTR 0xFFFFFF23
#define CMD_GRADCOLOR 0xFFFFFF34
#define CMD_GRADIENT 0xFFFFFF0B
#define CMD_INFLATE 0xFFFFFF22
#define CMD_INTERRUPT 0xFFFFFF02
#define CMD_KEYS 0xFFFFFF0E
#define CMD_LOADIDENTITY 0xFFFFFF26
#define CMD_LOADIMAGE 0xFFFFFF24
#define CMD_LOGO 0xFFFFFF31
#define CMD_MEMCPY 0xFFFFFF1D
#define CMD_MEMCRC 0xFFFFFF18
#define CMD_MEMSET 0xFFFFFF1B
#define CMD_MEMWRITE 0xFFFFFF1A
#define CMD_MEMZERO 0xFFFFFF1C
#define CMD_NUMBER 0xFFFFFF2E
#define CMD_PROGRESS 0xFFFFFF0F
#define CMD_REGREAD 0xFFFFFF19
#define CMD_ROTATE 0xFFFFFF29
#define CMD_SCALE 0xFFFFFF28
#define CMD_SCREENSAVER 0xFFFFFF2F
#define CMD_SCROLLBAR 0xFFFFFF11
#define CMD_SETFONT 0xFFFFFF2B
#define CMD_SETMATRIX 0xFFFFFF2A
#define CMD_SKETCH 0xFFFFFF30
#define CMD_SLIDER 0xFFFFFF10
#define CMD_SNAPSHOT 0xFFFFFF1F
#define CMD_SPINNER 0xFFFFFF16
#define CMD_STOP 0xFFFFFF17
#define CMD_SWAP 0xFFFFFF01
#define CMD_TEXT 0xFFFFFF0C
#define CMD_TOGGLE 0xFFFFFF12
#define CMD_TRACK 0xFFFFFF2C
#define CMD_TRANSLATE 0xFFFFFF27
/* the following are undocumented commands that therefore should not be used */
#if 0
#define CMD_CRC 0xFFFFFF03
#define CMD_HAMMERAUX 0xFFFFFF04
#define CMD_MARCH 0xFFFFFF05
#define CMD_IDCT 0xFFFFFF06
#define CMD_EXECUTE 0xFFFFFF07
#define CMD_GETPOINT 0xFFFFFF08
#define CMD_TOUCH_TRANSFORM 0xFFFFFF20
#endif
/* FT8xx graphics engine specific macros useful for static display list generation */
#define ALPHA_FUNC(func,ref) ((9UL<<24)|(((func)&7UL)<<8)|(((ref)&255UL)<<0))
#define BEGIN(prim) ((31UL<<24)|(((prim)&15UL)<<0))
#define BITMAP_HANDLE(handle) ((5UL<<24)|(((handle)&31UL)<<0))
#define BITMAP_LAYOUT(format,linestride,height) ((7UL<<24)|(((format)&31UL)<<19)|(((linestride)&1023UL)<<9)|(((height)&511UL)<<0))
#define BITMAP_SIZE(filter,wrapx,wrapy,width,height) ((8UL<<24)|(((filter)&1UL)<<20)|(((wrapx)&1UL)<<19)|(((wrapy)&1UL)<<18)|(((width)&511UL)<<9)|(((height)&511UL)<<0))
#define BITMAP_TRANSFORM_A(a) ((21UL<<24)|(((a)&131071UL)<<0))
#define BITMAP_TRANSFORM_B(b) ((22UL<<24)|(((b)&131071UL)<<0))
#define BITMAP_TRANSFORM_C(c) ((23UL<<24)|(((c)&16777215UL)<<0))
#define BITMAP_TRANSFORM_D(d) ((24UL<<24)|(((d)&131071UL)<<0))
#define BITMAP_TRANSFORM_E(e) ((25UL<<24)|(((e)&131071UL)<<0))
#define BITMAP_TRANSFORM_F(f) ((26UL<<24)|(((f)&16777215UL)<<0))
#define BLEND_FUNC(src,dst) ((11UL<<24)|(((src)&7UL)<<3)|(((dst)&7UL)<<0))
#define CALL(dest) ((29UL<<24)|(((dest)&65535UL)<<0))
#define CELL(cell) ((6UL<<24)|(((cell)&127UL)<<0))
#define CLEAR(c,s,t) ((38UL<<24)|(((c)&1UL)<<2)|(((s)&1UL)<<1)|(((t)&1UL)<<0))
#define CLEAR_COLOR_A(alpha) ((15UL<<24)|(((alpha)&255UL)<<0))
#define CLEAR_COLOR_RGB(red,green,blue) ((2UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0))
#define CLEAR_STENCIL(s) ((17UL<<24)|(((s)&255UL)<<0))
#define CLEAR_TAG(s) ((18UL<<24)|(((s)&255UL)<<0))
#define COLOR_A(alpha) ((16UL<<24)|(((alpha)&255UL)<<0))
#define COLOR_MASK(r,g,b,a) ((32UL<<24)|(((r)&1UL)<<3)|(((g)&1UL)<<2)|(((b)&1UL)<<1)|(((a)&1UL)<<0))
#define COLOR_RGB(red,green,blue) ((4UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0))
/* #define DISPLAY() ((0UL<<24)) */
#define END() ((33UL<<24))
#define JUMP(dest) ((30UL<<24)|(((dest)&65535UL)<<0))
#define LINE_WIDTH(width) ((14UL<<24)|(((width)&4095UL)<<0))
#define MACRO(m) ((37UL<<24)|(((m)&1UL)<<0))
#define POINT_SIZE(size) ((13UL<<24)|(((size)&8191UL)<<0))
#define RESTORE_CONTEXT() ((35UL<<24))
#define RETURN() ((36UL<<24))
#define SAVE_CONTEXT() ((34UL<<24))
#define STENCIL_FUNC(func,ref,mask) ((10UL<<24)|(((func)&7UL)<<16)|(((ref)&255UL)<<8)|(((mask)&255UL)<<0))
#define STENCIL_MASK(mask) ((19UL<<24)|(((mask)&255UL)<<0))
#define STENCIL_OP(sfail,spass) ((12UL<<24)|(((sfail)&7UL)<<3)|(((spass)&7UL)<<0))
#define TAG(s) ((3UL<<24)|(((s)&255UL)<<0))
#define TAG_MASK(mask) ((20UL<<24)|(((mask)&1UL)<<0))
#define VERTEX2F(x,y) ((1UL<<30)|(((x)&32767UL)<<15)|(((y)&32767UL)<<0))
#define VERTEX2II(x,y,handle,cell) ((2UL<<30)|(((x)&511UL)<<21)|(((y)&511UL)<<12)|(((handle)&31UL)<<7)|(((cell)&127UL)<<0))
/* ----------------- BT81x exclusive definitions -----------------*/
#if defined (BT81X_ENABLE)
#define EVE_GLFORMAT 31UL /* used with BITMAP_LAYOUT to indicate bitmap-format is specified by BITMAP_EXT_FORMAT */
#define DL_BITMAP_EXT_FORMAT 0x2E000000 /* requires OR'd arguments */
/* extended Bitmap formats */
#define EVE_COMPRESSED_RGBA_ASTC_4x4_KHR 37808UL
#define EVE_COMPRESSED_RGBA_ASTC_5x4_KHR 37809UL
#define EVE_COMPRESSED_RGBA_ASTC_5x5_KHR 37810UL
#define EVE_COMPRESSED_RGBA_ASTC_6x5_KHR 37811UL
#define EVE_COMPRESSED_RGBA_ASTC_6x6_KHR 37812UL
#define EVE_COMPRESSED_RGBA_ASTC_8x5_KHR 37813UL
#define EVE_COMPRESSED_RGBA_ASTC_8x6_KHR 37814UL
#define EVE_COMPRESSED_RGBA_ASTC_8x8_KHR 37815UL
#define EVE_COMPRESSED_RGBA_ASTC_10x5_KHR 37816UL
#define EVE_COMPRESSED_RGBA_ASTC_10x6_KHR 37817UL
#define EVE_COMPRESSED_RGBA_ASTC_10x8_KHR 37818UL
#define EVE_COMPRESSED_RGBA_ASTC_10x10_KHR 37819UL
#define EVE_COMPRESSED_RGBA_ASTC_12x10_KHR 37820UL
#define EVE_COMPRESSED_RGBA_ASTC_12x12_KHR 37821UL
#define EVE_RAM_ERR_REPORT 0x309800UL /* max 128 bytes null terminated string */
#define EVE_RAM_FLASH 0x800000UL
#define EVE_RAM_FLASH_POSTBLOB 0x801000UL
#define EVE_OPT_FLASH 64UL
#define EVE_OPT_FORMAT 4096UL
#define EVE_OPT_FILL 8192UL
/* additional commands for BT81x */
#define CMD_BITMAP_TRANSFORM 0xFFFFFF21
#define CMD_SYNC 0xFFFFFF42 /* does not need a dedicated function, just use EVE_cmd_dl(CMD_SYNC) */
#define CMD_FLASHERASE 0xFFFFFF44 /* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHERASE) */
#define CMD_FLASHWRITE 0xFFFFFF45
#define CMD_FLASHREAD 0xFFFFFF46
#define CMD_FLASHUPDATE 0xFFFFFF47
#define CMD_FLASHDETACH 0xFFFFFF48 /* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHDETACH) */
#define CMD_FLASHATTACH 0xFFFFFF49 /* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHATTACH) */
#define CMD_FLASHFAST 0xFFFFFF4A
#define CMD_FLASHSPIDESEL 0xFFFFFF4B /* does not need a dedicated function, just use EVE_cmd_dl(CMD_FLASHSPIDESEL) */
#define CMD_FLASHSPITX 0xFFFFFF4C
#define CMD_FLASHSPIRX 0xFFFFFF4D
#define CMD_FLASHSOURCE 0xFFFFFF4E
#define CMD_CLEARCACHE 0xFFFFFF4F /* does not need a dedicated function, just use EVE_cmd_dl(CMD_CLEARCACHE) */
#define CMD_INFLATE2 0xFFFFFF50
#define CMD_ROTATEAROUND 0xFFFFFF51
#define CMD_RESETFONTS 0xFFFFFF52 /* does not need a dedicated function, just use EVE_cmd_dl(CMD_RESETFONTS) */
#define CMD_ANIMSTART 0xFFFFFF53
#define CMD_ANIMSTOP 0xFFFFFF54
#define CMD_ANIMXY 0xFFFFFF55
#define CMD_ANIMDRAW 0xFFFFFF56
#define CMD_GRADIENTA 0xFFFFFF57
#define CMD_FILLWIDTH 0xFFFFFF58
#define CMD_APPENDF 0xFFFFFF59
#define CMD_ANIMFRAME 0xFFFFFF5A
#define CMD_VIDEOSTARTF 0xFFFFFF5F /* does not need a dedicated function, just use EVE_cmd_dl(CMD_VIDEOSTARTF) */
#if 0
/* some undocumented commands for BT81x */
#define CMD_NOP 0xFFFFFF5B
#define CMD_SHA1 0xFFFFFF5C
#define CMD_HMAC 0xFFFFFF5D
#define CMD_LAST_ 0xFFFFFF5E
#endif
/* additional registers for BT81x */
#define REG_ADAPTIVE_FRAMERATE 0x30257cUL
#define REG_PLAYBACK_PAUSE 0x3025ecUL
#define REG_FLASH_STATUS 0x3025f0UL
#define REG_FLASH_SIZE 0x309024UL
#define REG_PLAY_CONTROL 0x30914eUL
#define REG_COPRO_PATCH_DTR 0x309162UL
/* BT81x graphics engine specific macros */
#define BITMAP_EXT_FORMAT(format) ((46UL<<24)|(((format)&65535UL)<<0))
#define BITMAP_SWIZZLE(r,g,b,a) ((47UL<<24)|(((r)&7UL)<<9)|(((g)&7UL)<<6)|(((b)&7UL)<<3)|(((a)&7UL)<<0))
#define BITMAP_SOURCE2(flash_or_ram, addr) ((1UL<<24)|((flash_or_ram) << 23)|(((addr)&8388607UL)<<0))
#define INT_FRR() ((48UL<<24))
#undef BITMAP_TRANSFORM_A
#undef BITMAP_TRANSFORM_B
#undef BITMAP_TRANSFORM_D
#undef BITMAP_TRANSFORM_E
#define BITMAP_TRANSFORM_A_EXT(p,v) ((21UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))
#define BITMAP_TRANSFORM_B_EXT(p,v) ((22UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))
#define BITMAP_TRANSFORM_D_EXT(p,v) ((24UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))
#define BITMAP_TRANSFORM_E_EXT(p,v) ((25UL<<24)|(((p)&1UL)<<17)|(((v)&131071UL)<<0))
#define BITMAP_TRANSFORM_A(a) BITMAP_TRANSFORM_A_EXT(0,a)
#define BITMAP_TRANSFORM_B(b) BITMAP_TRANSFORM_B_EXT(0,b)
#define BITMAP_TRANSFORM_D(d) BITMAP_TRANSFORM_D_EXT(0,d)
#define BITMAP_TRANSFORM_E(e) BITMAP_TRANSFORM_E_EXT(0,e)
#endif
/* ----------------- FT81x / BT81x exclusive definitions -----------------*/
#if defined (FT81X_ENABLE)
/* Host commands */
#define EVE_CLKSEL 0x61 /* configure system clock */
#define EVE_RST_PULSE 0x68 /* reset core - all registers default and processors reset */
#define EVE_PINDRIVE 0x70 /* setup drive strength for various pins */
#define EVE_PIN_PD_STATE 0x71 /* setup how pins behave during power down */
/* Memory definitions */
#define EVE_RAM_G 0x000000UL
#define EVE_ROM_CHIPID 0x0C0000UL
#define EVE_ROM_FONT 0x1E0000UL
#define EVE_ROM_FONT_ADDR 0x2FFFFCUL
#define EVE_RAM_DL 0x300000UL
#define EVE_RAM_REG 0x302000UL
#define EVE_RAM_CMD 0x308000UL
/* Memory buffer sizes */
#define EVE_RAM_G_SIZE 1024*1024L
#define EVE_CMDFIFO_SIZE 4*1024L
#define EVE_RAM_DL_SIZE 8*1024L
/* various additional defines for FT81x */
#define EVE_ADC_DIFFERENTIAL 1UL
#define EVE_ADC_SINGLE_ENDED 0UL
#define EVE_INT_G8 18UL
#define EVE_INT_L8C 12UL
#define EVE_INT_VGA 13UL
#define EVE_OPT_MEDIAFIFO 16UL
#define EVE_OPT_FULLSCREEN 8UL
#define EVE_OPT_NOTEAR 4UL
#define EVE_OPT_SOUND 32UL
#define EVE_PALETTED565 14UL
#define EVE_PALETTED4444 15UL
#define EVE_PALETTED8 16UL
#define EVE_L2 17UL
/* additional commands for FT81x */
#define CMD_MEDIAFIFO 0xFFFFFF39
#define CMD_PLAYVIDEO 0xFFFFFF3A
#define CMD_ROMFONT 0xFFFFFF3F
#define CMD_SETBASE 0xFFFFFF38
#define CMD_SETBITMAP 0xFFFFFF43
#define CMD_SETFONT2 0xFFFFFF3B
#define CMD_SETROTATE 0xFFFFFF36
#define CMD_SETSCRATCH 0xFFFFFF3C
#define CMD_SNAPSHOT2 0xFFFFFF37
#define CMD_VIDEOFRAME 0xFFFFFF41
#define CMD_VIDEOSTART 0xFFFFFF40
/* the following are undocumented commands that therefore should not be used */
#if 0
#define CMD_CSKETCH 0xFFFFFF35
#define CMD_INT_RAMSHARED 0xFFFFFF3D
#define CMD_INT_SWLOADIMAGE 0xFFFFFF3E
#endif
/* Register definitions */
#define REG_ANA_COMP 0x302184UL /* only listed in datasheet */
#define REG_BIST_EN 0x302174UL /* only listed in datasheet */
#define REG_CLOCK 0x302008UL
#define REG_CMDB_SPACE 0x302574UL
#define REG_CMDB_WRITE 0x302578UL
#define REG_CMD_DL 0x302100UL
#define REG_CMD_READ 0x3020f8UL
#define REG_CMD_WRITE 0x3020fcUL
#define REG_CPURESET 0x302020UL
#define REG_CSPREAD 0x302068UL
#define REG_CTOUCH_EXTENDED 0x302108UL
#define REG_CTOUCH_TOUCH0_XY 0x302124UL /* only listed in datasheet */
#define REG_CTOUCH_TOUCH4_X 0x30216cUL
#define REG_CTOUCH_TOUCH4_Y 0x302120UL
#define REG_CTOUCH_TOUCH1_XY 0x30211cUL
#define REG_CTOUCH_TOUCH2_XY 0x30218cUL
#define REG_CTOUCH_TOUCH3_XY 0x302190UL
#define REG_TOUCH_CONFIG 0x302168UL
#define REG_DATESTAMP 0x302564UL /* only listed in datasheet */
#define REG_DITHER 0x302060UL
#define REG_DLSWAP 0x302054UL
#define REG_FRAMES 0x302004UL
#define REG_FREQUENCY 0x30200cUL
#define REG_GPIO 0x302094UL
#define REG_GPIOX 0x30209cUL
#define REG_GPIOX_DIR 0x302098UL
#define REG_GPIO_DIR 0x302090UL
#define REG_HCYCLE 0x30202cUL
#define REG_HOFFSET 0x302030UL
#define REG_HSIZE 0x302034UL
#define REG_HSYNC0 0x302038UL
#define REG_HSYNC1 0x30203cUL
#define REG_ID 0x302000UL
#define REG_INT_EN 0x3020acUL
#define REG_INT_FLAGS 0x3020a8UL
#define REG_INT_MASK 0x3020b0UL
#define REG_MACRO_0 0x3020d8UL
#define REG_MACRO_1 0x3020dcUL
#define REG_MEDIAFIFO_READ 0x309014UL /* only listed in programmers guide */
#define REG_MEDIAFIFO_WRITE 0x309018UL /* only listed in programmers guide */
#define REG_OUTBITS 0x30205cUL
#define REG_PCLK 0x302070UL
#define REG_PCLK_POL 0x30206cUL
#define REG_PLAY 0x30208cUL
#define REG_PLAYBACK_FORMAT 0x3020c4UL
#define REG_PLAYBACK_FREQ 0x3020c0UL
#define REG_PLAYBACK_LENGTH 0x3020b8UL
#define REG_PLAYBACK_LOOP 0x3020c8UL
#define REG_PLAYBACK_PLAY 0x3020ccUL
#define REG_PLAYBACK_READPTR 0x3020bcUL
#define REG_PLAYBACK_START 0x3020b4UL
#define REG_PWM_DUTY 0x3020d4UL
#define REG_PWM_HZ 0x3020d0UL
#define REG_RENDERMODE 0x302010UL /* only listed in datasheet */
#define REG_ROTATE 0x302058UL
#define REG_SNAPFORMAT 0x30201cUL /* only listed in datasheet */
#define REG_SNAPSHOT 0x302018UL /* only listed in datasheet */
#define REG_SNAPY 0x302014UL /* only listed in datasheet */
#define REG_SOUND 0x302088UL
#define REG_SPI_WIDTH 0x302188UL /* listed with false offset in programmers guide V1.1 */
#define REG_SWIZZLE 0x302064UL
#define REG_TAG 0x30207cUL
#define REG_TAG_X 0x302074UL
#define REG_TAG_Y 0x302078UL
#define REG_TAP_CRC 0x302024UL /* only listed in datasheet */
#define REG_TAP_MASK 0x302028UL /* only listed in datasheet */
#define REG_TOUCH_ADC_MODE 0x302108UL
#define REG_TOUCH_CHARGE 0x30210cUL
#define REG_TOUCH_DIRECT_XY 0x30218cUL
#define REG_TOUCH_DIRECT_Z1Z2 0x302190UL
#define REG_TOUCH_MODE 0x302104UL
#define REG_TOUCH_OVERSAMPLE 0x302114UL
#define REG_TOUCH_RAW_XY 0x30211cUL
#define REG_TOUCH_RZ 0x302120UL
#define REG_TOUCH_RZTHRESH 0x302118UL
#define REG_TOUCH_SCREEN_XY 0x302124UL
#define REG_TOUCH_SETTLE 0x302110UL
#define REG_TOUCH_TAG 0x30212cUL
#define REG_TOUCH_TAG1 0x302134UL /* only listed in datasheet */
#define REG_TOUCH_TAG1_XY 0x302130UL /* only listed in datasheet */
#define REG_TOUCH_TAG2 0x30213cUL /* only listed in datasheet */
#define REG_TOUCH_TAG2_XY 0x302138UL /* only listed in datasheet */
#define REG_TOUCH_TAG3 0x302144UL /* only listed in datasheet */
#define REG_TOUCH_TAG3_XY 0x302140UL /* only listed in datasheet */
#define REG_TOUCH_TAG4 0x30214cUL /* only listed in datasheet */
#define REG_TOUCH_TAG4_XY 0x302148UL /* only listed in datasheet */
#define REG_TOUCH_TAG_XY 0x302128UL
#define REG_TOUCH_TRANSFORM_A 0x302150UL
#define REG_TOUCH_TRANSFORM_B 0x302154UL
#define REG_TOUCH_TRANSFORM_C 0x302158UL
#define REG_TOUCH_TRANSFORM_D 0x30215cUL
#define REG_TOUCH_TRANSFORM_E 0x302160UL
#define REG_TOUCH_TRANSFORM_F 0x302164UL
#define REG_TRACKER 0x309000UL /* only listed in programmers guide */
#define REG_TRACKER_1 0x309004UL /* only listed in programmers guide */
#define REG_TRACKER_2 0x309008UL /* only listed in programmers guide */
#define REG_TRACKER_3 0x30900cUL /* only listed in programmers guide */
#define REG_TRACKER_4 0x309010UL /* only listed in programmers guide */
#define REG_TRIM 0x302180UL
#define REG_VCYCLE 0x302040UL
#define REG_VOFFSET 0x302044UL
#define REG_VOL_PB 0x302080UL
#define REG_VOL_SOUND 0x302084UL
#define REG_VSIZE 0x302048UL
#define REG_VSYNC0 0x30204cUL
#define REG_VSYNC1 0x302050UL
#if 0
#define REG_BUSYBITS 0x3020e8UL /* only listed as "reserved" in datasheet */
#define REG_CRC 0x302178UL /* only listed as "reserved" in datasheet */
#define REG_SPI_EARLY_TX 0x30217cUL /* only listed as "reserved" in datasheet */
#define REG_ROMSUB_SEL 0x3020f0UL /* only listed as "reserved" in datasheet */
#define REG_TOUCH_FAULT 0x302170UL /* only listed as "reserved" in datasheet */
#endif
/* FT81x graphics engine specific macros useful for static display list generation */
/* beware, these are different to FTDIs implementation as these take the original values as parameters and not only the upper bits */
#define BITMAP_LAYOUT_H(linestride,height) ((40UL<<24)|((((linestride&0xC00)>>10)&3UL)<<2)|((((height&0x600)>>9)&3UL)<<0))
#define BITMAP_SIZE_H(width,height) ((41UL<<24)|((((width&0x600)>>9)&3UL)<<2)|((((height&0x600)>>9)&3UL)<<0))
#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&4194303UL)<<0))
//#define NOP() ((45UL<<24))
#define PALETTE_SOURCE(addr) ((42UL<<24)|(((addr)&4194303UL)<<0))
#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&4095UL)<<12)|(((height)&4095UL)<<0))
#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&2047UL)<<11)|(((y)&2047UL)<<0))
#define VERTEX_FORMAT(frac) ((39UL<<24)|(((frac)&7UL)<<0))
#define VERTEX_TRANSLATE_X(x) ((43UL<<24)|(((x)&131071UL)<<0))
#define VERTEX_TRANSLATE_Y(y) ((44UL<<24)|(((y)&131071UL)<<0))
/* ----------------- FT80x exclusive definitions -----------------*/
#else
/* Memory definitions */
#define EVE_RAM_G 0x000000UL
#define EVE_ROM_CHIPID 0x0C0000UL
#define EVE_ROM_FONT 0x0BB23CUL
#define EVE_ROM_FONT_ADDR 0x0FFFFCUL
#define EVE_RAM_DL 0x100000UL
#define EVE_RAM_PAL 0x102000UL
#define EVE_RAM_CMD 0x108000UL
#define EVE_RAM_SCREENSHOT 0x1C2000UL
/* Memory buffer sizes */
#define EVE_RAM_G_SIZE 256*1024L
#define EVE_CMDFIFO_SIZE 4*1024L
#define EVE_RAM_DL_SIZE 8*1024L
#define EVE_RAM_PAL_SIZE 1*1024L
/* Register definitions */
#define REG_ID 0x102400UL
#define REG_FRAMES 0x102404UL
#define REG_CLOCK 0x102408UL
#define REG_FREQUENCY 0x10240CUL
#define REG_SCREENSHOT_EN 0x102410UL
#define REG_SCREENSHOT_Y 0x102414UL
#define REG_SCREENSHOT_START 0x102418UL
#define REG_CPURESET 0x10241CUL
#define REG_TAP_CRC 0x102420UL
#define REG_TAP_MASK 0x102424UL
#define REG_HCYCLE 0x102428UL
#define REG_HOFFSET 0x10242CUL
#define REG_HSIZE 0x102430UL
#define REG_HSYNC0 0x102434UL
#define REG_HSYNC1 0x102438UL
#define REG_VCYCLE 0x10243CUL
#define REG_VOFFSET 0x102440UL
#define REG_VSIZE 0x102444UL
#define REG_VSYNC0 0x102448UL
#define REG_VSYNC1 0x10244CUL
#define REG_DLSWAP 0x102450UL
#define REG_ROTATE 0x102454UL
#define REG_OUTBITS 0x102458UL
#define REG_DITHER 0x10245CUL
#define REG_SWIZZLE 0x102460UL
#define REG_CSPREAD 0x102464UL
#define REG_PCLK_POL 0x102468UL
#define REG_PCLK 0x10246CUL
#define REG_TAG_X 0x102470UL
#define REG_TAG_Y 0x102474UL
#define REG_TAG 0x102478UL
#define REG_VOL_PB 0x10247CUL
#define REG_VOL_SOUND 0x102480UL
#define REG_SOUND 0x102484UL
#define REG_PLAY 0x102488UL
#define REG_GPIO_DIR 0x10248CUL
#define REG_GPIO 0x102490UL
#define REG_INT_FLAGS 0x102498UL
#define REG_INT_EN 0x10249CUL
#define REG_INT_MASK 0x1024A0UL
#define REG_PLAYBACK_START 0x1024A4UL
#define REG_PLAYBACK_LENGTH 0x1024A8UL
#define REG_PLAYBACK_READPTR 0x1024ACUL
#define REG_PLAYBACK_FREQ 0x1024B0UL
#define REG_PLAYBACK_FORMAT 0x1024B4UL
#define REG_PLAYBACK_LOOP 0x1024B8UL
#define REG_PLAYBACK_PLAY 0x1024BCUL
#define REG_PWM_HZ 0x1024C0UL
#define REG_PWM_DUTY 0x1024C4UL
#define REG_MACRO_0 0x1024C8UL
#define REG_MACRO_1 0x1024CCUL
#define REG_SCREENSHOT_BUSY 0x1024D8UL
#define REG_CMD_READ 0x1024E4UL
#define REG_CMD_WRITE 0x1024E8UL
#define REG_CMD_DL 0x1024ECUL
#define REG_TOUCH_MODE 0x1024F0UL
#define REG_TOUCH_ADC_MODE 0x1024F4UL
#define REG_TOUCH_CHARGE 0x1024F8UL
#define REG_TOUCH_SETTLE 0x1024FCUL
#define REG_TOUCH_OVERSAMPLE 0x102500UL
#define REG_TOUCH_RZTHRESH 0x102504UL
#define REG_TOUCH_RAW_XY 0x102508UL
#define REG_TOUCH_RZ 0x10250CUL
#define REG_TOUCH_SCREEN_XY 0x102510UL
#define REG_TOUCH_TAG_XY 0x102514UL
#define REG_TOUCH_TAG 0x102518UL
#define REG_TOUCH_TRANSFORM_A 0x10251CUL
#define REG_TOUCH_TRANSFORM_B 0x102520UL
#define REG_TOUCH_TRANSFORM_C 0x102524UL
#define REG_TOUCH_TRANSFORM_D 0x102528UL
#define REG_TOUCH_TRANSFORM_E 0x10252CUL
#define REG_TOUCH_TRANSFORM_F 0x102530UL
#define REG_SCREENSHOT_READ 0x102554UL
#define REG_TRIM 0x10256CUL
#define REG_TOUCH_DIRECT_XY 0x102574UL
#define REG_TOUCH_DIRECT_Z1Z2 0x102578UL
#define REG_TRACKER 0x109000UL
/* FT80x graphics engine specific macros useful for static display list generation */
#define BITMAP_SOURCE(addr) ((1UL<<24)|(((addr)&1048575UL)<<0))
#define SCISSOR_SIZE(width,height) ((28UL<<24)|(((width)&1023UL)<<10)|(((height)&1023UL)<<0))
#define SCISSOR_XY(x,y) ((27UL<<24)|(((x)&511UL)<<9)|(((y)&511UL)<<0))
#endif
#endif /* EVE_H_ */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/EVE.h | C | apache-2.0 | 31,870 |
/*
@file EVE_commands.c
@brief contains FT8xx / BT8xx functions
@version 4.0
@date 2020-04-13
@author Rudolph Riedel, David Jade
@section info
This file needs to be renamed to EVE_command.cpp for use with Arduino.
At least für ATSAM I had the best result with -O2.
The c-standard is C99.
@section LICENSE
MIT License
Copyright (c) 2016-2020 Rudolph Riedel and David Jade
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@section History
4.1 LvGL edition
- This version is a heavily modified version of the MIT licensed FT81x code from https://github.com/RudolphRiedel/FT800-FT813
This version is based on a fork by David Jade that added native SPI DMA support and stripped out non-ESP32 code.
It has also been trimmed down to suit LvGL's needs. Extra features can be enabled by defining FT81X_FULL
*/
#include <stdio.h>
#include "EVE.h"
#include "EVE_commands.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "soc/soc_memory_layout.h"
#include "esp_log.h"
#include "disp_spi.h"
#include <string.h>
#if defined (BT81X_ENABLE)
#include <stdarg.h>
#endif
#define TAG_LOG "FT81X"
/* data structure for SPI reading that has (optional) space for inserted dummy byte */
typedef struct _spi_read_data {
#if defined(DISP_SPI_FULL_DUPLEX)
uint8_t _dummy_byte;
#endif
union {
uint8_t byte;
uint16_t word;
uint32_t dword;
} __attribute__((packed));
} spi_read_data __attribute__((aligned(4)));
/* Receive data helpers */
#define member_size(type, member) sizeof(((type *)0)->member)
#if defined(DISP_SPI_FULL_DUPLEX)
#define SPI_READ_DUMMY_LEN member_size(spi_read_data, _dummy_byte)
#else
#define SPI_READ_DUMMY_LEN 0
#endif
#define SPI_READ_BYTE_LEN (SPI_READ_DUMMY_LEN + member_size(spi_read_data, byte))
#define SPI_READ_WORD_LEN (SPI_READ_DUMMY_LEN + member_size(spi_read_data, word))
#define SPI_READ_DWORD_LEN (SPI_READ_DUMMY_LEN + member_size(spi_read_data, dword))
// EVE Memory Commands - used with EVE_memWritexx and EVE_memReadxx
#define MEM_WRITE 0x80 // EVE Host Memory Write
#define MEM_READ 0x00 // EVE Host Memory Read
#define MEM_WRITE_24 0x800000 // EVE Host Memory Write (24-bit format)
volatile uint16_t cmdOffset = 0x0000; /* offset for the 4k co-processor FIFO */
volatile uint8_t cmd_burst = 0; /* flag to indicate cmd-burst is active */
// Buffer for SPI transactions
uint8_t SPIBuffer[SPI_BUFFER_SIZE]; // must be in DMA capable memory if DMA is used!
uint16_t SPIBufferIndex = 0;
disp_spi_send_flag_t SPIInherentSendFlags = 0; // additional inherent SPI flags (for DIO/QIO mode switching)
uint8_t SPIDummyReadBits = 0; // Dummy bits for reading in DIO/QIO modes
// Macros to make SPI use explicit and less verbose
// (macros do obscure code a little but they also help code search and readability)
// Buffer a byte
#define BUFFER_SPI_BYTE(byte) SPIBuffer[SPIBufferIndex++] = (byte);
// Buffer a Word - little Endian format
#define BUFFER_SPI_WORD(word) \
BUFFER_SPI_BYTE((uint8_t)(word)) \
BUFFER_SPI_BYTE((uint8_t)((word) >> 8))
// Buffer a DWord - little Endian format
#define BUFFER_SPI_DWORD(dword) \
BUFFER_SPI_BYTE((uint8_t)(dword)) \
BUFFER_SPI_BYTE((uint8_t)((dword) >> 8)) \
BUFFER_SPI_BYTE((uint8_t)((dword) >> 16)) \
BUFFER_SPI_BYTE((uint8_t)((dword) >> 24))
// Buffer a 24-bit SPI Memory Write address - big Endian format
#define BUFFER_SPI_WRITE_ADDRESS(addr) \
BUFFER_SPI_BYTE((uint8_t)((addr) >> 16) | MEM_WRITE) \
BUFFER_SPI_BYTE((uint8_t)((addr) >> 8)) \
BUFFER_SPI_BYTE((uint8_t)(addr))
// Send buffer
#define SEND_SPI_BUFFER() \
disp_spi_transaction(SPIBuffer, SPIBufferIndex, (disp_spi_send_flag_t)(DISP_SPI_SEND_QUEUED | SPIInherentSendFlags), NULL, 0, 0); \
SPIBufferIndex = 0;
// Wait for DMA queued SPI transactions to complete
#define WAIT_SPI() \
disp_wait_for_pending_transactions();
void DELAY_MS(uint16_t ms)
{
vTaskDelay(ms / portTICK_PERIOD_MS);
}
#if EVE_USE_PDN
void EVE_pdn_set(void)
{
gpio_set_level(EVE_PDN, 0); /* Power-Down low */
}
void EVE_pdn_clear(void)
{
gpio_set_level(EVE_PDN, 1); /* Power-Down high */
}
#endif
void spi_acquire()
{
disp_spi_acquire();
}
void spi_release()
{
disp_spi_release();
}
void EVE_cmdWrite(uint8_t command, uint8_t parameter)
{
const uint8_t data[] =
{
command,
parameter,
0x00
};
disp_spi_transaction(data, sizeof(data), (disp_spi_send_flag_t)(DISP_SPI_SEND_POLLING | SPIInherentSendFlags), NULL, 0, 0);
}
uint8_t EVE_memRead8(uint32_t ftAddress)
{
spi_read_data data = {};
disp_spi_send_flag_t readflags = (disp_spi_send_flag_t)(DISP_SPI_RECEIVE | DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags);
#if defined(DISP_SPI_HALF_DUPLEX)
// in half-duplex mode the FT81x requires dummy bits
readflags |= DISP_SPI_VARIABLE_DUMMY;
#endif
disp_spi_transaction(NULL, SPI_READ_BYTE_LEN, readflags, (uint8_t*)&data, ftAddress, SPIDummyReadBits);
return data.byte; /* return byte read */
}
uint16_t EVE_memRead16(uint32_t ftAddress)
{
#if defined(DISP_SPI_HALF_DUPLEX)
// There are esp32 issues when reading in DMA half-duplex mode that prevents reading more than 1 byte at a time so we work around that
uint16_t word = 0;
for(int i = 0; i < sizeof(word); i++)
{
word |= (EVE_memRead8(ftAddress + i) << i * 8);
}
return word;
#endif
spi_read_data data = {};
disp_spi_send_flag_t readflags = (disp_spi_send_flag_t)(DISP_SPI_RECEIVE | DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags);
#if defined(DISP_SPI_HALF_DUPLEX)
// in half-duplex mode the FT81x requires dummy bits
readflags |= DISP_SPI_VARIABLE_DUMMY;
#endif
disp_spi_transaction(NULL, SPI_READ_WORD_LEN, readflags, (uint8_t*)&data, ftAddress, SPIDummyReadBits);
return data.word; /* return integer read */
}
uint32_t EVE_memRead32(uint32_t ftAddress)
{
#if defined(DISP_SPI_HALF_DUPLEX)
// There are esp32 issues when reading in DMA half-duplex mode that prevents reading more than 1 byte at a time so we work around that
uint32_t dword = 0;
for(int i = 0; i < sizeof(dword); i++)
{
dword |= (EVE_memRead8(ftAddress + i) << i * 8);
}
return dword;
#endif
spi_read_data data = {};
disp_spi_send_flag_t readflags = (disp_spi_send_flag_t)(DISP_SPI_RECEIVE | DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags);
#if defined(DISP_SPI_HALF_DUPLEX)
// in half-duplex mode the FT81x requires dummy bits
readflags |= DISP_SPI_VARIABLE_DUMMY;
#endif
disp_spi_transaction(NULL, SPI_READ_DWORD_LEN, readflags, (uint8_t*)&data, ftAddress, SPIDummyReadBits);
return data.dword; /* return integer read */
}
void EVE_memWrite8(uint32_t ftAddress, uint8_t ftData8)
{
disp_spi_transaction(&ftData8, sizeof(ftData8), (disp_spi_send_flag_t)(DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags), NULL, (ftAddress | MEM_WRITE_24), 0);
}
void EVE_memWrite16(uint32_t ftAddress, uint16_t ftData16)
{
disp_spi_transaction((uint8_t*)&ftData16, sizeof(ftData16), (disp_spi_send_flag_t)(DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags), NULL, (ftAddress | MEM_WRITE_24), 0);
}
void EVE_memWrite32(uint32_t ftAddress, uint32_t ftData32)
{
disp_spi_transaction((uint8_t*)&ftData32, sizeof(ftData32), (disp_spi_send_flag_t)(DISP_SPI_SEND_POLLING | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags), NULL, (ftAddress | MEM_WRITE_24), 0);
}
// write to EVE memory via SPI memory-mapped protocol using queued SPI transactions (i.e. DMA)
// Note: data should be in DMA-capable memory!
void EVE_memWrite_buffer(uint32_t ftAddress, const uint8_t *data, uint32_t len, bool LvGL_Flush)
{
// chunk by DMA transfer size (SPI_TRANSER_SIZE)
uint32_t bytes_left = len;
while(bytes_left > 0)
{
uint32_t block_len = (bytes_left > SPI_TRANSER_SIZE ? SPI_TRANSER_SIZE : bytes_left);
// only send flush on last chunk
disp_spi_send_flag_t flush_flag = 0;
if(LvGL_Flush && bytes_left - block_len == 0)
{
flush_flag = DISP_SPI_SIGNAL_FLUSH;
}
disp_spi_transaction(data, block_len, (disp_spi_send_flag_t)(DISP_SPI_SEND_QUEUED | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags | flush_flag), NULL, (ftAddress | MEM_WRITE_24), 0);
data += block_len;
ftAddress += block_len;
bytes_left -= block_len;
}
}
/* Check if the graphics processor completed executing the current command list. */
/* This is the case when REG_CMD_READ matches cmdOffset, indicating that all commands have been executed. */
uint8_t EVE_busy(void)
{
uint16_t cmdBufferRead;
WAIT_SPI(); // can't tell if EVE is busy if SPI is taking place
cmdBufferRead = EVE_memRead16(REG_CMD_READ); /* read the graphics processor read pointer */
if(cmdBufferRead == 0xFFF) /* we have a co-processor fault, make EVE play with us again */
{
#if defined (BT81X_ENABLE)
uint16_t copro_patch_pointer;
copro_patch_pointer = EVE_memRead16(REG_COPRO_PATCH_DTR);
#endif
EVE_memWrite8(REG_CPURESET, 1); /* hold co-processor engine in the reset condition */
EVE_memWrite16(REG_CMD_READ, 0); /* set REG_CMD_READ to 0 */
EVE_memWrite16(REG_CMD_WRITE, 0); /* set REG_CMD_WRITE to 0 */
EVE_memWrite32(REG_CMD_DL, 0); /* reset REG_CMD_DL to 0 as required by the BT81x programming guide, should not hurt FT8xx */
cmdOffset = 0;
EVE_memWrite8(REG_CPURESET, 0); /* set REG_CMD_WRITE to 0 to restart the co-processor engine*/
#if defined (BT81X_ENABLE)
EVE_memWrite16(REG_COPRO_PATCH_DTR, copro_patch_pointer);
DELAY_MS(5); /* just to be safe */
// reset the SPI buffer just to be cautious
SPIBufferIndex = 0;
BUFFER_SPI_WRITE_ADDRESS(EVE_RAM_CMD + cmdOffset)
BUFFER_SPI_DWORD(CMD_FLASHATTACH)
BUFFER_SPI_DWORD(CMD_FLASHFAST)
SEND_SPI_BUFFER()
WAIT_SPI()
cmdOffset += 8;
BUFFER_SPI_BYTE
BUFFER_SPI_BYTE(MEM_WRITE | 0x30); /* send Memory Write plus high address byte of REG_CMD_WRITE for EVE81x */
BUFFER_SPI_BYTE(0x20); /* send middle address byte of REG_CMD_WRITE for EVE81x */
BUFFER_SPI_BYTE(0xfc); /* send low address byte of REG_CMD_WRITE for EVE81x */
BUFFER_SPI_WORD(cmdOffset);
SEND_SPI_BUFFER()
WAIT_SPI()
EVE_memWrite8(REG_PCLK, EVE_PCLK); /* restore REG_PCLK in case it was set to zero by an error */
DELAY_MS(5); /* just to be safe */
#endif
}
if(cmdOffset != cmdBufferRead)
{
return 1;
}
else
{
return 0;
}
}
void EVE_get_cmdoffset(void)
{
cmdOffset = EVE_memRead16(REG_CMD_WRITE);
}
void EVE_inc_cmdoffset(uint16_t increment)
{
cmdOffset += increment;
cmdOffset &= 0x0fff; // circular
}
/* order the command co-processor to start processing its FIFO queue and do not wait for completion */
void EVE_cmd_start(void)
{
WAIT_SPI();
EVE_memWrite16(REG_CMD_WRITE, cmdOffset);
}
/* order the command co-processor to start processing its FIFO queue and wait for completion */
void EVE_cmd_execute(void)
{
EVE_cmd_start();
while (EVE_busy());
}
/* begin a co-processor command, this is used for all non-display-list commands */
void EVE_begin_cmd(uint32_t command)
{
BUFFER_SPI_WRITE_ADDRESS(EVE_RAM_CMD + cmdOffset)
BUFFER_SPI_DWORD(command)
EVE_inc_cmdoffset(4); // only count the command size - not the write address directive
}
/* co-processor commands that are not used in displays lists, these are no to be used with async transfers */
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_memzero(uint32_t ptr, uint32_t num)
{
EVE_begin_cmd(CMD_MEMZERO);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
}
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_memset(uint32_t ptr, uint8_t value, uint32_t num)
{
EVE_begin_cmd(CMD_MEMSET);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(value)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
}
/* this is meant to be called outside display-list building, does not support cmd-burst */
void block_transfer(const uint8_t *data, uint32_t len); // forward ref
void EVE_cmd_memwrite(uint32_t dest, uint32_t num, const uint8_t *data)
{
EVE_begin_cmd(CMD_MEMWRITE);
BUFFER_SPI_DWORD(dest)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
block_transfer(data, num); // block_transfer is immediate - make sure CMD buffer is prepared!
}
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num)
{
EVE_begin_cmd(CMD_MEMCPY);
BUFFER_SPI_DWORD(dest)
BUFFER_SPI_DWORD(src)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
}
/* commands for loading image data into FT8xx CMD memory, with DWORD padding: */
/* Note: these are immediate SPI transfers and assume the CMD buffer is prepared to process the data, etc... */
// Note: data should be in DMA-capable memory!
void eve_spi_CMD_write(uint64_t addr, const uint8_t *data, uint16_t len)
{
// we can use a direct transaction because it is already chunked
disp_spi_transaction(data, len, (disp_spi_send_flag_t)(DISP_SPI_SEND_QUEUED | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags), NULL, (addr | MEM_WRITE_24), 0);
uint8_t padding = len & 0x03; /* 0, 1, 2 or 3 */
padding = 4 - padding; /* 4, 3, 2 or 1 */
padding &= 3; /* 3, 2, 1 or 0 */
// padding is another transaction and needs it's own address (this is a DMA requirement)
if(padding)
{
addr += len;
uint8_t padData[4] = {0};
disp_spi_transaction(padData, padding, (disp_spi_send_flag_t)(DISP_SPI_SEND_QUEUED | DISP_SPI_ADDRESS_24 | SPIInherentSendFlags), NULL, (addr | MEM_WRITE_24), 0);
len += padding;
}
EVE_inc_cmdoffset(len);
}
void block_transfer(const uint8_t *data, uint32_t len)
{
WAIT_SPI(); // SPI commands must be in CMD buffer first
uint32_t bytes_left;
bytes_left = len;
while(bytes_left > 0)
{
uint32_t block_len;
block_len = (bytes_left > BLOCK_TRANSFER_SIZE ? BLOCK_TRANSFER_SIZE : bytes_left);
eve_spi_CMD_write(EVE_RAM_CMD + cmdOffset, data, block_len);
data += block_len;
bytes_left -= block_len;
// signal to process data
EVE_cmd_execute();
}
}
#if FT81X_FULL
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
void EVE_cmd_inflate(uint32_t ptr, const uint8_t *data, uint16_t len)
{
EVE_begin_cmd(CMD_INFLATE);
BUFFER_SPI_DWORD(ptr)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
block_transfer(data, len); // block_transfer is immediate - make sure CMD buffer is prepared!
}
#if defined (BT81X_ENABLE)
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
void EVE_cmd_inflate2(uint32_t ptr, uint32_t options, const uint8_t *data, uint16_t len)
{
EVE_begin_cmd(CMD_INFLATE2);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(options)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
if(options == 0) /* direct data, not by Media-FIFO or Flash */
{
block_transfer(data, len); // block_transfer is immediate - make sure CMD buffer is prepared!
}
}
#endif
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
void EVE_cmd_loadimage(uint32_t ptr, uint32_t options, const uint8_t *data, uint16_t len)
{
EVE_begin_cmd(CMD_LOADIMAGE);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(options)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
#if defined (BT81X_ENABLE)
if( ((options & EVE_OPT_MEDIAFIFO) == 0) && ((options & EVE_OPT_FLASH) == 0) )/* direct data, neither by Media-FIFO or from Flash */
#elif defined (FT81X_ENABLE)
if((options & EVE_OPT_MEDIAFIFO) == 0) /* direct data, not by Media-FIFO */
#endif
{
block_transfer(data, len); // block_transfer is immediate - make sure CMD buffer is prepared!
}
}
#if defined (FT81X_ENABLE)
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_mediafifo(uint32_t ptr, uint32_t size)
{
EVE_begin_cmd(CMD_MEDIAFIFO);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(size)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
}
#endif
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_interrupt(uint32_t ms)
{
EVE_begin_cmd(CMD_INTERRUPT);
BUFFER_SPI_DWORD(ms)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
}
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_setfont(uint32_t font, uint32_t ptr)
{
EVE_begin_cmd(CMD_SETFONT);
BUFFER_SPI_DWORD(font)
BUFFER_SPI_DWORD(ptr)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
}
#if defined (FT81X_ENABLE)
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_setfont2(uint32_t font, uint32_t ptr, uint32_t firstchar)
{
EVE_begin_cmd(CMD_SETFONT2);
BUFFER_SPI_DWORD(font)
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(firstchar)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
}
#endif
#if defined (FT81X_ENABLE)
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_setrotate(uint32_t r)
{
EVE_begin_cmd(CMD_SETROTATE);
BUFFER_SPI_DWORD(r)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
}
#endif
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_snapshot(uint32_t ptr)
{
EVE_begin_cmd(CMD_SNAPSHOT);
BUFFER_SPI_DWORD(ptr)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
}
#if defined (FT81X_ENABLE)
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_snapshot2(uint32_t fmt, uint32_t ptr, int16_t x0, int16_t y0, int16_t w0, int16_t h0)
{
EVE_begin_cmd(CMD_SNAPSHOT2);
BUFFER_SPI_DWORD(fmt)
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
EVE_inc_cmdoffset(16);
SEND_SPI_BUFFER()
}
#endif
/* this is meant to be called outside display-list building, does not support cmd-burst */
void EVE_cmd_track(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t tag)
{
EVE_begin_cmd(CMD_TRACK);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(tag)
BUFFER_SPI_WORD(0)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
}
/* commands that return values by writing to the command-fifo */
/* note: yes, these are different than the functions in the Programmers Guide from FTDI,
this is because I have no idea why anyone would want to pass "result" as an actual argument to these functions
when this only marks the offset the command-processor is writing to */
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* crc32 = EVE_cmd_memcrc(my_ptr_to_some_memory_region, some_amount_of_bytes); */
uint32_t EVE_cmd_memcrc(uint32_t ptr, uint32_t num)
{
EVE_begin_cmd(CMD_MEMCRC);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(num)
BUFFER_SPI_DWORD(0)
EVE_inc_cmdoffset(8);
uint16_t offset = cmdOffset;
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
EVE_cmd_execute();
return (EVE_memRead32(EVE_RAM_CMD + offset));
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* address = EVE_cmd_getpr(); */
uint32_t EVE_cmd_getptr(void)
{
EVE_begin_cmd(CMD_GETPTR);
uint16_t offset = cmdOffset;
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
EVE_cmd_execute();
return (EVE_memRead32(EVE_RAM_CMD + offset));
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* regvalue = EVE_cmd_regread(ptr); */
/* this seems to be completely pointless, there is no real use for it outside a display-list since the register could be read directly */
/* and for what purpose would this be implemented to be used in a display list?? */
uint32_t EVE_cmd_regread(uint32_t ptr)
{
uint16_t offset;
EVE_begin_cmd(CMD_REGREAD);
BUFFER_SPI_DWORD(ptr)
EVE_inc_cmdoffset(4);
offset = cmdOffset;
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
EVE_cmd_execute();
return (EVE_memRead32(EVE_RAM_CMD + offset));
}
/*
Get the properties of an image after a CMD_LOADIMAGE operation.
uint32 pointer, width, height;
EVE_LIB_GetProps(&pointer, &width, &height);
uint32 width, height;
EVE_LIB_GetProps(0, &width, &height);
this is meant to be called outside display-list building, it includes executing the command
and waiting for completion, does not support cmd-burst
*/
void EVE_LIB_GetProps(uint32_t *pointer, uint32_t *width, uint32_t *height)
{
EVE_begin_cmd(CMD_GETPROPS);
uint16_t offset = cmdOffset;
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
EVE_cmd_execute();
if(pointer)
{
*pointer = EVE_memRead32(EVE_RAM_CMD + offset);
}
if(width)
{
*width = EVE_memRead32(EVE_RAM_CMD + offset + 4);
}
if(height)
{
*height = EVE_memRead32(EVE_RAM_CMD + offset + 8);
}
}
/* FT811 / FT813 binary-blob from FTDIs AN_336 to patch the touch-engine for Goodix GT911 / GT9271 touch controllers */
#if defined (EVE_HAS_GT911)
#if defined (__AVR__)
#include <avr/pgmspace.h>
#else
#define PROGMEM
#endif
const uint16_t EVE_GT911_len = 1184;
const uint8_t EVE_GT911_data[1184] PROGMEM =
{
26,255,255,255,32,32,48,0,4,0,0,0,2,0,0,0,
34,255,255,255,0,176,48,0,120,218,237,84,221,111,84,69,20,63,51,179,93,160,148,101,111,76,5,44,141,123,111,161,11,219,154,16,9,16,17,229,156,75,26,11,13,21,227,3,16,252,184,179,
45,219,143,45,41,125,144,72,67,100,150,71,189,113,18,36,17,165,100,165,198,16,32,17,149,196,240,128,161,16,164,38,54,240,0,209,72,130,15,38,125,48,66,82,30,76,19,31,172,103,46,
139,24,255,4,227,157,204,156,51,115,102,206,231,239,220,5,170,94,129,137,75,194,216,98,94,103,117,115,121,76,131,177,125,89,125,82,123,60,243,58,142,242,204,185,243,188,118,156,
227,155,203,238,238,195,251,205,229,71,92,28,169,190,184,84,143,113,137,53,244,103,181,237,87,253,113,137,233,48,12,198,165,181,104,139,25,84,253,155,114,74,191,0,54,138,163,
12,62,131,207,129,23,217,34,91,31,128,65,246,163,175,213,8,147,213,107,35,203,94,108,3,111,40,171,83,24,15,165,177,222,116,97,23,188,140,206,150,42,102,181,87,78,86,182,170,134,
215,241,121,26,243,252,2,76,115,217,139,222,206,173,136,132,81,61,35,185,39,113,23,46,199,76,178,54,151,183,224,0,40,189,28,149,182,58,131,79,152,30,76,34,98,234,162,216,133,141,
102,39,170,40,192,101,53,201,146,191,37,77,44,177,209,74,211,5,206,187,5,6,216,47,53,96,123,22,50,103,251,192,84,17,74,227,185,56,106,51,91,161,96,182,163,48,171,141,139,65,152,
66,66,11,102,43,158,75,36,80,147,184,147,139,112,17,235,216,103,111,239,245,92,10,175,194,40,44,58,125,5,59,112,50,103,245,4,78,192,5,156,194,51,60,191,134,75,110,173,237,46,192,
121,156,192,115,184,218,120,67,63,115,46,11,102,10,97,232,50,235,114,182,148,118,178,41,188,12,135,77,202,124,12,96,238,35,161,234,189,129,23,249,212,139,230,25,53,48,205,52,93,
163,117,53,154,170,81,85,163,178,70,69,66,167,241,14,46,241,1,226,136,152,179,197,59,184,148,254,49,132,48,15,176,137,192,76,131,196,105,104,162,86,81,160,165,255,26,173,162,137,
86,145,210,183,192,55,175,194,211,60,91,120,230,184,174,27,41,131,155,40,224,29,87,179,232,16,55,55,7,165,147,81,23,165,49,101,54,224,75,180,81,108,18,29,226,69,225,110,175,224,
42,212,25,47,130,193,110,234,192,215,252,56,74,162,24,46,251,174,54,106,68,245,14,9,155,160,22,120,207,104,240,29,90,178,140,28,24,220,47,166,112,61,251,208,192,111,56,239,238,
93,255,251,62,99,32,193,75,61,190,235,123,229,110,218,194,85,79,225,59,98,20,238,227,235,220,11,221,149,25,180,116,194,159,111,96,192,24,213,59,139,179,156,215,69,230,19,24,35,
135,117,206,171,206,162,67,129,234,61,235,11,104,103,84,64,223,167,254,40,163,101,92,84,43,150,46,249,219,205,7,116,11,91,104,61,57,75,223,8,48,25,28,119,252,222,113,49,86,249,
74,180,211,156,181,61,215,168,157,7,251,199,150,242,250,91,58,132,94,121,7,53,151,139,98,6,165,153,69,214,32,110,211,100,101,31,89,45,81,98,23,205,205,197,209,109,186,198,35,
141,191,249,25,60,132,223,153,251,98,20,239,146,139,20,217,250,41,250,137,58,177,90,57,79,51,108,233,20,253,194,187,49,222,205,114,141,96,48,175,219,107,54,111,138,22,154,103,
108,79,58,252,179,178,79,164,195,2,153,36,39,170,199,201,167,197,85,106,8,59,177,81,46,56,2,230,75,114,17,55,112,188,65,208,137,77,114,10,115,55,58,208,197,173,122,87,6,140,
110,42,208,124,163,70,108,241,104,18,245,98,214,187,134,53,42,221,22,182,133,211,116,148,177,194,209,192,85,90,199,58,55,203,2,229,19,137,187,161,228,154,112,203,145,125,244,
188,220,118,228,41,201,181,41,195,144,215,183,51,80,250,21,217,16,217,200,235,109,227,188,122,218,142,60,170,224,112,240,184,130,229,224,113,5,223,148,163,80,165,183,130,187,
132,116,64,238,161,85,220,115,139,205,98,227,244,29,102,125,7,37,243,123,223,11,26,92,63,243,116,61,191,138,123,244,160,84,186,74,31,5,174,247,119,135,199,248,253,135,242,97,
102,145,190,144,14,85,238,221,231,193,158,48,205,25,120,248,15,220,29,158,9,70,185,30,103,229,33,254,23,237,160,172,62,193,90,222,224,232,14,200,56,90,104,142,227,120,110,6,
21,211,203,65,150,99,151,220,247,87,164,50,159,49,239,234,58,142,0,109,108,123,18,79,227,36,100,248,222,205,96,127,120,26,171,228,69,63,36,17,252,200,17,116,242,187,227,88,143,
247,2,75,191,6,130,59,188,11,55,240,31,243,122,152,226,183,207,154,73,188,39,219,43,105,222,87,41,143,141,140,175,73,112,184,252,61,184,16,90,250,35,168,82,119,176,57,116,94,
200,150,22,190,179,44,104,12,235,84,149,102,252,89,154,193,99,228,106,242,125,248,64,194,255,223,127,242,83,11,255,2,70,214,226,128,0,0
};
#endif
#endif // FT81X_FULL
/* init, has to be executed with the SPI setup to 11 MHz or less as required by FT8xx / BT8xx */
uint8_t EVE_init(void)
{
uint8_t chipid = 0;
uint16_t timeout = 0;
#if EVE_USE_PDN
EVE_pdn_set();
DELAY_MS(6); /* minimum time for power-down is 5ms */
EVE_pdn_clear();
DELAY_MS(21); /* minimum time to allow from rising PD_N to first access is 20ms */
#endif
/* EVE_cmdWrite(EVE_CORERST,0); */ /* reset, only required for warm-start if PowerDown line is not used */
#if defined (EVE_HAS_CRYSTAL)
EVE_cmdWrite(EVE_CLKEXT, 0); /* setup EVE for external clock */
#else
EVE_cmdWrite(EVE_CLKINT, 0); /* setup EVE for internal clock */
#endif
#if defined (BT81X_ENABLE)
EVE_cmdWrite(EVE_CLKSEL ,0x46); /* set clock to 72 MHz */
#endif
EVE_cmdWrite(EVE_ACTIVE, 0); /* start EVE */
/* BRT AN033 BT81X_Series_Programming_Guide V1.2 had a small change to chapter 2.4 "Initialization Sequence during Boot Up" */
/* Send Host command “ACTIVE” and wait for at least 300 milliseconds. */
/* Ensure that there is no SPI access during this time. */
/* I asked Bridgetek for clarification why this has been made stricter. */
/* From observation with quite a few of different displays I do not agree that either the 300ms are necessary or that */
/* *reading* the SPI while EVE inits itself is causing any issues. */
/* But since BT815 at 72MHz need 42ms anyways before they start to answer, here is my compromise, a fixed 40ms delay */
/* to provide at least a short moment of silence for EVE */
DELAY_MS(40);
/* The most reliable DIO/QIO switching point is after EVE start up but before reading the ChipID. */
#if defined(DISP_SPI_TRANS_MODE_DIO)
ESP_LOGI(TAG_LOG, "Switching to DIO mode");
DELAY_MS(20); /* different boards may take a different delay but this generally seems to work */
EVE_memWrite16(REG_SPI_WIDTH, SPI_WIDTH_DIO);
SPIInherentSendFlags = DISP_SPI_MODE_DIO | DISP_SPI_MODE_DIOQIO_ADDR;
SPIDummyReadBits = 4; /* Esp32 DMA SPI transaction dummy_bits works more like clock cycles, so in DIO 4 dummy_bits == 8 total bits */
#elif defined(DISP_SPI_TRANS_MODE_QIO)
ESP_LOGI(TAG_LOG, "Switching to QIO mode");
DELAY_MS(20); /* different boards may take a different delay but this generally seems to work */
EVE_memWrite16(REG_SPI_WIDTH, SPI_WIDTH_QIO);
SPIInherentSendFlags = DISP_SPI_MODE_QIO | DISP_SPI_MODE_DIOQIO_ADDR;
SPIDummyReadBits = 2; /* Esp32 DMA SPI transaction dummy_bits works more like clock cycles, so in QIO 2 dummy_bits == 8 total bits */
#elif defined(DISP_SPI_HALF_DUPLEX)
SPIDummyReadBits = 8; /* SIO half-duplex mode */
#endif
while(chipid != 0x7C) /* if chipid is not 0x7c, continue to read it until it is, EVE needs a moment for it's power on self-test and configuration */
{
DELAY_MS(1);
chipid = EVE_memRead8(REG_ID);
timeout++;
if(timeout > 400)
{
ESP_LOGI(TAG_LOG, "Failed to read ChipID...aborting initialization.");
return 0;
}
}
timeout = 0;
while (0x00 != (EVE_memRead8(REG_CPURESET) & 0x03)) /* check if EVE is in working status */
{
DELAY_MS(1);
timeout++;
if(timeout > 50) /* experimental, 10 was the lowest value to get the BT815 started with, the touch-controller was the last to get out of reset */
{
ESP_LOGI(TAG_LOG, "Failed to read CPU status...aborting initialization.");
return 0;
}
}
/* tell EVE that we changed the frequency from default to 72MHz for BT8xx */
#if defined (BT81X_ENABLE)
EVE_memWrite32(REG_FREQUENCY, 72000000);
#endif
/* we have a display with a Goodix GT911 / GT9271 touch-controller on it, so we patch our FT811 or FT813 according to AN_336 or setup a BT815 accordingly */
#if defined (EVE_HAS_GT911)
#if defined (BT81X_ENABLE)
EVE_memWrite32(REG_TOUCH_CONFIG, 0x000005d1); /* switch to Goodix touch controller */
#else
EVE_get_cmdoffset();
BUFFER_SPI_WRITE_ADDRESS(EVE_RAM_CMD + cmdOffset)
SEND_SPI_BUFFER()
spi_flash_write(EVE_GT911_data, EVE_GT911_len);
EVE_cmd_execute();
EVE_memWrite8(REG_TOUCH_OVERSAMPLE, 0x0f); /* setup oversample to 0x0f as "hidden" in binary-blob for AN_336 */
EVE_memWrite16(REG_TOUCH_CONFIG, 0x05D0); /* write magic cookie as requested by AN_336 */
/* specific to the EVE2 modules from Matrix-Orbital we have to use GPIO3 to reset GT911 */
EVE_memWrite16(REG_GPIOX_DIR, 0x8008); /* Reset-Value is 0x8000, adding 0x08 sets GPIO3 to output, default-value for REG_GPIOX is 0x8000 -> Low output on GPIO3 */
DELAY_MS(1); /* wait more than 100µs */
EVE_memWrite8(REG_CPURESET, 0x00); /* clear all resets */
DELAY_MS(56); /* wait more than 55ms */
EVE_memWrite16(REG_GPIOX_DIR, 0x8000); /* setting GPIO3 back to input */
#endif
#endif
/* EVE_memWrite8(REG_PCLK, 0x00); */ /* set PCLK to zero - don't clock the LCD until later, line disabled because zero is reset-default and we just did a reset */
#if defined (EVE_ADAM101)
EVE_memWrite8(REG_PWM_DUTY, 0x80); /* turn off backlight for Glyn ADAM101 module, it uses inverted values */
#else
EVE_memWrite8(REG_PWM_DUTY, 0); /* turn off backlight for any other module */
#endif
/* Initialize Display */
EVE_memWrite16(REG_HSIZE, EVE_HSIZE); /* active display width */
EVE_memWrite16(REG_HCYCLE, EVE_HCYCLE); /* total number of clocks per line, incl front/back porch */
EVE_memWrite16(REG_HOFFSET, EVE_HOFFSET); /* start of active line */
EVE_memWrite16(REG_HSYNC0, EVE_HSYNC0); /* start of horizontal sync pulse */
EVE_memWrite16(REG_HSYNC1, EVE_HSYNC1); /* end of horizontal sync pulse */
EVE_memWrite16(REG_VSIZE, EVE_VSIZE); /* active display height */
EVE_memWrite16(REG_VCYCLE, EVE_VCYCLE); /* total number of lines per screen, including pre/post */
EVE_memWrite16(REG_VOFFSET, EVE_VOFFSET); /* start of active screen */
EVE_memWrite16(REG_VSYNC0, EVE_VSYNC0); /* start of vertical sync pulse */
EVE_memWrite16(REG_VSYNC1, EVE_VSYNC1); /* end of vertical sync pulse */
EVE_memWrite8(REG_SWIZZLE, EVE_SWIZZLE); /* FT8xx output to LCD - pin order */
EVE_memWrite8(REG_PCLK_POL, EVE_PCLKPOL); /* LCD data is clocked in on this PCLK edge */
EVE_memWrite8(REG_CSPREAD, EVE_CSPREAD); /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
/* do not set PCLK yet - wait for just after the first display list */
/* configure Touch */
EVE_memWrite8(REG_TOUCH_MODE, EVE_TMODE_CONTINUOUS); /* enable touch */
EVE_memWrite16(REG_TOUCH_RZTHRESH, EVE_TOUCH_RZTHRESH); /* eliminate any false touches */
/* disable Audio for now */
EVE_memWrite8(REG_VOL_PB, 0x00); /* turn recorded audio volume down */
EVE_memWrite8(REG_VOL_SOUND, 0x00); /* turn synthesizer volume off */
EVE_memWrite16(REG_SOUND, 0x6000); /* set synthesizer to mute */
/* write a basic display-list to get things started */
EVE_memWrite32(EVE_RAM_DL, DL_CLEAR_RGB);
EVE_memWrite32(EVE_RAM_DL + 4, (DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG));
EVE_memWrite32(EVE_RAM_DL + 8, DL_DISPLAY); /* end of display list */
EVE_memWrite32(REG_DLSWAP, EVE_DLSWAP_FRAME);
/* nothing is being displayed yet... the pixel clock is still 0x00 */
EVE_memWrite8(REG_GPIO, 0x80); /* enable the DISP signal to the LCD panel, it is set to output in REG_GPIO_DIR by default */
EVE_memWrite8(REG_PCLK, EVE_PCLK); /* now start clocking data to the LCD panel */
#if defined (EVE_ADAM101)
EVE_memWrite8(REG_PWM_DUTY, 0x60); /* turn on backlight to 25% for Glyn ADAM101 module, it uses inverted values */
#else
EVE_memWrite8(REG_PWM_DUTY, 0x20); /* turn on backlight to 25% for any other module */
#endif
timeout = 0;
while(EVE_busy()) /* just to be safe, should not even enter the loop */
{
DELAY_MS(1);
timeout++;
if(timeout > 4)
{
break; /* something is wrong here, but since we made it this far through the init, just leave the loop */
}
}
EVE_get_cmdoffset(); /* just to be safe */
#if defined (EVE_DMA)
EVE_init_dma(); /* prepare DMA */
#endif
return 1;
}
/*
These eliminate the overhead of transmitting the command-fifo address with every single command, just wrap a sequence of commands
with these and the address is only transmitted once at the start of the block.
Be careful to not use any functions in the sequence that do not address the command-fifo as for example any EVE_mem...() function.
*/
void EVE_start_cmd_burst(void)
{
cmd_burst = 42;
WAIT_SPI() // it is important to wait before writing to the SPI buffer as it might be in a DMA transaction
BUFFER_SPI_WRITE_ADDRESS(EVE_RAM_CMD + cmdOffset)
}
void EVE_end_cmd_burst(void)
{
cmd_burst = 0;
SEND_SPI_BUFFER()
}
/* begin a co-processor command */
void EVE_start_cmd(uint32_t command)
{
if(!cmd_burst)
{
WAIT_SPI() // it is important to wait before writing to the SPI buffer as it might be in a DMA transaction
BUFFER_SPI_WRITE_ADDRESS(EVE_RAM_CMD + cmdOffset)
}
BUFFER_SPI_DWORD(command)
EVE_inc_cmdoffset(4); /* update the command-ram pointer */
}
/* generic function for all commands that have no arguments and all display-list specific control words */
/*
examples:
EVE_cmd_dl(CMD_DLSTART);
EVE_cmd_dl(CMD_SWAP);
EVE_cmd_dl(CMD_SCREENSAVER);
EVE_cmd_dl(LINE_WIDTH(1*16));
EVE_cmd_dl(VERTEX2F(0,0));
EVE_cmd_dl(DL_BEGIN | EVE_RECTS);
*/
void EVE_cmd_dl(uint32_t command)
{
if(cmd_burst)
{
BUFFER_SPI_DWORD(command)
EVE_inc_cmdoffset(4); /* update the command-ram pointer */
}
else
{
EVE_start_cmd(command);
SEND_SPI_BUFFER()
}
}
#if FT81X_FULL
/* write a string to co-processor memory in context of a command: no chip-select, just plain SPI-transfers */
/* note: assumes cmdOffset is already DWORD aligned */
void EVE_write_string(const char *text)
{
uint8_t textindex = 0;
uint8_t padding = 0;
uint8_t *bytes = (uint8_t *) text; /* need to handle the array as bunch of bytes */
while(bytes[textindex] != 0)
{
BUFFER_SPI_BYTE(bytes[textindex]);
textindex++;
if(textindex > 249 || SPIBufferIndex >= SPI_BUFFER_SIZE) /* there appears to be no end for the "string", or no more room in SPI buffer, so leave */
{
break;
}
}
/* we need to transmit at least one 0x00 byte and up to four if the string happens to be 4-byte aligned already */
padding = textindex & 3; /* 0, 1, 2 or 3 */
padding = 4-padding; /* 4, 3, 2 or 1 */
textindex += padding;
while(padding > 0 && SPIBufferIndex < SPI_BUFFER_SIZE)
{
BUFFER_SPI_BYTE(0);
padding--;
}
EVE_inc_cmdoffset(textindex);
}
/* EVE3 FLASH functions */
#if defined (BT81X_ENABLE)
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* write "num" bytes from *data to the external flash on a BT81x board at address ptr */
/* note: ptr must be 256 byte aligned, num must be a multiple of 256 */
/* note: EVE will not do anything if the alignment requirements are not met */
/* note: the address ptr is relative to the flash so the first address is 0x00000000 not 0x800000 */
/* note: on AVR controllers this expects the data to be located in the controllers flash memory */
void EVE_cmd_flashwrite(uint32_t ptr, uint32_t num, const uint8_t *data)
{
EVE_begin_cmd(CMD_FLASHWRITE);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
WAIT_SPI()
block_transfer(data, num);
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* write "num" bytes from src in the external flash on a BT81x board to dest in RAM_G */
/* note: src must be 64-byte aligned, dest must be 4-byte aligned, num must be a multiple of 4 */
/* note: EVE will not do anything if the alignment requirements are not met */
/* note: the src pointer is relative to the flash so the first address is 0x00000000 not 0x800000 */
void EVE_cmd_flashread(uint32_t dest, uint32_t src, uint32_t num)
{
EVE_begin_cmd(CMD_FLASHREAD);
BUFFER_SPI_DWORD(dest)
BUFFER_SPI_DWORD(src)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* write "num" bytes from src in RAM_G to to the external flash on a BT81x board at address dest */
/* note: dest must be 4096-byte aligned, src must be 4-byte aligned, num must be a multiple of 4096 */
/* note: EVE will not do anything if the alignment requirements are not met */
/* note: the address ptr is relative to the flash so the first address is 0x00000000 not 0x800000 */
void EVE_cmd_flashupdate(uint32_t dest, uint32_t src, uint32_t num)
{
EVE_begin_cmd(CMD_FLASHUPDATE);
BUFFER_SPI_DWORD(dest)
BUFFER_SPI_DWORD(src)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(12);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* this is added for conveniance, using EVE_cmd_dl(CMD_FLASHERASE); followed by EVE_cmd_execute(); would work as well */
void EVE_cmd_flasherase(void)
{
EVE_begin_cmd(CMD_FLASHERASE);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* this is added for conveniance, using EVE_cmd_dl(CMD_FLASHATTACH); followed by EVE_cmd_execute(); would work as well */
void EVE_cmd_flashattach(void)
{
EVE_begin_cmd(CMD_FLASHATTACH);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* this is added for conveniance, using EVE_cmd_dl(CMD_FLASHDETACH); followed by EVE_cmd_execute(); would work as well */
void EVE_cmd_flashdetach(void)
{
EVE_begin_cmd(CMD_FLASHDETACH);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* this is added for conveniance, using EVE_cmd_dl(CMD_FLASHSPIDESEL); followed by EVE_cmd_execute(); would work as well */
void EVE_cmd_flashspidesel(void)
{
EVE_begin_cmd(CMD_FLASHSPIDESEL);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
uint32_t EVE_cmd_flashfast(void)
{
uint16_t offset;
EVE_begin_cmd(CMD_FLASHFAST);
BUFFER_SPI_DWORD(0)
offset = cmdOffset;
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
EVE_cmd_execute();
return EVE_memRead32(EVE_RAM_CMD + offset);
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* write "num" bytes from *data to the BT81x SPI interface */
/* note: raw direct access, not really useful for anything */
void EVE_cmd_flashspitx(uint32_t num, const uint8_t *data)
{
EVE_begin_cmd(CMD_FLASHSPITX);
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
WAIT_SPI()
block_transfer(data, num);
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
/* write "num" bytes from the BT81x SPI interface dest in RAM_G */
/* note: raw direct access, not really useful for anything */
void EVE_cmd_flashspirx(uint32_t dest, uint32_t num)
{
EVE_begin_cmd(CMD_FLASHREAD);
BUFFER_SPI_DWORD(dest)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* this is meant to be called outside display-list building, it includes executing the command and waiting for completion, does not support cmd-burst */
void EVE_cmd_flashsource(uint32_t ptr)
{
EVE_begin_cmd(CMD_FLASHSOURCE);
BUFFER_SPI_DWORD(ptr)
EVE_inc_cmdoffset(4);
SEND_SPI_BUFFER()
EVE_cmd_execute();
}
/* switch the FLASH attached to a BT815/BT816 to full-speed mode, returns 0 for failing to do so, does not support cmd-burst */
uint8_t EVE_init_flash(void)
{
uint8_t timeout = 0;
uint8_t status;
status = EVE_memRead8(REG_FLASH_STATUS); /* should be 0x02 - FLASH_STATUS_BASIC, power-up is done and the attached flash is detected */
while(status == 0) /* FLASH_STATUS_INIT - we are somehow still in init, give it a litte more time, this should never happen */
{
status = EVE_memRead8(REG_FLASH_STATUS);
DELAY_MS(1);
timeout++;
if(timeout > 100) /* 100ms and still in init, lets call quits now and exit with an error */
{
return 0;
}
}
if(status == 1) /* FLASH_STATUS_DETACHED - no flash was found during init, no flash present or the detection failed, but have hope and let the BT81x have annother try */
{
EVE_cmd_dl(CMD_FLASHATTACH);
EVE_cmd_execute();
status = EVE_memRead8(REG_FLASH_STATUS);
if(status != 2) /* still not in FLASH_STATUS_BASIC, time to give up */
{
return 0;
}
}
if(status == 2) /* FLASH_STATUS_BASIC - flash detected and ready for action, lets move it up to FLASH_STATUS_FULL */
{
uint32_t result;
result = EVE_cmd_flashfast();
if(result == 0) /* cmd_flashfast was successful */
{
return 1;
}
else /* room for improvement, cmd_flashfast provided an error code but there is no way to return it without returning a value that is FALSE all the same */
{
return 0;
}
}
if(status == 3) /* FLASH_STATUS_FULL - we are already there, why has this function been called? */
{
return 1;
}
return 0;
}
#endif
/* commands to draw graphics objects: */
#if defined (BT81X_ENABLE)
/* as the name implies, "num_args" is the number of arguments passed to this function as variadic arguments */
void EVE_cmd_text_var(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text, uint8_t num_args, ...)
{
va_list arguments;
uint8_t counter;
uint32_t data;
va_start(arguments, num_args);
BUFFER_SPI_DWORD(CMD_TEXT)
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(options & EVE_OPT_FORMAT)
{
for(counter = 0; counter < num_args; counter++)
{
data = (uint32_t) va_arg(arguments, int);
BUFFER_SPI_DWORD(data)
EVE_inc_cmdoffset(4);
}
}
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
va_end(arguments);
}
#endif
void EVE_cmd_text(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text)
{
EVE_start_cmd(CMD_TEXT);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
EVE_inc_cmdoffset(8);
EVE_write_string(text);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#if defined (BT81X_ENABLE)
/* as the name implies, "num_args" is the number of arguments passed to this function as variadic arguments */
void EVE_cmd_button_var(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text, uint8_t num_args, ...)
{
va_list arguments;
uint8_t counter;
uint32_t data;
va_start(arguments, num_args);
EVE_start_cmd(CMD_BUTTON);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(options & EVE_OPT_FORMAT)
{
for(counter = 0; counter < num_args; counter++)
{
data = (uint32_t) va_arg(arguments, int);
BUFFER_SPI_DWORD(data)
EVE_inc_cmdoffset(4);
}
}
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
va_end(arguments);
}
#endif
void EVE_cmd_button(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text)
{
EVE_start_cmd(CMD_BUTTON);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* draw a clock */
void EVE_cmd_clock(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t hours, uint16_t minutes, uint16_t seconds, uint16_t millisecs)
{
EVE_start_cmd(CMD_CLOCK);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(r0)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(hours)
BUFFER_SPI_WORD(minutes)
BUFFER_SPI_WORD(seconds)
BUFFER_SPI_WORD(millisecs)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_color_rgb(uint8_t red, uint8_t green, uint8_t blue)
{
BUFFER_SPI_BYTE(green) /* low-byte */
BUFFER_SPI_BYTE(blue)
BUFFER_SPI_BYTE(red)
BUFFER_SPI_BYTE(0x04) /* encoding for COLOR_RGB */
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_bgcolor(uint32_t color)
{
EVE_start_cmd(CMD_BGCOLOR);
BUFFER_SPI_DWORD(color & 0x00ffffff)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_fgcolor(uint32_t color)
{
EVE_start_cmd(CMD_FGCOLOR);
BUFFER_SPI_DWORD(color & 0x00ffffff)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_gradcolor(uint32_t color)
{
EVE_start_cmd(CMD_GRADCOLOR);
BUFFER_SPI_DWORD(color & 0x00ffffff)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_gauge(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range)
{
EVE_start_cmd(CMD_GAUGE);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(r0)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(major)
BUFFER_SPI_WORD(minor)
BUFFER_SPI_WORD(val)
BUFFER_SPI_WORD(range)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1)
{
EVE_start_cmd(CMD_GRADIENT);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_DWORD(rgb0 & 0x00ffffff)
BUFFER_SPI_WORD(x1)
BUFFER_SPI_WORD(y1)
BUFFER_SPI_DWORD(rgb1 & 0x00ffffff)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_keys(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text)
{
EVE_start_cmd(CMD_KEYS);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_progress(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t range)
{
EVE_start_cmd(CMD_PROGRESS);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(val)
BUFFER_SPI_WORD(range)
BUFFER_SPI_WORD(0) /* dummy word for 4-byte alignment */
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_scrollbar(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t size, uint16_t range)
{
EVE_start_cmd(CMD_SCROLLBAR);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(val)
BUFFER_SPI_WORD(size)
BUFFER_SPI_WORD(range)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_slider(int16_t x1, int16_t y1, int16_t w1, int16_t h1, uint16_t options, uint16_t val, uint16_t range)
{
EVE_start_cmd(CMD_SLIDER);
BUFFER_SPI_WORD(x1)
BUFFER_SPI_WORD(y1)
BUFFER_SPI_WORD(w1)
BUFFER_SPI_WORD(h1)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(val)
BUFFER_SPI_WORD(range)
BUFFER_SPI_WORD(0) /* dummy word for 4-byte alignment */
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_dial(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t val)
{
EVE_start_cmd(CMD_DIAL);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(r0)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(val)
BUFFER_SPI_WORD(0) /* dummy word for 4-byte alignment */
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#if defined (BT81X_ENABLE)
/* as the name implies, "num_args" is the number of arguments passed to this function as variadic arguments */
void EVE_cmd_toggle_var(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text, uint8_t num_args, ...)
{
va_list arguments;
uint8_t counter;
uint32_t data;
va_start(arguments, num_args);
EVE_start_cmd(CMD_TOGGLE);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(state)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(options & EVE_OPT_FORMAT)
{
for(counter = 0; counter < num_args; counter++)
{
data = (uint32_t) va_arg(arguments, int);
BUFFER_SPI_DWORD(data)
EVE_inc_cmdoffset(4);
}
}
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
va_end(arguments);
}
#endif
void EVE_cmd_toggle(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text)
{
EVE_start_cmd(CMD_TOGGLE);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
BUFFER_SPI_WORD(state)
EVE_inc_cmdoffset(12);
EVE_write_string(text);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#if defined (FT81X_ENABLE)
void EVE_cmd_setbase(uint32_t base)
{
EVE_start_cmd(CMD_SETBASE);
BUFFER_SPI_DWORD(base);
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
#endif // FT81X_FULL
#if defined (FT81X_ENABLE)
void EVE_cmd_setbitmap(uint32_t addr, uint16_t fmt, uint16_t width, uint16_t height)
{
EVE_start_cmd(CMD_SETBITMAP);
BUFFER_SPI_DWORD(addr)
BUFFER_SPI_WORD(fmt)
BUFFER_SPI_WORD(width)
BUFFER_SPI_WORD(height)
BUFFER_SPI_WORD(0)
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
#if FT81X_FULL
void EVE_cmd_number(int16_t x0, int16_t y0, int16_t font, uint16_t options, int32_t number)
{
EVE_start_cmd(CMD_NUMBER);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(font)
BUFFER_SPI_WORD(options)
BUFFER_SPI_DWORD(number)
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_append(uint32_t ptr, uint32_t num)
{
EVE_start_cmd(CMD_APPEND);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* commands for setting the bitmap transform matrix: */
/*
The description in the programmers guide is strange for this function.
While it is named *get*matrix, parameters 'a' to 'f' are supplied to the function
and described as "output parameter"
Best guess is that this one allows to setup the matrix coefficients manually.
If this assumption is correct it rather should be named cmd_setupmatrix().
*/
void EVE_cmd_getmatrix(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f)
{
EVE_start_cmd(CMD_GETMATRIX);
BUFFER_SPI_DWORD(a)
BUFFER_SPI_DWORD(b)
BUFFER_SPI_DWORD(c)
BUFFER_SPI_DWORD(d)
BUFFER_SPI_DWORD(e)
BUFFER_SPI_DWORD(f)
EVE_inc_cmdoffset(24);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_translate(int32_t tx, int32_t ty)
{
EVE_start_cmd(CMD_TRANSLATE);
BUFFER_SPI_DWORD(tx)
BUFFER_SPI_DWORD(ty)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_scale(int32_t sx, int32_t sy)
{
EVE_start_cmd(CMD_SCALE);
BUFFER_SPI_DWORD(sx)
BUFFER_SPI_DWORD(sy)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_rotate(int32_t ang)
{
EVE_start_cmd(CMD_ROTATE);
BUFFER_SPI_DWORD(ang)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#if defined (BT81X_ENABLE)
void EVE_cmd_rotatearound(int32_t x0, int32_t y0, int32_t angle, int32_t scale)
{
EVE_start_cmd(CMD_ROTATEAROUND);
BUFFER_SPI_DWORD(x0)
BUFFER_SPI_DWORD(y0)
BUFFER_SPI_DWORD(ang)
BUFFER_SPI_DWORD(scale)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
/* other commands: */
void EVE_cmd_calibrate(void)
{
EVE_start_cmd(CMD_CALIBRATE);
BUFFER_SPI_DWORD(0)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#if defined (FT81X_ENABLE)
void EVE_cmd_romfont(uint32_t font, uint32_t romslot)
{
EVE_start_cmd(CMD_ROMFONT);
BUFFER_SPI_DWORD(font & 0x0000ffff)
BUFFER_SPI_DWORD(romslot & 0x0000ffff)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
#if defined (FT81X_ENABLE)
void EVE_cmd_setscratch(uint32_t handle)
{
EVE_start_cmd(CMD_SETSCRATCH);
BUFFER_SPI_DWORD(handle)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
void EVE_cmd_sketch(int16_t x0, int16_t y0, uint16_t w0, uint16_t h0, uint32_t ptr, uint16_t format)
{
EVE_start_cmd(CMD_SKETCH);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(w0)
BUFFER_SPI_WORD(h0)
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_WORD(format)
BUFFER_SPI_WORD(0) /* dummy word for 4-byte alignment */
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_spinner(int16_t x0, int16_t y0, uint16_t style, uint16_t scale)
{
EVE_start_cmd(CMD_SPINNER);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_WORD(style)
BUFFER_SPI_WORD(scale)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* various commands new for EVE3 */
#if defined (BT81X_ENABLE)
void EVE_cmd_animstart(int32_t ch, uint32_t aoptr, uint32_t loop)
{
EVE_start_cmd(CMD_ANIMSTART);
BUFFER_SPI_DWORD(ch)
BUFFER_SPI_DWORD(aoptr)
BUFFER_SPI_DWORD(loop)
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_animstop(int32_t ch)
{
EVE_start_cmd(CMD_ANIMSTOP);
BUFFER_SPI_DWORD(ch)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_animxy(int32_t ch, int16_t x0, int16_t y0)
{
EVE_start_cmd(CMD_ANIMXY);
BUFFER_SPI_DWORD(ch)
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_animdraw(int32_t ch)
{
EVE_start_cmd(CMD_ANIMDRAW);
BUFFER_SPI_DWORD(ch)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_animframe(int16_t x0, int16_t y0, uint32_t aoptr, uint32_t frame)
{
EVE_start_cmd(CMD_ANIMFRAME);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_DWORD(aoptr)
BUFFER_SPI_DWORD(frame)
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_gradienta(int16_t x0, int16_t y0, uint32_t argb0, int16_t x1, int16_t y1, uint32_t argb1)
{
EVE_start_cmd(CMD_GRADIENTA);
BUFFER_SPI_WORD(x0)
BUFFER_SPI_WORD(y0)
BUFFER_SPI_DWORD(argb0)
BUFFER_SPI_WORD(x1)
BUFFER_SPI_WORD(y1)
BUFFER_SPI_DWORD(argb1)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_fillwidth(uint32_t s)
{
EVE_start_cmd(CMD_FILLWIDTH);
BUFFER_SPI_DWORD(s)
EVE_inc_cmdoffset(4);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
void EVE_cmd_appendf(uint32_t ptr, uint32_t num)
{
EVE_start_cmd(CMD_APPENDF);
BUFFER_SPI_DWORD(ptr)
BUFFER_SPI_DWORD(num)
EVE_inc_cmdoffset(8);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
#endif
/* warning! meta-command! this is a sequence of display-list commands to simplify use at the price of some overhead */
void EVE_cmd_point(int16_t x0, int16_t y0, uint16_t size)
{
EVE_start_cmd((DL_BEGIN | EVE_POINTS));
uint32_t calc = POINT_SIZE(size*16);
BUFFER_SPI_DWORD(calc)
calc = VERTEX2F(x0 * 16, y0 * 16);
BUFFER_SPI_DWORD(calc)
BUFFER_SPI_DWORD(DL_END)
EVE_inc_cmdoffset(12);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* warning! meta-command! this is a sequence of display-list commands to simplify use at the price of some overhead */
void EVE_cmd_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t width)
{
EVE_start_cmd((DL_BEGIN | EVE_LINES));
uint32_t calc = LINE_WIDTH(width * 16);
BUFFER_SPI_DWORD(calc)
calc = VERTEX2F(x0 * 16, y0 * 16);
BUFFER_SPI_DWORD(calc)
calc = VERTEX2F(x1 * 16, y1 * 16);
BUFFER_SPI_DWORD(calc)
BUFFER_SPI_DWORD(DL_END)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* warning! meta-command! this is a sequence of display-list commands to simplify use at the price of some overhead */
void EVE_cmd_rect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t corner)
{
EVE_start_cmd((DL_BEGIN | EVE_RECTS));
uint32_t calc = LINE_WIDTH(corner * 16);
BUFFER_SPI_DWORD(calc)
calc = VERTEX2F(x0 * 16, y0 * 16);
BUFFER_SPI_DWORD(calc)
calc = VERTEX2F(x1 * 16, y1 * 16);
BUFFER_SPI_DWORD(calc)
BUFFER_SPI_DWORD(DL_END)
EVE_inc_cmdoffset(16);
if(!cmd_burst)
{
SEND_SPI_BUFFER()
}
}
/* this is meant to be called outside display-list building */
/* this function displays an interactive calibration screen, calculates the calibration values and */
/* writes the new values to the touch matrix registers of EVE */
/* unlike the built-in cmd_calibrate() of EVE this also works with displays that are cut down from larger ones like EVE2-38A / EVE2-38G */
/* the height is needed as parameter as EVE_VSIZE for the EVE2-38 is 272 but the visible size is only 116 */
/* so the call would be EVE_calibrate_manual(116); for the EVE2-38A and EVE2-38G while for most other displays */
/* using EVE_calibrate_manual(EVE_VSIZE) would work - but for normal displays the built-in cmd_calibrate would work as expected anyways */
/* this code was taken from the MatrixOrbital EVE2-Library on Github, adapted and modified */
void EVE_calibrate_manual(uint16_t height)
{
uint32_t displayX[3], displayY[3];
uint32_t touchX[3], touchY[3];
uint32_t touchValue;
int32_t tmp, k;
int32_t TransMatrix[6];
uint8_t count = 0;
char num[2];
uint8_t touch_lock = 1;
/* these values determine where your calibration points will be drawn on your display */
displayX[0] = (EVE_HSIZE * 0.15);
displayY[0] = (height * 0.15);
displayX[1] = (EVE_HSIZE * 0.85);
displayY[1] = (height / 2);
displayX[2] = (EVE_HSIZE / 2);
displayY[2] = (height * 0.85);
while (count < 3)
{
// immediate transfer mode
EVE_cmd_dl(CMD_DLSTART);
EVE_cmd_dl(DL_CLEAR_RGB | 0x000000);
EVE_cmd_dl(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG);
/* draw Calibration Point on screen */
EVE_cmd_dl(DL_COLOR_RGB | 0x0000ff);
EVE_cmd_dl(POINT_SIZE(20*16));
EVE_cmd_dl((DL_BEGIN | EVE_POINTS));
EVE_cmd_dl(VERTEX2F((uint32_t)(displayX[count]) * 16, (uint32_t)((displayY[count])) * 16));
EVE_cmd_dl(DL_END);
EVE_cmd_dl(DL_COLOR_RGB | 0xffffff);
EVE_cmd_text((EVE_HSIZE/2), 50, 27, EVE_OPT_CENTER, "Please tap on the dot.");
num[0] = count + 0x31; num[1] = 0; /* null terminated string of one character */
EVE_cmd_text(displayX[count], displayY[count], 27, EVE_OPT_CENTER, num);
EVE_cmd_dl(DL_DISPLAY);
EVE_cmd_dl(CMD_SWAP);
EVE_cmd_execute();
while(1)
{
touchValue = EVE_memRead32(REG_TOUCH_DIRECT_XY); /* read for any new touch tag inputs */
if(touch_lock)
{
if(touchValue & 0x80000000) /* check if we have no touch */
{
touch_lock = 0;
}
}
else
{
if (!(touchValue & 0x80000000)) /* check if a touch is detected */
{
touchX[count] = (touchValue>>16) & 0x03FF; /* raw Touchscreen Y coordinate */
touchY[count] = touchValue & 0x03FF; /* raw Touchscreen Y coordinate */
touch_lock = 1;
count++;
break; /* leave while(1) */
}
}
}
}
k = ((touchX[0] - touchX[2])*(touchY[1] - touchY[2])) - ((touchX[1] - touchX[2])*(touchY[0] - touchY[2]));
tmp = (((displayX[0] - displayX[2]) * (touchY[1] - touchY[2])) - ((displayX[1] - displayX[2])*(touchY[0] - touchY[2])));
TransMatrix[0] = ((int64_t)tmp << 16) / k;
tmp = (((touchX[0] - touchX[2]) * (displayX[1] - displayX[2])) - ((displayX[0] - displayX[2])*(touchX[1] - touchX[2])));
TransMatrix[1] = ((int64_t)tmp << 16) / k;
tmp = ((touchY[0] * (((touchX[2] * displayX[1]) - (touchX[1] * displayX[2])))) + (touchY[1] * (((touchX[0] * displayX[2]) - (touchX[2] * displayX[0])))) + (touchY[2] * (((touchX[1] * displayX[0]) - (touchX[0] * displayX[1])))));
TransMatrix[2] = ((int64_t)tmp << 16) / k;
tmp = (((displayY[0] - displayY[2]) * (touchY[1] - touchY[2])) - ((displayY[1] - displayY[2])*(touchY[0] - touchY[2])));
TransMatrix[3] = ((int64_t)tmp << 16) / k;
tmp = (((touchX[0] - touchX[2]) * (displayY[1] - displayY[2])) - ((displayY[0] - displayY[2])*(touchX[1] - touchX[2])));
TransMatrix[4] = ((int64_t)tmp << 16) / k;
tmp = ((touchY[0] * (((touchX[2] * displayY[1]) - (touchX[1] * displayY[2])))) + (touchY[1] * (((touchX[0] * displayY[2]) - (touchX[2] * displayY[0])))) + (touchY[2] * (((touchX[1] * displayY[0]) - (touchX[0] * displayY[1])))));
TransMatrix[5] = ((int64_t)tmp << 16) / k;
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, TransMatrix[0]);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, TransMatrix[1]);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, TransMatrix[2]);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, TransMatrix[3]);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, TransMatrix[4]);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, TransMatrix[5]);
}
#endif // FT81X_FULL
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/EVE_commands.c | C | apache-2.0 | 63,596 |
/*
@file EVE_commands.h
@brief contains FT8xx / BT8xx function prototypes
@version 4.1 LvGL edition
@date 2020-04-13
@author Rudolph Riedel, David Jade
@section LICENSE
MIT License
Copyright (c) 2016-2020 Rudolph Riedel and David Jade
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@section History
4.1 LvGL edition
- This version is a heavily modified version of the MIT licensed FT81x code from https://github.com/RudolphRiedel/FT800-FT813
This version is based on a fork by David Jade that added native SPI DMA support and stripped out non-ESP32 code.
It has also been trimmed down to suit LvGL's needs. Extra features can be enabled by defining FT81X_FULL
*/
#include "EVE.h"
#ifndef EVE_COMMANDS_H_
#define EVE_COMMANDS_H_
#define BLOCK_TRANSFER_SIZE 3840 // block transfer size when write data to CMD buffer
void DELAY_MS(uint16_t ms);
#if EVE_USE_PDN
void EVE_pdn_set(void);
void EVE_pdn_clear(void);
#endif
void spi_acquire();
void spi_release();
void EVE_cmdWrite(uint8_t command, uint8_t parameter);
uint8_t EVE_memRead8(uint32_t ftAddress);
uint16_t EVE_memRead16(uint32_t ftAddress);
uint32_t EVE_memRead32(uint32_t ftAddress);
void EVE_memWrite8(uint32_t ftAddress, uint8_t ftData8);
void EVE_memWrite16(uint32_t ftAddress, uint16_t ftData16);
void EVE_memWrite32(uint32_t ftAddress, uint32_t ftData32);
void EVE_memWrite_buffer(uint32_t ftAddress, const uint8_t *data, uint32_t len, bool LvGL_Flush);
uint8_t EVE_busy(void);
void EVE_get_cmdoffset(void);
/* commands to operate on memory: */
void EVE_cmd_memzero(uint32_t ptr, uint32_t num);
void EVE_cmd_memset(uint32_t ptr, uint8_t value, uint32_t num);
void EVE_cmd_memwrite(uint32_t dest, uint32_t num, const uint8_t *data);
void EVE_cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num);
#if FT81X_FULL
/* commands for loading image data into FT8xx memory: */
void EVE_cmd_inflate(uint32_t ptr, const uint8_t *data, uint16_t len);
void EVE_cmd_loadimage(uint32_t ptr, uint32_t options, const uint8_t *data, uint16_t len);
#if defined (FT81X_ENABLE)
void EVE_cmd_mediafifo(uint32_t ptr, uint32_t size);
#endif
#endif // FT81X_FULL
void EVE_cmd_start(void);
void EVE_cmd_execute(void);
void EVE_start_cmd_burst(void);
void EVE_end_cmd_burst(void);
void EVE_cmd_dl(uint32_t command);
#if FT81X_FULL
/* EVE3 commands */
#if defined (BT81X_ENABLE)
void EVE_cmd_flashwrite(uint32_t ptr, uint32_t num, const uint8_t *data);
void EVE_cmd_flashread(uint32_t dest, uint32_t src, uint32_t num);
void EVE_cmd_flashupdate(uint32_t dest, uint32_t src, uint32_t num);
void EVE_cmd_flasherase(void);
void EVE_cmd_flashattach(void);
void EVE_cmd_flashdetach(void);
void EVE_cmd_flashspidesel(void);
uint32_t EVE_cmd_flashfast(void);
void EVE_cmd_flashspitx(uint32_t num, const uint8_t *data);
void EVE_cmd_flashspirx(uint32_t dest, uint32_t num);
void EVE_cmd_flashsource(uint32_t ptr);
void EVE_cmd_inflate2(uint32_t ptr, uint32_t options, const uint8_t *data, uint16_t len);
void EVE_cmd_rotatearound(int32_t x0, int32_t y0, int32_t angle, int32_t scale);
void EVE_cmd_animstart(int32_t ch, uint32_t aoptr, uint32_t loop);
void EVE_cmd_animstop(int32_t ch);
void EVE_cmd_animxy(int32_t ch, int16_t x0, int16_t y0);
void EVE_cmd_animdraw(int32_t ch);
void EVE_cmd_animframe(int16_t x0, int16_t y0, uint32_t aoptr, uint32_t frame);
void EVE_cmd_gradienta(int16_t x0, int16_t y0, uint32_t argb0, int16_t x1, int16_t y1, uint32_t argb1);
void EVE_cmd_fillwidth(uint32_t s);
void EVE_cmd_appendf(uint32_t ptr, uint32_t num);
uint8_t EVE_init_flash(void);
#endif
/* commands to draw graphics objects: */
#if defined (BT81X_ENABLE)
void EVE_cmd_text_var(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text, uint8_t numargs, ...);
void EVE_cmd_button_var(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text, uint8_t num_args, ...);
void EVE_cmd_toggle_var(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text, uint8_t num_args, ...);
#endif
void EVE_cmd_text(int16_t x0, int16_t y0, int16_t font, uint16_t options, const char* text);
void EVE_cmd_button(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text);
void EVE_cmd_clock(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t hours, uint16_t minutes, uint16_t seconds, uint16_t millisecs);
void EVE_color_rgb(uint8_t red, uint8_t green, uint8_t blue);
void EVE_cmd_bgcolor(uint32_t color);
void EVE_cmd_fgcolor(uint32_t color);
void EVE_cmd_gradcolor(uint32_t color);
void EVE_cmd_gauge(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range);
void EVE_cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1);
void EVE_cmd_keys(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t font, uint16_t options, const char* text);
void EVE_cmd_progress(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t range);
void EVE_cmd_scrollbar(int16_t x0, int16_t y0, int16_t w0, int16_t h0, uint16_t options, uint16_t val, uint16_t size, uint16_t range);
void EVE_cmd_slider(int16_t x1, int16_t y1, int16_t w1, int16_t h1, uint16_t options, uint16_t val, uint16_t range);
void EVE_cmd_dial(int16_t x0, int16_t y0, int16_t r0, uint16_t options, uint16_t val);
void EVE_cmd_toggle(int16_t x0, int16_t y0, int16_t w0, int16_t font, uint16_t options, uint16_t state, const char* text);
void EVE_cmd_number(int16_t x0, int16_t y0, int16_t font, uint16_t options, int32_t number);
#endif // FT81X_FULL
#if defined (FT81X_ENABLE)
#if FT81X_FULL
void EVE_cmd_setbase(uint32_t base);
#endif
void EVE_cmd_setbitmap(uint32_t addr, uint16_t fmt, uint16_t width, uint16_t height);
#endif
#if FT81X_FULL
void EVE_cmd_append(uint32_t ptr, uint32_t num);
/* commands for setting the bitmap transform matrix: */
void EVE_cmd_getmatrix(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f);
void EVE_cmd_translate(int32_t tx, int32_t ty);
void EVE_cmd_scale(int32_t sx, int32_t sy);
void EVE_cmd_rotate(int32_t ang);
/* other commands: */
void EVE_cmd_calibrate(void);
void EVE_cmd_interrupt(uint32_t ms);
void EVE_cmd_setfont(uint32_t font, uint32_t ptr);
#if defined (FT81X_ENABLE)
void EVE_cmd_romfont(uint32_t font, uint32_t romslot);
void EVE_cmd_setfont2(uint32_t font, uint32_t ptr, uint32_t firstchar);
void EVE_cmd_setrotate(uint32_t r);
void EVE_cmd_setscratch(uint32_t handle);
#endif
void EVE_cmd_sketch(int16_t x0, int16_t y0, uint16_t w0, uint16_t h0, uint32_t ptr, uint16_t format);
void EVE_cmd_snapshot(uint32_t ptr);
#if defined (FT81X_ENABLE)
void EVE_cmd_snapshot2(uint32_t fmt, uint32_t ptr, int16_t x0, int16_t y0, int16_t w0, int16_t h0);
#endif
void EVE_cmd_spinner(int16_t x0, int16_t y0, uint16_t style, uint16_t scale);
void EVE_cmd_track(int16_t x0, int16_t y0, int16_t w0, int16_t h0, int16_t tag);
/* commands that return values by writing to the command-fifo */
uint32_t EVE_cmd_memcrc(uint32_t ptr, uint32_t num);
uint32_t EVE_cmd_getptr(void);
uint32_t EVE_cmd_regread(uint32_t ptr);
void EVE_LIB_GetProps(uint32_t *pointer, uint32_t *width, uint32_t *height);
/* meta-commands, sequences of several display-list entries condensed into simpler to use functions at the price of some overhead */
void EVE_cmd_point(int16_t x0, int16_t y0, uint16_t size);
void EVE_cmd_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t w0);
void EVE_cmd_rect(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t corner);
void EVE_calibrate_manual(uint16_t height);
#endif // FT81X_FULL
/* startup FT8xx: */
uint8_t EVE_init(void);
#endif /* EVE_COMMANDS_H_ */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/EVE_commands.h | C | apache-2.0 | 8,716 |
/*
@file EVE_config.h
@brief configuration information for some TFTs
@version 4.0
@date 2020-02-16
@author Rudolph Riedel, David Jade
@section LICENSE
MIT License
Copyright (c) 2016-2020 Rudolph Riedel amd David Jade
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@section History
4.1 LvGL edition
- This version is a heavily modified version of the MIT licensed FT81x code from https://github.com/RudolphRiedel/FT800-FT813
This version is based on a fork by David Jade that added native SPI DMA support and stripped out non-ESP32 code.
It has also been trimmed down to suit LvGL's needs. Extra features can be enabled by defining FT81X_FULL
*/
#ifndef EVE_CONFIG_H_
#define EVE_CONFIG_H_
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_spi_conf.h"
#include "FT81x.h"
#define EVE_CLK DISP_SPI_CLK // orange
#define EVE_MISO DISP_SPI_MISO // yellow
#define EVE_MOSI DISP_SPI_MOSI // green
#define EVE_CS DISP_SPI_CS // blue
#define EVE_PDN CONFIG_LV_DISP_PIN_RST // grey
#define EVE_USE_PDN CONFIG_LV_DISP_USE_RST
#define SPI_TRANSER_SIZE (DISP_BUF_SIZE * (LV_COLOR_DEPTH / 8))
#define BYTES_PER_PIXEL (LV_COLOR_DEPTH / 8) // bytes per pixel for (16 for RGB565)
#define BYTES_PER_LINE (EVE_HSIZE * BYTES_PER_PIXEL)
#define SCREEN_BUFFER_SIZE (EVE_HSIZE * EVE_VSIZE * BYTES_PER_PIXEL)
#define SPI_BUFFER_SIZE 256 // size in bytes (multiples of 4) of SPI transaction buffer for streaming commands
/* select the settings for the TFT attached */
#if 0
#define EVE_VM800B35A
#define EVE_VM800B43A
#define EVE_VM800B50A
#define EVE_VM810C
#define EVE_ME812A
#define EVE_ME813A
#define EVE_FT810CB_HY50HD
#define EVE_FT811CB_HY50HD
#define EVE_ET07
#define EVE_RVT28
#define EVE_RVT35
#define EVE_RVT43
#define EVE_RVT50
#define EVE_RVT70
#define EVE_RiTFT43
#define EVE_RiTFT50
#define EVE_RiTFT70
#define EVE_EVE2_29
#define EVE_EVE2_35
#define EVE_EVE2_35G
#define EVE_EVE2_38
#define EVE_EVE2_38G
#define EVE_EVE2_43
#define EVE_EVE2_43G
#define EVE_EVE2_50
#define EVE_EVE2_50G
#define EVE_EVE2_70
#define EVE_EVE2_70G
#define EVE_EVE3_35
#define EVE_EVE3_35G
#define EVE_EVE3_43
#define EVE_EVE3_43G
#define EVE_EVE3_50
#define EVE_EVE3_50G
#define EVE_EVE3_70
#define EVE_EVE3_70G
#define EVE_NHD_35
#define EVE_NHD_43
#define EVE_NHD_50
#define EVE_NHD_70
#define EVE_ADAM101
#define EVE_CFAF240400C1_030SC
#define EVE_CFAF320240F_035T
#define EVE_CFAF480128A0_039TC
#define EVE_CFAF800480E0_050SC
#define EVE_PAF90
#define EVE_SUNFLOWER
#define EVE_CONNECTEVE
#endif
#if defined(CONFIG_LV_FT81X_CONFIG_EVE_VM800B35A)
#define EVE_VM800B35A
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_VM800B43A)
#define EVE_VM800B43A
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_VM800B50A)
#define EVE_VM800B50A
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_VM810C)
#define EVE_VM810C
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_ME812A)
#define EVE_ME812A
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_ME813A)
#define EVE_ME813A
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_FT810CB_HY50HD)
#define EVE_FT810CB_HY50HD
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_FT811CB_HY50HD)
#define EVE_FT811CB_HY50HD
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_ET07)
#define EVE_ET07
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RVT28)
#define EVE_RVT28
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RVT35)
#define EVE_RVT35
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RVT43)
#define EVE_RVT43
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RVT50)
#define EVE_RVT50
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RVT70)
#define EVE_RVT70
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RiTFT43)
#define EVE_RiTFT43
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RiTFT50)
#define EVE_RiTFT50
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_RiTFT70)
#define EVE_RiTFT70
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_29)
#define EVE_EVE2_29
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_35)
#define EVE_EVE2_35
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_35G)
#define EVE_EVE2_35G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_38)
#define EVE_EVE2_38
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_38G)
#define EVE_EVE2_38G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_43)
#define EVE_EVE2_43
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_43G)
#define EVE_EVE2_43G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_50)
#define EVE_EVE2_50
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_50G)
#define EVE_EVE2_50G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_70)
#define EVE_EVE2_70
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE2_70G)
#define EVE_EVE2_70G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_35)
#define EVE_EVE3_35
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_35G)
#define EVE_EVE3_35G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_43)
#define EVE_EVE3_43
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_43G)
#define EVE_EVE3_43G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_50)
#define EVE_EVE3_50
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_50G)
#define EVE_EVE3_50G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_70)
#define EVE_EVE3_70
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_EVE3_70G)
#define EVE_EVE3_70G
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_NHD_35)
#define EVE_NHD_35
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_NHD_43)
#define EVE_NHD_43
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_NHD_50)
#define EVE_NHD_50
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_NHD_70)
#define EVE_NHD_70
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_ADAM101)
#define EVE_ADAM101
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_CFAF240400C1_030SC)
#define EVE_CFAF240400C1_030SC
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_CFAF320240F_035T)
#define EVE_CFAF320240F_035T
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_CFAF480128A0_039TC)
#define EVE_CFAF480128A0_039TC
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_CFAF800480E0_050SC)
#define EVE_CFAF800480E0_050SC
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_PAF90)
#define EVE_PAF90
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_SUNFLOWER)
#define EVE_SUNFLOWER
#elif defined(CONFIG_LV_FT81X_CONFIG_EVE_CONNECTEVE)
#define EVE_CONNECTEVE
#endif
/* display timing parameters below */
/* untested */
#if defined (EVE_EVE3_35)
#define EVE_EVE2_35
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_EVE3_35G)
#define EVE_EVE2_35G
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_EVE3_43)
#define EVE_EVE2_43
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
#if defined (EVE_EVE3_43G)
#define EVE_EVE2_43G
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_EVE3_50)
#define EVE_EVE2_50
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
#if defined (EVE_EVE3_50G)
#define EVE_EVE2_50G
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_EVE3_70)
#define EVE_EVE2_70
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_EVE3_70G)
#define EVE_EVE2_70G
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
#if defined (EVE_RiTFT43)
#define EVE_RVT43
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_RiTFT50)
#define EVE_RVT70
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* untested */
#if defined (EVE_RiTFT70)
#define EVE_RVT70
#define EVE_HAS_CRYSTAL
#define BT81X_ENABLE
#endif
/* some test setup */
#if defined (EVE_800x480x)
#define EVE_HSIZE (800L) /* Thd Length of visible part of line (in PCLKs) - display width */
#define EVE_VSIZE (480L) /* Tvd Number of visible lines (in lines) - display height */
#define EVE_VSYNC0 (0L) /* Tvf Vertical Front Porch */
#define EVE_VSYNC1 (10L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */
#define EVE_VOFFSET (35L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */
#define EVE_VCYCLE (516L) /* Tv Total number of lines (visible and non-visible) (in lines) */
#define EVE_HSYNC0 (0L) /* (40L) // Thf Horizontal Front Porch */
#define EVE_HSYNC1 (88L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */
#define EVE_HOFFSET (169L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */
#define EVE_HCYCLE (969L) /* Th Total length of line (visible and non-visible) (in PCLKs) */
#define EVE_PCLKPOL (1L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */
#define EVE_SWIZZLE (0L) /* Defines the arrangement of the RGB pins of the FT800 */
#define EVE_PCLK (2L) /* 60MHz / REG_PCLK = PCLK frequency 30 MHz */
#define EVE_CSPREAD (1L) /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
#define EVE_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* VM800B35A: FT800 320x240 3.5" FTDI FT800 */
#if defined (EVE_VM800B35A)
#define EVE_HSIZE (320L) /* Thd Length of visible part of line (in PCLKs) - display width */
#define EVE_VSIZE (240L) /* Tvd Number of visible lines (in lines) - display height */
#define EVE_VSYNC0 (0L) /* Tvf Vertical Front Porch */
#define EVE_VSYNC1 (2L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */
#define EVE_VOFFSET (13L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */
#define EVE_VCYCLE (263L) /* Tv Total number of lines (visible and non-visible) (in lines) */
#define EVE_HSYNC0 (0L) /* Thf Horizontal Front Porch */
#define EVE_HSYNC1 (10L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */
#define EVE_HOFFSET (70L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */
#define EVE_HCYCLE (408L) /* Th Total length of line (visible and non-visible) (in PCLKs) */
#define EVE_PCLKPOL (0L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */
#define EVE_SWIZZLE (2L) /* Defines the arrangement of the RGB pins of the FT800 */
#define EVE_PCLK (8L) /* 48MHz / REG_PCLK = PCLK frequency */
#define EVE_CSPREAD (1L) /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
#define EVE_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */
#define EVE_HAS_CRYSTAL /* use external crystal or internal oscillator? */
#endif
/* FTDI/BRT EVE modules VM800B43A and VM800B50A FT800 480x272 4.3" and 5.0" */
#if defined (EVE_VM800B43A) || defined (EVE_VM800B50A)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#endif
/* untested */
/* FTDI/BRT EVE2 modules VM810C50A-D, ME812A-WH50R and ME813A-WH50C, 800x480 5.0" */
#if defined (EVE_VM810C) || defined (EVE_ME812A) || defined (EVE_ME813A)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* FT810CB-HY50HD: FT810 800x480 5.0" HAOYU */
#if defined (EVE_FT810CB_HY50HD)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (13L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (20L)
#define EVE_HOFFSET (64L)
#define EVE_HCYCLE (952L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (2000L) /* touch-sensitivity */
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* FT811CB-HY50HD: FT811 800x480 5.0" HAOYU */
#if defined (EVE_FT811CB_HY50HD)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (13L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (20L)
#define EVE_HOFFSET (64L)
#define EVE_HCYCLE (952L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* untested */
/* G-ET0700G0DM6 800x480 7.0" Glyn */
#if defined (EVE_ET07)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (35L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (128L)
#define EVE_HOFFSET (203L)
#define EVE_HCYCLE (1056L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* untested */
/* RVT28 240x320 2.8" Riverdi, various options, FT800/FT801 */
#if defined (EVE_RVT28)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (2L)
#define EVE_VCYCLE (326L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (20L)
#define EVE_HCYCLE (270L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (4L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#endif
/* untested */
/* RVT3.5 320x240 3.5" Riverdi, various options, FT800/FT801 */
#if defined (EVE_RVT35)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (13L)
#define EVE_VCYCLE (263L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (2L)
#define EVE_PCLK (6L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#endif
/* untested */
/* RVT43 / RVT4.3 480x272 4.3" Riverdi, various options, FT800/FT801 */
#if defined (EVE_RVT43)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#endif
/* untested */
/* RVT50xQFxxxxx 800x480 5.0" Riverdi, various options, FT812/FT813 */
#if defined (EVE_RVT50)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* RVT70xQFxxxxx 800x480 7.0" Riverdi, various options, FT812/FT813, tested with RVT70UQFNWC0x */
#if defined (EVE_RVT70)
#define EVE_HSIZE (800L) /* Thd Length of visible part of line (in PCLKs) - display width */
#define EVE_VSIZE (480L) /* Tvd Number of visible lines (in lines) - display height */
#define EVE_VSYNC0 (0L) /* Tvf Vertical Front Porch */
#define EVE_VSYNC1 (10L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */
#define EVE_VOFFSET (23L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */
#define EVE_VCYCLE (525L) /* Tv Total number of lines (visible and non-visible) (in lines) */
#define EVE_HSYNC0 (0L) /* Thf Horizontal Front Porch */
#define EVE_HSYNC1 (10L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */
#define EVE_HOFFSET (46L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */
#define EVE_HCYCLE (1056L) /* Th Total length of line (visible and non-visible) (in PCLKs) */
#define EVE_PCLKPOL (1L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */
#define EVE_SWIZZLE (0L) /* Defines the arrangement of the RGB pins of the FT800 */
#define EVE_PCLK (2L) /* 60MHz / REG_PCLK = PCLK frequency 30 MHz */
#define EVE_CSPREAD (1L) /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
#define EVE_TOUCH_RZTHRESH (1800L) /* touch-sensitivity */
#define FT81X_ENABLE
#endif
/* untested */
/* EVE2-29A 320x102 2.9" 1U Matrix Orbital, non-touch, FT812 */
#if defined (EVE_EVE2_29)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (102L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (156L)
#define EVE_VCYCLE (262L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (8L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* EVE2-35A 320x240 3.5" Matrix Orbital, resistive, or non-touch, FT812 */
#if defined (EVE_EVE2_35)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (18L)
#define EVE_VCYCLE (262L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (8L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* EVE2-35G 320x240 3.5" Matrix Orbital, capacitive touch, FT813 */
#if defined (EVE_EVE2_35G)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (18L)
#define EVE_VCYCLE (262L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (8L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_GT911 /* special treatment required for out-of-spec touch-controller */
#define FT81X_ENABLE
#endif
/* EVE2-38A 480x116 3.8" 1U Matrix Orbital, resistive touch, FT812 */
#if defined (EVE_EVE2_38)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (152L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* EVE2-38G 480x116 3.8" 1U Matrix Orbital, capacitive touch, FT813 */
#if defined (EVE_EVE2_38G)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (152L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_GT911 /* special treatment required for out-of-spec touch-controller */
#define FT81X_ENABLE
#endif
/* untested */
/* EVE2-43A 480x272 4.3" Matrix Orbital, resistive or no touch, FT812 */
#if defined (EVE_EVE2_43)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* EVE2-43G 480x272 4.3" Matrix Orbital, capacitive touch, FT813 */
#if defined (EVE_EVE2_43G)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_GT911 /* special treatment required for out-of-spec touch-controller */
#define FT81X_ENABLE
#endif
/* untested */
/* Matrix Orbital EVE2 modules EVE2-50A, EVE2-70A : 800x480 5.0" and 7.0" resistive, or no touch, FT812 */
#if defined (EVE_EVE2_50) || defined (EVE_EVE2_70)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* Matrix Orbital EVE2 modules EVE2-50G, EVE2-70G : 800x480 5.0" and 7.0" capacitive touch, FT813 */
#if defined (EVE_EVE2_50G) || defined (EVE_EVE2_70G)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_GT911 /* special treatment required for out-of-spec touch-controller */
#define FT81X_ENABLE
#endif
/* NHD-3.5-320240FT-CxXx-xxx 320x240 3.5" Newhaven, resistive or capacitive, FT81x */
#if defined (EVE_NHD_35)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (13L)
#define EVE_VCYCLE (263L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (2L)
#define EVE_PCLK (6L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* untested */
/* NHD-4.3-480272FT-CxXx-xxx 480x272 4.3" Newhaven, resistive or capacitive, FT81x */
#if defined (EVE_NHD_43)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (292L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (548L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* untested */
/* NHD-5.0-800480FT-CxXx-xxx 800x480 5.0" Newhaven, resistive or capacitive, FT81x */
#if defined (EVE_NHD_50)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* untested */
/* NHD-7.0-800480FT-CxXx-xxx 800x480 7.0" Newhaven, resistive or capacitive, FT81x */
#if defined (EVE_NHD_70)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (3L)
#define EVE_VOFFSET (32L)
#define EVE_VCYCLE (525L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (48L)
#define EVE_HOFFSET (88L)
#define EVE_HCYCLE (928L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* ADAM101-LCP-SWVGA-NEW 1024x600 10.1" Glyn, capacitive, FT813 */
#if defined (EVE_ADAM101)
#define EVE_HSIZE (1024L)
#define EVE_VSIZE (600L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (1L)
#define EVE_VOFFSET (1L)
#define EVE_VCYCLE (720L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (1L)
#define EVE_HOFFSET (1L)
#define EVE_HCYCLE (1100L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (1L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* Crystalfonts CFAF240400C1-030SC 240x400 3.0" , FT811 capacitive touch */
#if defined (EVE_CFAF240400C1_030SC)
#define EVE_HSIZE (240L)
#define EVE_VSIZE (400L)
#define EVE_VSYNC0 (4L)
#define EVE_VSYNC1 (6L)
#define EVE_VOFFSET (8L)
#define EVE_VCYCLE (409L)
#define EVE_HSYNC0 (10L)
#define EVE_HSYNC1 (20L)
#define EVE_HOFFSET (40L)
#define EVE_HCYCLE (489L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (2L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* Crystalfonts CFAF320240F-035T 320x240 3.5" , FT810 resistive touch */
#if defined (EVE_CFAF320240F_035T)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (1L)
#define EVE_VSYNC1 (4L)
#define EVE_VOFFSET (4L)
#define EVE_VCYCLE (245L)
#define EVE_HSYNC0 (10L)
#define EVE_HSYNC1 (20L)
#define EVE_HOFFSET (40L)
#define EVE_HCYCLE (510L)
#define EVE_PCLKPOL (0L)
#define EVE_SWIZZLE (2L)
#define EVE_PCLK (8L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* Crystalfonts CFAF480128A0-039TC 480x128 3.9" , FT811 capacitive touch */
#if defined (EVE_CFAF480128A0_039TC)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (128L)
#define EVE_VSYNC0 (4L)
#define EVE_VSYNC1 (5L)
#define EVE_VOFFSET (8L)
#define EVE_VCYCLE (137L)
#define EVE_HSYNC0 (24L)
#define EVE_HSYNC1 (35L)
#define EVE_HOFFSET (41L)
#define EVE_HCYCLE (1042L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (7L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define FT81X_ENABLE
#endif
/* Crystalfonts CFAF800480E0-050SC 800x480 5.0" , FT813 capacitive touch */
#if defined (EVE_CFAF800480E0_050SC)
#define EVE_HSIZE (800L)
#define EVE_VSIZE (480L)
#define EVE_VSYNC0 (7L)
#define EVE_VSYNC1 (8L)
#define EVE_VOFFSET (30L)
#define EVE_VCYCLE (511L)
#define EVE_HSYNC0 (16L)
#define EVE_HSYNC1 (17L)
#define EVE_HOFFSET (62L)
#define EVE_HCYCLE (978L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (2L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_GT911
#define FT81X_ENABLE
#endif
/* PAF90B5WFNWC01 800x480 9.0" Panasys, BT815 */
#if defined (EVE_PAF90)
#define EVE_HSIZE (800L) /* Thd Length of visible part of line (in PCLKs) - display width */
#define EVE_VSIZE (480L) /* Tvd Number of visible lines (in lines) - display height */
#define EVE_VSYNC0 (0L) /* Tvf Vertical Front Porch */
#define EVE_VSYNC1 (10L) /* Tvf + Tvp Vertical Front Porch plus Vsync Pulse width */
#define EVE_VOFFSET (23L) /* Tvf + Tvp + Tvb Number of non-visible lines (in lines) */
#define EVE_VCYCLE (525L) /* Tv Total number of lines (visible and non-visible) (in lines) */
#define EVE_HSYNC0 (0L) /* Thf Horizontal Front Porch */
#define EVE_HSYNC1 (10L) /* Thf + Thp Horizontal Front Porch plus Hsync Pulse width */
#define EVE_HOFFSET (46L) /* Thf + Thp + Thb Length of non-visible part of line (in PCLK cycles) */
#define EVE_HCYCLE (1056L) /* Th Total length of line (visible and non-visible) (in PCLKs) */
#define EVE_PCLKPOL (1L) /* PCLK polarity (0 = rising edge, 1 = falling edge) */
#define EVE_SWIZZLE (0L) /* Defines the arrangement of the RGB pins of the FT800 */
#define EVE_PCLK (2L) /* 60MHz / REG_PCLK = PCLK frequency 30 MHz */
#define EVE_CSPREAD (1L) /* helps with noise, when set to 1 fewer signals are changed simultaneously, reset-default: 1 */
#define EVE_TOUCH_RZTHRESH (1200L) /* touch-sensitivity */
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#define BT81X_ENABLE
#endif
/* untested */
/* Sunflower Arduino Shield, 320x240 3.5" from Cowfish, FT813, https://github.com/Cowfish-Studios/Cowfish_Sunflower_Shield_PCB */
/* set EVE_CS to 6 and EVE_PDN to 5 in the Arduino block in EVE_target.h */
#if defined (EVE_SUNFLOWER)
#define EVE_HSIZE (320L)
#define EVE_VSIZE (240L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (2L)
#define EVE_VOFFSET (13L)
#define EVE_VCYCLE (263L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (10L)
#define EVE_HOFFSET (70L)
#define EVE_HCYCLE (408L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (2L)
#define EVE_PCLK (6L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (1200L)
#define EVE_HAS_CRYSTAL
#define FT81X_ENABLE
#endif
/* untested */
/* MikroElektronika ConnectEVE, FT800 480x272 4.3" */
#if defined (EVE_CONNECTEVE)
#define EVE_HSIZE (480L)
#define EVE_VSIZE (272L)
#define EVE_VSYNC0 (0L)
#define EVE_VSYNC1 (10L)
#define EVE_VOFFSET (12L)
#define EVE_VCYCLE (286L)
#define EVE_HSYNC0 (0L)
#define EVE_HSYNC1 (41L)
#define EVE_HOFFSET (43L)
#define EVE_HCYCLE (525L)
#define EVE_PCLKPOL (1L)
#define EVE_SWIZZLE (0L)
#define EVE_PCLK (5L)
#define EVE_CSPREAD (0L)
#define EVE_TOUCH_RZTHRESH (2000L)
#define EVE_HAS_CRYSTAL
#endif
#endif /* EVE_CONFIG_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/EVE_config.h | C | apache-2.0 | 30,006 |
#include <stdio.h>
#include "driver/gpio.h"
#include "FT81x.h"
#include "EVE.h"
#include "EVE_commands.h"
/* some pre-definded colors */
#define RED 0xff0000UL
#define ORANGE 0xffa500UL
#define GREEN 0x00ff00UL
#define BLUE 0x0000ffUL
#define BLUE_1 0x5dade2L
#define YELLOW 0xffff00UL
#define PINK 0xff00ffUL
#define PURPLE 0x800080UL
#define WHITE 0xffffffUL
#define BLACK 0x000000UL
/* memory-map defines */
#define SCREEN_BITMAP_ADDR 0x00000000 // full screen buffer (0x00000000 - 0x000BBE40)
uint8_t tft_active = 0;
void touch_calibrate(void)
{
/* send pre-recorded touch calibration values, depending on the display the code is compiled for */
#if defined (EVE_CFAF240400C1_030SC)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x0000ed11);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x00001139);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff76809);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x00000000);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00010690);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xfffadf2e);
#endif
#if defined (EVE_CFAF320240F_035T)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x00005614);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x0000009e);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff43422);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x0000001d);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0xffffbda4);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x00f8f2ef);
#endif
#if defined (EVE_CFAF480128A0_039TC)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x00010485);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x0000017f);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfffb0bd3);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x00000073);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0000e293);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x00069904);
#endif
#if defined (EVE_CFAF800480E0_050SC)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000107f9);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0xffffff8c);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff451ae);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x000000d2);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0000feac);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xfffcfaaf);
#endif
#if defined (EVE_PAF90)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x00000159);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x0001019c);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff93625);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x00010157);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00000000);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x0000c101);
#endif
#if defined (EVE_RiTFT43)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000062cd);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0xfffffe45);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff45e0a);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x000001a3);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00005b33);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xFFFbb870);
#endif
#if defined (EVE_EVE2_38)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x00007bed);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x000001b0);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfff60aa5);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x00000095);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0xffffdcda);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x00829c08);
#endif
#if defined (EVE_EVE2_35G)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000109E4);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x000007A6);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xFFEC1EBA);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x0000072C);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0001096A);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xFFF469CF);
#endif
#if defined (EVE_EVE2_43G)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x0000a1ff);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x00000680);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xffe54cc2);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0xffffff53);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0000912c);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xfffe628d);
#endif
#if defined (EVE_EVE2_50G)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000109E4);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x000007A6);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xFFEC1EBA);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x0000072C);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0001096A);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xFFF469CF);
#endif
#if defined (EVE_EVE2_70G)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000105BC);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0xFFFFFA8A);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0x00004670);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0xFFFFFF75);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00010074);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xFFFF14C8);
#endif
#if defined (EVE_NHD_35)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x0000f78b);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x00000427);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfffcedf8);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0xfffffba4);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x0000f756);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x0009279e);
#endif
#if defined (EVE_RVT70)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000074df);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x000000e6);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xfffd5474);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0x000001af);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00007e79);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0xffe9a63c);
#endif
#if defined (EVE_FT811CB_HY50HD)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 66353);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 712);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 4293876677);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 4294966157);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 67516);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 418276);
#endif
#if defined (EVE_ADAM101)
EVE_memWrite32(REG_TOUCH_TRANSFORM_A, 0x000101E3);
EVE_memWrite32(REG_TOUCH_TRANSFORM_B, 0x00000114);
EVE_memWrite32(REG_TOUCH_TRANSFORM_C, 0xFFF5EEBA);
EVE_memWrite32(REG_TOUCH_TRANSFORM_D, 0xFFFFFF5E);
EVE_memWrite32(REG_TOUCH_TRANSFORM_E, 0x00010226);
EVE_memWrite32(REG_TOUCH_TRANSFORM_F, 0x0000C783);
#endif
/* activate this if you are using a module for the first time or if you need to re-calibrate it */
/* write down the numbers on the screen and either place them in one of the pre-defined blocks above or make a new block */
// Note: requires FT81x_FULL to be defined
#if 0
/* calibrate touch and displays values to screen */
EVE_cmd_dl(CMD_DLSTART);
EVE_cmd_dl(DL_CLEAR_RGB | BLACK);
EVE_cmd_dl(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG);
EVE_cmd_text((EVE_HSIZE/2), 50, 26, EVE_OPT_CENTER, "Please tap on the dot.");
EVE_cmd_calibrate();
EVE_cmd_dl(DL_DISPLAY);
EVE_cmd_dl(CMD_SWAP);
EVE_cmd_execute();
uint32_t touch_a, touch_b, touch_c, touch_d, touch_e, touch_f;
touch_a = EVE_memRead32(REG_TOUCH_TRANSFORM_A);
touch_b = EVE_memRead32(REG_TOUCH_TRANSFORM_B);
touch_c = EVE_memRead32(REG_TOUCH_TRANSFORM_C);
touch_d = EVE_memRead32(REG_TOUCH_TRANSFORM_D);
touch_e = EVE_memRead32(REG_TOUCH_TRANSFORM_E);
touch_f = EVE_memRead32(REG_TOUCH_TRANSFORM_F);
EVE_cmd_dl(CMD_DLSTART);
EVE_cmd_dl(DL_CLEAR_RGB | BLACK);
EVE_cmd_dl(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG);
EVE_cmd_dl(TAG(0));
EVE_cmd_text(5, 15, 26, 0, "TOUCH_TRANSFORM_A:");
EVE_cmd_text(5, 30, 26, 0, "TOUCH_TRANSFORM_B:");
EVE_cmd_text(5, 45, 26, 0, "TOUCH_TRANSFORM_C:");
EVE_cmd_text(5, 60, 26, 0, "TOUCH_TRANSFORM_D:");
EVE_cmd_text(5, 75, 26, 0, "TOUCH_TRANSFORM_E:");
EVE_cmd_text(5, 90, 26, 0, "TOUCH_TRANSFORM_F:");
#if defined (FT81X_ENABLE)
EVE_cmd_setbase(16L); /* FT81x only */
EVE_cmd_number(310, 15, 26, EVE_OPT_RIGHTX|8, touch_a);
EVE_cmd_number(310, 30, 26, EVE_OPT_RIGHTX|8, touch_b);
EVE_cmd_number(310, 45, 26, EVE_OPT_RIGHTX|8, touch_c);
EVE_cmd_number(310, 60, 26, EVE_OPT_RIGHTX|8, touch_d);
EVE_cmd_number(310, 75, 26, EVE_OPT_RIGHTX|8, touch_e);
EVE_cmd_number(310, 90, 26, EVE_OPT_RIGHTX|8, touch_f);
#else
EVE_cmd_number(310, 15, 26, EVE_OPT_RIGHTX, touch_a);
EVE_cmd_number(310, 30, 26, EVE_OPT_RIGHTX, touch_b);
EVE_cmd_number(310, 45, 26, EVE_OPT_RIGHTX, touch_c);
EVE_cmd_number(310, 60, 26, EVE_OPT_RIGHTX, touch_d);
EVE_cmd_number(310, 75, 26, EVE_OPT_RIGHTX, touch_e);
EVE_cmd_number(310, 90, 26, EVE_OPT_RIGHTX, touch_f);
#endif
EVE_cmd_dl(DL_DISPLAY); /* instruct the graphics processor to show the list */
EVE_cmd_dl(CMD_SWAP); /* make this list active */
EVE_cmd_execute();
while(1);
#endif
}
// set up a display list for a fullscreen writable bitmap
void TFT_bitmap_display(void)
{
if(tft_active != 0)
{
EVE_start_cmd_burst(); /* start writing to the cmd-fifo as one stream of bytes, only sending the address once */
EVE_cmd_dl(CMD_DLSTART); /* start the display list */
EVE_cmd_dl(DL_CLEAR_RGB | BLACK); /* set the default clear color to black */
EVE_cmd_dl(DL_CLEAR | CLR_COL | CLR_STN | CLR_TAG); /* clear the screen - this and the previous prevent artifacts between lists, Attributes are the color, stencil and tag buffers */
EVE_cmd_dl(TAG(0));
// fullscreen bitmap for memory-mapped direct access
EVE_cmd_dl(TAG(20));
EVE_cmd_setbitmap(SCREEN_BITMAP_ADDR, EVE_RGB565, EVE_HSIZE, EVE_VSIZE);
EVE_cmd_dl(DL_BEGIN | EVE_BITMAPS);
EVE_cmd_dl(VERTEX2F(0, 0));
EVE_cmd_dl(DL_END);
EVE_cmd_dl(TAG(0));
EVE_cmd_dl(DL_DISPLAY); /* instruct the graphics processor to show the list */
EVE_cmd_dl(CMD_SWAP); /* make this list active */
EVE_end_cmd_burst(); /* stop writing to the cmd-fifo */
EVE_cmd_start(); /* order the command co-processor to start processing its FIFO queue but do not wait for completion */
}
}
void FT81x_init(void)
{
#if EVE_USE_PDN
gpio_pad_select_gpio(EVE_PDN);
#endif
gpio_set_level(EVE_CS, 1);
#if EVE_USE_PDN
gpio_set_direction(EVE_PDN, GPIO_MODE_OUTPUT);
#endif
spi_acquire();
if(EVE_init())
{
tft_active = 1;
EVE_memWrite8(REG_PWM_DUTY, 0x30); /* setup backlight, range is from 0 = off to 0x80 = max */
touch_calibrate();
EVE_cmd_memset(SCREEN_BITMAP_ADDR, BLACK, SCREEN_BUFFER_SIZE); // clear screen buffer
EVE_cmd_execute();
TFT_bitmap_display(); // set DL for fullscreen bitmap display
}
spi_release();
}
// write fullscreen bitmap directly
void TFT_WriteScreen(uint8_t* Bitmap)
{
EVE_memWrite_buffer(SCREEN_BITMAP_ADDR, Bitmap, SCREEN_BUFFER_SIZE, false);
}
// write bitmap directly, line-by-line
void TFT_WriteBitmap(uint8_t* Bitmap, uint16_t X, uint16_t Y, uint16_t Width, uint16_t Height)
{
// calc base address
uint32_t addr = SCREEN_BITMAP_ADDR + (Y * BYTES_PER_LINE) + (X * BYTES_PER_PIXEL);
// can we do a fast full width block transfer?
if(X == 0 && Width == EVE_HSIZE)
{
EVE_memWrite_buffer(addr, Bitmap, (Height * BYTES_PER_LINE), true);
}
else
{
// line by line mode
uint32_t bpl = Width * BYTES_PER_PIXEL;
for (uint16_t i = 0; i < Height; i++)
{
EVE_memWrite_buffer(addr, Bitmap + (i * bpl), bpl, (i == Height - 1));
addr += BYTES_PER_LINE;
}
}
}
// LittlevGL flush callback
void FT81x_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
TFT_WriteBitmap((uint8_t*)color_map, area->x1, area->y1, lv_area_get_width(area), lv_area_get_height(area));
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/FT81x.c | C | apache-2.0 | 10,960 |
#ifndef FT81X_H_
#define FT81X_H_
#include <stdint.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
void FT81x_init(void);
void FT81x_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
#endif /* FT81X_H_ */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/FT81x.h | C | apache-2.0 | 306 |
/**
* @file GC9A01.c
*
*/
/*********************
* INCLUDES
*********************/
#include "GC9A01.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "GC9A01"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void GC9A01_set_orientation(uint8_t orientation);
static void GC9A01_send_cmd(uint8_t cmd);
static void GC9A01_send_data(void * data, uint16_t length);
static void GC9A01_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void GC9A01_init(void)
{
lcd_init_cmd_t GC_init_cmds[]={
////////////////////////////////////////////
{0xEF, {0}, 0},
{0xEB, {0x14}, 1},
{0xFE, {0}, 0},
{0xEF, {0}, 0},
{0xEB, {0x14}, 1},
{0x84, {0x40}, 1},
{0x85, {0xFF}, 1},
{0x86, {0xFF}, 1},
{0x87, {0xFF}, 1},
{0x88, {0x0A}, 1},
{0x89, {0x21}, 1},
{0x8A, {0x00}, 1},
{0x8B, {0x80}, 1},
{0x8C, {0x01}, 1},
{0x8D, {0x01}, 1},
{0x8E, {0xFF}, 1},
{0x8F, {0xFF}, 1},
{0xB6, {0x00, 0x20}, 2},
//call orientation
{0x3A, {0x05}, 1},
{0x90, {0x08, 0x08, 0X08, 0X08}, 4},
{0xBD, {0x06}, 1},
{0xBC, {0x00}, 1},
{0xFF, {0x60, 0x01, 0x04}, 3},
{0xC3, {0x13}, 1},
{0xC4, {0x13}, 1},
{0xC9, {0x22}, 1},
{0xBE, {0x11}, 1},
{0xE1, {0x10, 0x0E}, 2},
{0xDF, {0x21, 0x0C, 0x02}, 3},
{0xF0, {0x45, 0x09, 0x08, 0x08, 0x26, 0x2A}, 6},
{0xF1, {0x43, 0x70, 0x72, 0x36, 0x37, 0x6F}, 6},
{0xF2, {0x45, 0x09, 0x08, 0x08, 0x26, 0x2A}, 6},
{0xF3, {0x43, 0x70, 0x72, 0x36, 0x37, 0x6F}, 6},
{0xED, {0x1B, 0x0B}, 2},
{0xAE, {0x77}, 1},
{0xCD, {0x63}, 1},
{0x70, {0x07, 0x07, 0x04, 0x0E, 0x0F, 0x09, 0x07, 0X08, 0x03}, 9},
{0xE8, {0x34}, 1},
{0x62, {0x18, 0x0D, 0x71, 0xED, 0x70, 0x70, 0x18, 0X0F, 0x71, 0xEF, 0x70, 0x70}, 12},
{0x63, {0x18, 0x11, 0x71, 0xF1, 0x70, 0x70, 0x18, 0X13, 0x71, 0xF3, 0x70, 0x70}, 12},
{0x64, {0x28, 0x29, 0xF1, 0x01, 0xF1, 0x00, 0x07}, 7},
{0x66, {0x3C, 0x00, 0xCD, 0x67, 0x45, 0x45, 0x10, 0X00, 0x00, 0x00}, 10},
{0x67, {0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, 0x54, 0X10, 0x32, 0x98}, 10},
{0x74, {0x10, 0x85, 0x80, 0x00, 0x00, 0x4E, 0x00}, 7},
{0x98, {0x3E, 0x07}, 2},
{0x35, {0}, 0},
{0x21, {0}, 0},
{0x11, {0}, 0x80}, //0x80 delay flag
{0x29, {0}, 0x80}, //0x80 delay flag
{0, {0}, 0xff}, //init end flag
////////////////////////////////////////////
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(GC9A01_DC);
gpio_set_direction(GC9A01_DC, GPIO_MODE_OUTPUT);
#if GC9A01_USE_RST
gpio_pad_select_gpio(GC9A01_RST);
gpio_set_direction(GC9A01_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(GC9A01_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(GC9A01_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "Initialization.");
//Send all the commands
uint16_t cmd = 0;
while (GC_init_cmds[cmd].databytes!=0xff) {
GC9A01_send_cmd(GC_init_cmds[cmd].cmd);
GC9A01_send_data(GC_init_cmds[cmd].data, GC_init_cmds[cmd].databytes&0x1F);
if (GC_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
GC9A01_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
#if GC9A01_INVERT_COLORS == 1
GC9A01_send_cmd(0x21);
#else
GC9A01_send_cmd(0x20);
#endif
}
void GC9A01_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t data[4];
/*Column addresses*/
GC9A01_send_cmd(0x2A); //0x2A
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = area->x1 & 0xFF;
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = area->x2 & 0xFF;
GC9A01_send_data(data, 4);
/*Page addresses*/
GC9A01_send_cmd(0x2B); //0x2B
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = area->y1 & 0xFF;
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = area->y2 & 0xFF;
GC9A01_send_data(data, 4);
/*Memory write*/
GC9A01_send_cmd(0x2C); //0x2C
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
GC9A01_send_color((void*)color_map, size * 2);
}
void GC9A01_sleep_in()
{
uint8_t data[] = {0x08};
GC9A01_send_cmd(0x10); //0x10 Enter Sleep Mode
GC9A01_send_data(&data, 1);
}
void GC9A01_sleep_out()
{
uint8_t data[] = {0x08};
GC9A01_send_cmd(0x11); //0x11 Sleep OUT
GC9A01_send_data(&data, 1);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void GC9A01_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(GC9A01_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void GC9A01_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(GC9A01_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void GC9A01_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(GC9A01_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void GC9A01_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
#if defined CONFIG_LV_PREDEFINED_DISPLAY_M5STACK
uint8_t data[] = {0x68, 0x68, 0x08, 0x08}; ///
#elif defined (CONFIG_LV_PREDEFINED_DISPLAY_WROVER4)
uint8_t data[] = {0x4C, 0x88, 0x28, 0xE8}; ///
#elif defined (CONFIG_LV_PREDEFINED_DISPLAY_NONE)
uint8_t data[] = {0x08, 0xC8, 0x68, 0xA8}; ///ggggg
#endif
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
GC9A01_send_cmd(0x36);
GC9A01_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/GC9A01.c | C | apache-2.0 | 6,232 |
/**
* @file lv_templ.h
*
*/
#ifndef GC9A01_H
#define GC9A01_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define GC9A01_DC CONFIG_LV_DISP_PIN_DC
#define GC9A01_RST CONFIG_LV_DISP_PIN_RST
#define GC9A01_USE_RST CONFIG_LV_DISP_USE_RST
#define GC9A01_INVERT_COLORS CONFIG_LV_INVERT_COLORS
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void GC9A01_init(void);
void GC9A01_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void GC9A01_sleep_in(void);
void GC9A01_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*GC9A01_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/GC9A01.h | C | apache-2.0 | 1,021 |
/**
* @file disp_driver.c
*/
#include "disp_driver.h"
#include "disp_spi.h"
#include "esp_lcd_backlight.h"
#include "sdkconfig.h"
void *disp_driver_init(void)
{
#if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341
ili9341_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481
ili9481_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488
ili9488_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789
st7789_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S
st7796s_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S
st7735s_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357
hx8357_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486
ili9486_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
sh1107_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
ssd1306_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X
FT81x_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820
il3820_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875
ra8875_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01
GC9A01_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A
jd79653a_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D
uc8151d_init();
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C
ili9163c_init();
#endif
// We still use menuconfig for these settings
// It will be set up during runtime in the future
#if (defined(CONFIG_LV_DISP_BACKLIGHT_SWITCH) || defined(CONFIG_LV_DISP_BACKLIGHT_PWM))
const disp_backlight_config_t bckl_config = {
.gpio_num = CONFIG_LV_DISP_PIN_BCKL,
#if defined CONFIG_LV_DISP_BACKLIGHT_PWM
.pwm_control = true,
#else
.pwm_control = false,
#endif
#if defined CONFIG_LV_BACKLIGHT_ACTIVE_LVL
.output_invert = false, // Backlight on high
#else
.output_invert = true, // Backlight on low
#endif
.timer_idx = 0,
.channel_idx = 0 // @todo this prevents us from having two PWM controlled displays
};
disp_backlight_h bckl_handle = disp_backlight_new(&bckl_config);
disp_backlight_set(bckl_handle, 100);
return bckl_handle;
#else
return NULL;
#endif
}
void disp_driver_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
#if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341
ili9341_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481
ili9481_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488
ili9488_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789
st7789_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S
st7796s_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S
st7735s_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357
hx8357_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486
ili9486_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
sh1107_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
ssd1306_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X
FT81x_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820
il3820_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875
ra8875_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01
GC9A01_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A
jd79653a_lv_fb_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D
uc8151d_lv_fb_flush(drv, area, color_map);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C
ili9163c_flush(drv, area, color_map);
#endif
}
void disp_driver_rounder(lv_disp_drv_t * disp_drv, lv_area_t * area)
{
#if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
ssd1306_rounder(disp_drv, area);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
sh1107_rounder(disp_drv, area);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820
il3820_rounder(disp_drv, area);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A
jd79653a_lv_rounder_cb(disp_drv, area);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D
uc8151d_lv_rounder_cb(disp_drv, area);
#endif
}
void disp_driver_set_px(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
#if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
ssd1306_set_px_cb(disp_drv, buf, buf_w, x, y, color, opa);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
sh1107_set_px_cb(disp_drv, buf, buf_w, x, y, color, opa);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820
il3820_set_px_cb(disp_drv, buf, buf_w, x, y, color, opa);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A
jd79653a_lv_set_fb_cb(disp_drv, buf, buf_w, x, y, color, opa);
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D
uc8151d_lv_set_fb_cb(disp_drv, buf, buf_w, x, y, color, opa);
#endif
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/disp_driver.c | C | apache-2.0 | 5,308 |
/**
* @file disp_driver.h
*/
#ifndef DISP_DRIVER_H
#define DISP_DRIVER_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#if defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9341
#include "ili9341.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9481
#include "ili9481.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9488
#include "ili9488.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7789
#include "st7789.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7796S
#include "st7796s.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ST7735S
#include "st7735s.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_HX8357
#include "hx8357.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9486
#include "ili9486.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SH1107
#include "sh1107.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_SSD1306
#include "ssd1306.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X
#include "FT81x.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_IL3820
#include "il3820.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875
#include "ra8875.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_GC9A01
#include "GC9A01.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_JD79653A
#include "jd79653a.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_UC8151D
#include "uc8151d.h"
#elif defined CONFIG_LV_TFT_DISPLAY_CONTROLLER_ILI9163C
#include "ili9163c.h"
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/* Initialize display */
void *disp_driver_init(void);
/* Display flush callback */
void disp_driver_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
/* Display rounder callback, used with monochrome dispays */
void disp_driver_rounder(lv_disp_drv_t * disp_drv, lv_area_t * area);
/* Display set_px callback, used with monochrome dispays */
void disp_driver_set_px(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*DISP_DRIVER_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/disp_driver.h | C | apache-2.0 | 2,412 |
/**
* @file disp_spi.c
*
*/
/*********************
* INCLUDES
*********************/
#include "esp_system.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "esp_log.h"
#define TAG "disp_spi"
#include <string.h>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
#include <freertos/task.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "disp_spi.h"
#include "disp_driver.h"
#include "../lvgl_helpers.h"
#include "../lvgl_spi_conf.h"
/******************************************************************************
* Notes about DMA spi_transaction_ext_t structure pooling
*
* An xQueue is used to hold a pool of reusable SPI spi_transaction_ext_t
* structures that get used for all DMA SPI transactions. While an xQueue may
* seem like overkill it is an already built-in RTOS feature that comes at
* little cost. xQueues are also ISR safe if it ever becomes necessary to
* access the pool in the ISR callback.
*
* When a DMA request is sent, a transaction structure is removed from the
* pool, filled out, and passed off to the esp32 SPI driver. Later, when
* servicing pending SPI transaction results, the transaction structure is
* recycled back into the pool for later reuse. This matches the DMA SPI
* transaction life cycle requirements of the esp32 SPI driver.
*
* When polling or synchronously sending SPI requests, and as required by the
* esp32 SPI driver, all pending DMA transactions are first serviced. Then the
* polling SPI request takes place.
*
* When sending an asynchronous DMA SPI request, if the pool is empty, some
* small percentage of pending transactions are first serviced before sending
* any new DMA SPI transactions. Not too many and not too few as this balance
* controls DMA transaction latency.
*
* It is therefore not the design that all pending transactions must be
* serviced and placed back into the pool with DMA SPI requests - that
* will happen eventually. The pool just needs to contain enough to float some
* number of in-flight SPI requests to speed up the overall DMA SPI data rate
* and reduce transaction latency. If however a display driver uses some
* polling SPI requests or calls disp_wait_for_pending_transactions() directly,
* the pool will reach the full state more often and speed up DMA queuing.
*
*****************************************************************************/
/*********************
* DEFINES
*********************/
#define SPI_TRANSACTION_POOL_SIZE 50 /* maximum number of DMA transactions simultaneously in-flight */
/* DMA Transactions to reserve before queueing additional DMA transactions. A 1/10th seems to be a good balance. Too many (or all) and it will increase latency. */
#define SPI_TRANSACTION_POOL_RESERVE_PERCENTAGE 10
#if SPI_TRANSACTION_POOL_SIZE >= SPI_TRANSACTION_POOL_RESERVE_PERCENTAGE
#define SPI_TRANSACTION_POOL_RESERVE (SPI_TRANSACTION_POOL_SIZE / SPI_TRANSACTION_POOL_RESERVE_PERCENTAGE)
#else
#define SPI_TRANSACTION_POOL_RESERVE 1 /* defines minimum size */
#endif
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void IRAM_ATTR spi_ready (spi_transaction_t *trans);
/**********************
* STATIC VARIABLES
**********************/
static spi_host_device_t spi_host;
static spi_device_handle_t spi;
static QueueHandle_t TransactionPool = NULL;
static transaction_cb_t chained_post_cb;
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void disp_spi_add_device_config(spi_host_device_t host, spi_device_interface_config_t *devcfg)
{
spi_host=host;
chained_post_cb=devcfg->post_cb;
devcfg->post_cb=spi_ready;
esp_err_t ret=spi_bus_add_device(host, devcfg, &spi);
assert(ret==ESP_OK);
}
void disp_spi_add_device(spi_host_device_t host)
{
disp_spi_add_device_with_speed(host, SPI_TFT_CLOCK_SPEED_HZ);
}
void disp_spi_add_device_with_speed(spi_host_device_t host, int clock_speed_hz)
{
ESP_LOGI(TAG, "Adding SPI device");
ESP_LOGI(TAG, "Clock speed: %dHz, mode: %d, CS pin: %d",
clock_speed_hz, SPI_TFT_SPI_MODE, DISP_SPI_CS);
spi_device_interface_config_t devcfg={
.clock_speed_hz = clock_speed_hz,
.mode = SPI_TFT_SPI_MODE,
.spics_io_num=DISP_SPI_CS, // CS pin
.input_delay_ns=DISP_SPI_INPUT_DELAY_NS,
.queue_size=SPI_TRANSACTION_POOL_SIZE,
.pre_cb=NULL,
.post_cb=NULL,
#if defined(DISP_SPI_HALF_DUPLEX)
.flags = SPI_DEVICE_NO_DUMMY | SPI_DEVICE_HALFDUPLEX, /* dummy bits should be explicitly handled via DISP_SPI_VARIABLE_DUMMY as needed */
#else
#if defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_FT81X)
.flags = 0,
#elif defined (CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875)
.flags = SPI_DEVICE_NO_DUMMY,
#endif
#endif
};
disp_spi_add_device_config(host, &devcfg);
/* create the transaction pool and fill it with ptrs to spi_transaction_ext_t to reuse */
if(TransactionPool == NULL) {
TransactionPool = xQueueCreate(SPI_TRANSACTION_POOL_SIZE, sizeof(spi_transaction_ext_t*));
assert(TransactionPool != NULL);
for (size_t i = 0; i < SPI_TRANSACTION_POOL_SIZE; i++)
{
spi_transaction_ext_t* pTransaction = (spi_transaction_ext_t*)heap_caps_malloc(sizeof(spi_transaction_ext_t), MALLOC_CAP_DMA);
assert(pTransaction != NULL);
memset(pTransaction, 0, sizeof(spi_transaction_ext_t));
xQueueSend(TransactionPool, &pTransaction, portMAX_DELAY);
}
}
}
void disp_spi_change_device_speed(int clock_speed_hz)
{
if (clock_speed_hz <= 0) {
clock_speed_hz = SPI_TFT_CLOCK_SPEED_HZ;
}
ESP_LOGI(TAG, "Changing SPI device clock speed: %d", clock_speed_hz);
disp_spi_remove_device();
disp_spi_add_device_with_speed(spi_host, clock_speed_hz);
}
void disp_spi_remove_device()
{
/* Wait for previous pending transaction results */
disp_wait_for_pending_transactions();
esp_err_t ret=spi_bus_remove_device(spi);
assert(ret==ESP_OK);
}
void disp_spi_transaction(const uint8_t *data, size_t length,
disp_spi_send_flag_t flags, uint8_t *out,
uint64_t addr, uint8_t dummy_bits)
{
if (0 == length) {
return;
}
spi_transaction_ext_t t = {0};
/* transaction length is in bits */
t.base.length = length * 8;
if (length <= 4 && data != NULL) {
t.base.flags = SPI_TRANS_USE_TXDATA;
memcpy(t.base.tx_data, data, length);
} else {
t.base.tx_buffer = data;
}
if (flags & DISP_SPI_RECEIVE) {
assert(out != NULL && (flags & (DISP_SPI_SEND_POLLING | DISP_SPI_SEND_SYNCHRONOUS)));
t.base.rx_buffer = out;
#if defined(DISP_SPI_HALF_DUPLEX)
t.base.rxlength = t.base.length;
t.base.length = 0; /* no MOSI phase in half-duplex reads */
#else
t.base.rxlength = 0; /* in full-duplex mode, zero means same as tx length */
#endif
}
if (flags & DISP_SPI_ADDRESS_8) {
t.address_bits = 8;
} else if (flags & DISP_SPI_ADDRESS_16) {
t.address_bits = 16;
} else if (flags & DISP_SPI_ADDRESS_24) {
t.address_bits = 24;
} else if (flags & DISP_SPI_ADDRESS_32) {
t.address_bits = 32;
}
if (t.address_bits) {
t.base.addr = addr;
t.base.flags |= SPI_TRANS_VARIABLE_ADDR;
}
#if defined(DISP_SPI_HALF_DUPLEX)
if (flags & DISP_SPI_MODE_DIO) {
t.base.flags |= SPI_TRANS_MODE_DIO;
} else if (flags & DISP_SPI_MODE_QIO) {
t.base.flags |= SPI_TRANS_MODE_QIO;
}
if (flags & DISP_SPI_MODE_DIOQIO_ADDR) {
t.base.flags |= SPI_TRANS_MODE_DIOQIO_ADDR;
}
if ((flags & DISP_SPI_VARIABLE_DUMMY) && dummy_bits) {
t.dummy_bits = dummy_bits;
t.base.flags |= SPI_TRANS_VARIABLE_DUMMY;
}
#endif
/* Save flags for pre/post transaction processing */
t.base.user = (void *) flags;
/* Poll/Complete/Queue transaction */
if (flags & DISP_SPI_SEND_POLLING) {
disp_wait_for_pending_transactions(); /* before polling, all previous pending transactions need to be serviced */
spi_device_polling_transmit(spi, (spi_transaction_t *) &t);
} else if (flags & DISP_SPI_SEND_SYNCHRONOUS) {
disp_wait_for_pending_transactions(); /* before synchronous queueing, all previous pending transactions need to be serviced */
spi_device_transmit(spi, (spi_transaction_t *) &t);
} else {
/* if necessary, ensure we can queue new transactions by servicing some previous transactions */
if(uxQueueMessagesWaiting(TransactionPool) == 0) {
spi_transaction_t *presult;
while(uxQueueMessagesWaiting(TransactionPool) < SPI_TRANSACTION_POOL_RESERVE) {
if (spi_device_get_trans_result(spi, &presult, 1) == ESP_OK) {
xQueueSend(TransactionPool, &presult, portMAX_DELAY); /* back to the pool to be reused */
}
}
}
spi_transaction_ext_t *pTransaction = NULL;
xQueueReceive(TransactionPool, &pTransaction, portMAX_DELAY);
memcpy(pTransaction, &t, sizeof(t));
if (spi_device_queue_trans(spi, (spi_transaction_t *) pTransaction, portMAX_DELAY) != ESP_OK) {
xQueueSend(TransactionPool, &pTransaction, portMAX_DELAY); /* send failed transaction back to the pool to be reused */
}
}
}
void disp_wait_for_pending_transactions(void)
{
spi_transaction_t *presult;
while(uxQueueMessagesWaiting(TransactionPool) < SPI_TRANSACTION_POOL_SIZE) { /* service until the transaction reuse pool is full again */
if (spi_device_get_trans_result(spi, &presult, 1) == ESP_OK) {
xQueueSend(TransactionPool, &presult, portMAX_DELAY);
}
}
}
void disp_spi_acquire(void)
{
esp_err_t ret = spi_device_acquire_bus(spi, portMAX_DELAY);
assert(ret == ESP_OK);
}
void disp_spi_release(void)
{
spi_device_release_bus(spi);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void IRAM_ATTR spi_ready(spi_transaction_t *trans)
{
disp_spi_send_flag_t flags = (disp_spi_send_flag_t) trans->user;
if (flags & DISP_SPI_SIGNAL_FLUSH) {
lv_disp_t * disp = NULL;
#if (LVGL_VERSION_MAJOR >= 7)
disp = _lv_refr_get_disp_refreshing();
#else /* Before v7 */
disp = lv_refr_get_disp_refreshing();
#endif
#if LVGL_VERSION_MAJOR < 8
lv_disp_flush_ready(&disp->driver);
#else
lv_disp_flush_ready(disp->driver);
#endif
}
if (chained_post_cb) {
chained_post_cb(trans);
}
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/disp_spi.c | C | apache-2.0 | 10,530 |
/**
* @file disp_spi.h
*
*/
#ifndef DISP_SPI_H
#define DISP_SPI_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#include <driver/spi_master.h>
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
typedef enum _disp_spi_send_flag_t {
DISP_SPI_SEND_QUEUED = 0x00000000,
DISP_SPI_SEND_POLLING = 0x00000001,
DISP_SPI_SEND_SYNCHRONOUS = 0x00000002,
DISP_SPI_SIGNAL_FLUSH = 0x00000004,
DISP_SPI_RECEIVE = 0x00000008,
DISP_SPI_CMD_8 = 0x00000010, /* Reserved */
DISP_SPI_CMD_16 = 0x00000020, /* Reserved */
DISP_SPI_ADDRESS_8 = 0x00000040,
DISP_SPI_ADDRESS_16 = 0x00000080,
DISP_SPI_ADDRESS_24 = 0x00000100,
DISP_SPI_ADDRESS_32 = 0x00000200,
DISP_SPI_MODE_DIO = 0x00000400,
DISP_SPI_MODE_QIO = 0x00000800,
DISP_SPI_MODE_DIOQIO_ADDR = 0x00001000,
DISP_SPI_VARIABLE_DUMMY = 0x00002000,
} disp_spi_send_flag_t;
/**********************
* GLOBAL PROTOTYPES
**********************/
void disp_spi_add_device(spi_host_device_t host);
void disp_spi_add_device_config(spi_host_device_t host, spi_device_interface_config_t *devcfg);
void disp_spi_add_device_with_speed(spi_host_device_t host, int clock_speed_hz);
void disp_spi_change_device_speed(int clock_speed_hz);
void disp_spi_remove_device();
/* Important!
All buffers should also be 32-bit aligned and DMA capable to prevent extra allocations and copying.
When DMA reading (even in polling mode) the ESP32 always read in 4-byte chunks even if less is requested.
Extra space will be zero filled. Always ensure the out buffer is large enough to hold at least 4 bytes!
*/
void disp_spi_transaction(const uint8_t *data, size_t length,
disp_spi_send_flag_t flags, uint8_t *out, uint64_t addr, uint8_t dummy_bits);
void disp_wait_for_pending_transactions(void);
void disp_spi_acquire(void);
void disp_spi_release(void);
static inline void disp_spi_send_data(uint8_t *data, size_t length) {
disp_spi_transaction(data, length, DISP_SPI_SEND_POLLING, NULL, 0, 0);
}
static inline void disp_spi_send_colors(uint8_t *data, size_t length) {
disp_spi_transaction(data, length,
DISP_SPI_SEND_QUEUED | DISP_SPI_SIGNAL_FLUSH,
NULL, 0, 0);
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*DISP_SPI_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/disp_spi.h | C | apache-2.0 | 2,533 |
/**
* @file esp_lcd_backlight.c
*
*/
/*********************
* INCLUDES
*********************/
#include "esp_lcd_backlight.h"
#include "driver/ledc.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "soc/ledc_periph.h" // to invert LEDC output on IDF version < v4.3
typedef struct {
bool pwm_control; // true: LEDC is used, false: GPIO is used
int index; // Either GPIO or LEDC channel
} disp_backlight_t;
static const char *TAG = "disp_backlight";
disp_backlight_h disp_backlight_new(const disp_backlight_config_t *config)
{
// Check input parameters
if (config == NULL)
return NULL;
if (!GPIO_IS_VALID_OUTPUT_GPIO(config->gpio_num)) {
ESP_LOGW(TAG, "Invalid GPIO number");
return NULL;
}
disp_backlight_t *bckl_dev = calloc(1, sizeof(disp_backlight_t));
if (bckl_dev == NULL){
ESP_LOGW(TAG, "Not enough memory");
return NULL;
}
if (config->pwm_control){
// Configure LED (Backlight) pin as PWM for Brightness control.
bckl_dev->pwm_control = true;
bckl_dev->index = config->channel_idx;
const ledc_channel_config_t LCD_backlight_channel = {
.gpio_num = config->gpio_num,
.speed_mode = LEDC_LOW_SPEED_MODE,
.channel = config->channel_idx,
.intr_type = LEDC_INTR_DISABLE,
.timer_sel = config->timer_idx,
.duty = 0,
.hpoint = 0
};
const ledc_timer_config_t LCD_backlight_timer = {
.speed_mode = LEDC_LOW_SPEED_MODE,
.bit_num = LEDC_TIMER_10_BIT,
.timer_num = config->timer_idx,
.freq_hz = 5000,
.clk_cfg = LEDC_AUTO_CLK};
ESP_ERROR_CHECK(ledc_timer_config(&LCD_backlight_timer));
ESP_ERROR_CHECK(ledc_channel_config(&LCD_backlight_channel));
gpio_matrix_out(config->gpio_num, ledc_periph_signal[LEDC_LOW_SPEED_MODE].sig_out0_idx + config->channel_idx, config->output_invert, 0);
}
else
{
// Configure GPIO for output
bckl_dev->index = config->gpio_num;
gpio_pad_select_gpio(config->gpio_num);
ESP_ERROR_CHECK(gpio_set_direction(config->gpio_num, GPIO_MODE_OUTPUT));
gpio_matrix_out(config->gpio_num, SIG_GPIO_OUT_IDX, config->output_invert, false);
}
return (disp_backlight_h)bckl_dev;
}
void disp_backlight_set(disp_backlight_h bckl, int brightness_percent)
{
// Check input paramters
if (bckl == NULL)
return;
if (brightness_percent > 100)
brightness_percent = 100;
if (brightness_percent < 0)
brightness_percent = 0;
disp_backlight_t *bckl_dev = (disp_backlight_t *) bckl;
ESP_LOGI(TAG, "Setting LCD backlight: %d%%", brightness_percent);
if (bckl_dev->pwm_control) {
uint32_t duty_cycle = (1023 * brightness_percent) / 100; // LEDC resolution set to 10bits, thus: 100% = 1023
ESP_ERROR_CHECK(ledc_set_duty(LEDC_LOW_SPEED_MODE, bckl_dev->index, duty_cycle));
ESP_ERROR_CHECK(ledc_update_duty(LEDC_LOW_SPEED_MODE, bckl_dev->index));
} else {
ESP_ERROR_CHECK(gpio_set_level(bckl_dev->index, brightness_percent));
}
}
void disp_backlight_delete(disp_backlight_h bckl)
{
if (bckl == NULL)
return;
disp_backlight_t *bckl_dev = (disp_backlight_t *) bckl;
if (bckl_dev->pwm_control) {
ledc_stop(LEDC_LOW_SPEED_MODE, bckl_dev->index, 0);
} else {
gpio_reset_pin(bckl_dev->index);
}
free (bckl);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/esp_lcd_backlight.c | C | apache-2.0 | 3,522 |
/**
* @file esp_lcd_backlight.h
*/
#ifndef ESP_LCD_BACKLIGHT_H
#define ESP_LCD_BACKLIGHT_H
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef __cplusplus
extern "C" { /* extern "C" */
#endif
/**********************
* GLOBAL PROTOTYPES
**********************/
/**
* @brief Display backlight controller handle
*
*/
typedef void * disp_backlight_h;
/**
* @brief Configuration structure of backlight controller
*
* Must be passed to disp_backlight_new() for correct configuration
*/
typedef struct {
bool pwm_control;
bool output_invert;
int gpio_num; // see gpio_num_t
// Relevant only for PWM controlled backlight
// Ignored for switch (ON/OFF) backlight control
int timer_idx; // ledc_timer_t
int channel_idx; // ledc_channel_t
} disp_backlight_config_t;
/**
* @brief Create new backlight controller
*
* @param[in] config Configuration structure of backlight controller
* @return Display backlight controller handle
*/
disp_backlight_h disp_backlight_new(const disp_backlight_config_t *config);
/**
* @brief Set backlight
*
* Brightness parameter can be 0-100 for PWM controlled backlight.
* GPIO controlled backlight (ON/OFF) is turned off witch value 0 and turned on with any positive value.
*
* @param bckl Backlight controller handle
* @param[in] brightness_percent Brightness in [%]
*/
void disp_backlight_set(disp_backlight_h bckl, int brightness_percent);
void disp_backlight_delete(disp_backlight_h bckl);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ESP_LCD_BACKLIGHT_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/esp_lcd_backlight.h | C | apache-2.0 | 1,623 |
/**
* @file HX8357.c
*
* Roughly based on the Adafruit_HX8357_Library
*
* This library should work with:
* Adafruit 3.5" TFT 320x480 + Touchscreen Breakout
* http://www.adafruit.com/products/2050
*
* Adafruit TFT FeatherWing - 3.5" 480x320 Touchscreen for Feathers
* https://www.adafruit.com/product/3651
*
*/
/*********************
* INCLUDES
*********************/
#include "hx8357.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include <esp_log.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "HX8357"
#define MADCTL_MY 0x80 ///< Bottom to top
#define MADCTL_MX 0x40 ///< Right to left
#define MADCTL_MV 0x20 ///< Reverse Mode
#define MADCTL_ML 0x10 ///< LCD refresh Bottom to top
#define MADCTL_RGB 0x00 ///< Red-Green-Blue pixel order
#define MADCTL_BGR 0x08 ///< Blue-Green-Red pixel order
#define MADCTL_MH 0x04 ///< LCD refresh right to left
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void hx8357_send_cmd(uint8_t cmd);
static void hx8357_send_data(void * data, uint16_t length);
static void hx8357_send_color(void * data, uint16_t length);
/**********************
* INITIALIZATION ARRAYS
**********************/
// Taken from the Adafruit driver
static const uint8_t
initb[] = {
HX8357B_SETPOWER, 3,
0x44, 0x41, 0x06,
HX8357B_SETVCOM, 2,
0x40, 0x10,
HX8357B_SETPWRNORMAL, 2,
0x05, 0x12,
HX8357B_SET_PANEL_DRIVING, 5,
0x14, 0x3b, 0x00, 0x02, 0x11,
HX8357B_SETDISPLAYFRAME, 1,
0x0c, // 6.8mhz
HX8357B_SETPANELRELATED, 1,
0x01, // BGR
0xEA, 3, // seq_undefined1, 3 args
0x03, 0x00, 0x00,
0xEB, 4, // undef2, 4 args
0x40, 0x54, 0x26, 0xdb,
HX8357B_SETGAMMA, 12,
0x00, 0x15, 0x00, 0x22, 0x00, 0x08, 0x77, 0x26, 0x66, 0x22, 0x04, 0x00,
HX8357_MADCTL, 1,
0xC0,
HX8357_COLMOD, 1,
0x55,
HX8357_PASET, 4,
0x00, 0x00, 0x01, 0xDF,
HX8357_CASET, 4,
0x00, 0x00, 0x01, 0x3F,
HX8357B_SETDISPMODE, 1,
0x00, // CPU (DBI) and internal oscillation ??
HX8357_SLPOUT, 0x80 + 120/5, // Exit sleep, then delay 120 ms
HX8357_DISPON, 0x80 + 10/5, // Main screen turn on, delay 10 ms
0 // END OF COMMAND LIST
}, initd[] = {
HX8357_SWRESET, 0x80 + 100/5, // Soft reset, then delay 10 ms
HX8357D_SETC, 3,
0xFF, 0x83, 0x57,
0xFF, 0x80 + 500/5, // No command, just delay 300 ms
HX8357_SETRGB, 4,
0x80, 0x00, 0x06, 0x06, // 0x80 enables SDO pin (0x00 disables)
HX8357D_SETCOM, 1,
0x25, // -1.52V
HX8357_SETOSC, 1,
0x68, // Normal mode 70Hz, Idle mode 55 Hz
HX8357_SETPANEL, 1,
0x05, // BGR, Gate direction swapped
HX8357_SETPWR1, 6,
0x00, // Not deep standby
0x15, // BT
0x1C, // VSPR
0x1C, // VSNR
0x83, // AP
0xAA, // FS
HX8357D_SETSTBA, 6,
0x50, // OPON normal
0x50, // OPON idle
0x01, // STBA
0x3C, // STBA
0x1E, // STBA
0x08, // GEN
HX8357D_SETCYC, 7,
0x02, // NW 0x02
0x40, // RTN
0x00, // DIV
0x2A, // DUM
0x2A, // DUM
0x0D, // GDON
0x78, // GDOFF
HX8357D_SETGAMMA, 34,
0x02, 0x0A, 0x11, 0x1d, 0x23, 0x35, 0x41, 0x4b, 0x4b,
0x42, 0x3A, 0x27, 0x1B, 0x08, 0x09, 0x03, 0x02, 0x0A,
0x11, 0x1d, 0x23, 0x35, 0x41, 0x4b, 0x4b, 0x42, 0x3A,
0x27, 0x1B, 0x08, 0x09, 0x03, 0x00, 0x01,
HX8357_COLMOD, 1,
0x55, // 16 bit
HX8357_MADCTL, 1,
0xC0,
HX8357_TEON, 1,
0x00, // TW off
HX8357_TEARLINE, 2,
0x00, 0x02,
HX8357_SLPOUT, 0x80 + 150/5, // Exit Sleep, then delay 150 ms
HX8357_DISPON, 0x80 + 50/5, // Main screen turn on, delay 50 ms
0, // END OF COMMAND LIST
};
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
static uint8_t displayType = HX8357D;
void hx8357_init(void)
{
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(HX8357_DC);
gpio_set_direction(HX8357_DC, GPIO_MODE_OUTPUT);
#if HX8357_USE_RST
gpio_pad_select_gpio(HX8357_RST);
gpio_set_direction(HX8357_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(HX8357_RST, 0);
vTaskDelay(10 / portTICK_RATE_MS);
gpio_set_level(HX8357_RST, 1);
vTaskDelay(120 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "Initialization.");
//Send all the commands
const uint8_t *addr = (displayType == HX8357B) ? initb : initd;
uint8_t cmd, x, numArgs;
while((cmd = *addr++) > 0) { // '0' command ends list
x = *addr++;
numArgs = x & 0x7F;
if (cmd != 0xFF) { // '255' is ignored
if (x & 0x80) { // If high bit set, numArgs is a delay time
hx8357_send_cmd(cmd);
} else {
hx8357_send_cmd(cmd);
hx8357_send_data((void *) addr, numArgs);
addr += numArgs;
}
}
if (x & 0x80) { // If high bit set...
vTaskDelay(numArgs * 5 / portTICK_RATE_MS); // numArgs is actually a delay time (5ms units)
}
}
hx8357_set_rotation(1);
#if HX8357_INVERT_COLORS
hx8357_send_cmd(HX8357_INVON);
#else
hx8357_send_cmd(HX8357_INVOFF);
#endif
}
void hx8357_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
/* Column addresses */
uint8_t xb[] = {
(uint8_t) (area->x1 >> 8) & 0xFF,
(uint8_t) (area->x1) & 0xFF,
(uint8_t) (area->x2 >> 8) & 0xFF,
(uint8_t) (area->x2) & 0xFF,
};
/* Page addresses */
uint8_t yb[] = {
(uint8_t) (area->y1 >> 8) & 0xFF,
(uint8_t) (area->y1) & 0xFF,
(uint8_t) (area->y2 >> 8) & 0xFF,
(uint8_t) (area->y2) & 0xFF,
};
/*Column addresses*/
hx8357_send_cmd(HX8357_CASET);
hx8357_send_data(xb, 4);
/*Page addresses*/
hx8357_send_cmd(HX8357_PASET);
hx8357_send_data(yb, 4);
/*Memory write*/
hx8357_send_cmd(HX8357_RAMWR);
hx8357_send_color((void*)color_map, size * 2);
}
void hx8357_set_rotation(uint8_t r)
{
r = r & 3; // can't be higher than 3
switch(r) {
case 0:
r = MADCTL_MX | MADCTL_MY | MADCTL_RGB;
break;
case 1:
r = MADCTL_MV | MADCTL_MY | MADCTL_RGB;
break;
case 2:
r = MADCTL_RGB;
break;
case 3:
r = MADCTL_MX | MADCTL_MV | MADCTL_RGB;
break;
}
hx8357_send_cmd(HX8357_MADCTL);
hx8357_send_data(&r, 1);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void hx8357_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(HX8357_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void hx8357_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(HX8357_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void hx8357_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(HX8357_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/hx8357.c | C | apache-2.0 | 8,091 |
/**
* @file HX8357.h
*
* Roughly based on the Adafruit_HX8357_Library
*
* This library should work with:
* Adafruit 3.5" TFT 320x480 + Touchscreen Breakout
* http://www.adafruit.com/products/2050
*
* Adafruit TFT FeatherWing - 3.5" 480x320 Touchscreen for Feathers
* https://www.adafruit.com/product/3651
*
*/
#ifndef HX8357_H
#define HX8357_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include <stdint.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define HX8357_DC CONFIG_LV_DISP_PIN_DC
#define HX8357_RST CONFIG_LV_DISP_PIN_RST
#define HX8357_USE_RST CONFIG_LV_DISP_USE_RST
#define HX8357_INVERT_COLORS CONFIG_LV_INVERT_COLORS
/*******************
* HX8357B/D REGS
*********************/
#define HX8357D 0xD ///< Our internal const for D type
#define HX8357B 0xB ///< Our internal const for B type
#define HX8357_TFTWIDTH 320 ///< 320 pixels wide
#define HX8357_TFTHEIGHT 480 ///< 480 pixels tall
#define HX8357_NOP 0x00 ///< No op
#define HX8357_SWRESET 0x01 ///< software reset
#define HX8357_RDDID 0x04 ///< Read ID
#define HX8357_RDDST 0x09 ///< (unknown)
#define HX8357_RDPOWMODE 0x0A ///< Read power mode Read power mode
#define HX8357_RDMADCTL 0x0B ///< Read MADCTL
#define HX8357_RDCOLMOD 0x0C ///< Column entry mode
#define HX8357_RDDIM 0x0D ///< Read display image mode
#define HX8357_RDDSDR 0x0F ///< Read dosplay signal mode
#define HX8357_SLPIN 0x10 ///< Enter sleep mode
#define HX8357_SLPOUT 0x11 ///< Exit sleep mode
#define HX8357B_PTLON 0x12 ///< Partial mode on
#define HX8357B_NORON 0x13 ///< Normal mode
#define HX8357_INVOFF 0x20 ///< Turn off invert
#define HX8357_INVON 0x21 ///< Turn on invert
#define HX8357_DISPOFF 0x28 ///< Display on
#define HX8357_DISPON 0x29 ///< Display off
#define HX8357_CASET 0x2A ///< Column addr set
#define HX8357_PASET 0x2B ///< Page addr set
#define HX8357_RAMWR 0x2C ///< Write VRAM
#define HX8357_RAMRD 0x2E ///< Read VRAm
#define HX8357B_PTLAR 0x30 ///< (unknown)
#define HX8357_TEON 0x35 ///< Tear enable on
#define HX8357_TEARLINE 0x44 ///< (unknown)
#define HX8357_MADCTL 0x36 ///< Memory access control
#define HX8357_COLMOD 0x3A ///< Color mode
#define HX8357_SETOSC 0xB0 ///< Set oscillator
#define HX8357_SETPWR1 0xB1 ///< Set power control
#define HX8357B_SETDISPLAY 0xB2 ///< Set display mode
#define HX8357_SETRGB 0xB3 ///< Set RGB interface
#define HX8357D_SETCOM 0xB6 ///< Set VCOM voltage
#define HX8357B_SETDISPMODE 0xB4 ///< Set display mode
#define HX8357D_SETCYC 0xB4 ///< Set display cycle reg
#define HX8357B_SETOTP 0xB7 ///< Set OTP memory
#define HX8357D_SETC 0xB9 ///< Enable extension command
#define HX8357B_SET_PANEL_DRIVING 0xC0 ///< Set panel drive mode
#define HX8357D_SETSTBA 0xC0 ///< Set source option
#define HX8357B_SETDGC 0xC1 ///< Set DGC settings
#define HX8357B_SETID 0xC3 ///< Set ID
#define HX8357B_SETDDB 0xC4 ///< Set DDB
#define HX8357B_SETDISPLAYFRAME 0xC5 ///< Set display frame
#define HX8357B_GAMMASET 0xC8 ///< Set Gamma correction
#define HX8357B_SETCABC 0xC9 ///< Set CABC
#define HX8357_SETPANEL 0xCC ///< Set Panel
#define HX8357B_SETPOWER 0xD0 ///< Set power control
#define HX8357B_SETVCOM 0xD1 ///< Set VCOM
#define HX8357B_SETPWRNORMAL 0xD2 ///< Set power normal
#define HX8357B_RDID1 0xDA ///< Read ID #1
#define HX8357B_RDID2 0xDB ///< Read ID #2
#define HX8357B_RDID3 0xDC ///< Read ID #3
#define HX8357B_RDID4 0xDD ///< Read ID #4
#define HX8357D_SETGAMMA 0xE0 ///< Set Gamma
#define HX8357B_SETGAMMA 0xC8 ///< Set Gamma
#define HX8357B_SETPANELRELATED 0xE9 ///< Set panel related
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void hx8357_init(void);
void hx8357_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void hx8357_set_rotation(uint8_t r);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*HX8357_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/hx8357.h | C | apache-2.0 | 4,904 |
/**
@file il3820.c
@brief Waveshare e-paper 2.9in b/w display
@version 1.0
@date 2020-05-29
@author Juergen Kienhoefer
@section LICENSE
MIT License
Copyright (c) 2020 Juergen Kienhoefer
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/*********************
* INCLUDES
*********************/
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "il3820.h"
/*********************
* DEFINES
*********************/
#define TAG "IL3820"
/**
* SSD1673, SSD1608 compatible EPD controller driver.
*/
#define BIT_SET(a,b) ((a) |= (1U<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1U<<(b)))
/* Number of pixels? */
#define IL3820_PIXEL (LV_HOR_RES_MAX * LV_VER_RES_MAX)
#define EPD_PANEL_NUMOF_COLUMS EPD_PANEL_WIDTH
#define EPD_PANEL_NUMOF_ROWS_PER_PAGE 8
/* Are pages the number of bytes to represent the panel width? in bytes */
#define EPD_PANEL_NUMOF_PAGES (EPD_PANEL_HEIGHT / EPD_PANEL_NUMOF_ROWS_PER_PAGE)
#define IL3820_PANEL_FIRST_PAGE 0
#define IL3820_PANEL_LAST_PAGE (EPD_PANEL_NUMOF_PAGES - 1)
#define IL3820_PANEL_FIRST_GATE 0
#define IL3820_PANEL_LAST_GATE (EPD_PANEL_NUMOF_COLUMS - 1)
#define IL3820_PIXELS_PER_BYTE 8
uint8_t il3820_scan_mode = IL3820_DATA_ENTRY_XIYIY;
static uint8_t il3820_lut_initial[] = {
0x50, 0xAA, 0x55, 0xAA, 0x11, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static uint8_t il3820_lut_default[] = {
0x10, 0x18, 0x18, 0x08, 0x18, 0x18,
0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static uint8_t il3820_softstart[] = {0xd7, 0xd6, 0x9d};
static uint8_t il3820_vcom[] = {0xa8};
/* 4 dummy lines per gate */
static uint8_t il3820_dummyline[] = {0x1a};
/* 2us per line */
static uint8_t il3820_gatetime[] = {0x08};
static uint8_t il3820_border[] = {0x03};
static bool il3820_partial = false;
/* Static functions */
static void il3820_clear_cntlr_mem(uint8_t ram_cmd, bool update);
static void il3820_waitbusy(int wait_ms);
static inline void il3820_command_mode(void);
static inline void il3820_data_mode(void);
static inline void il3820_write_cmd(uint8_t cmd, uint8_t *data, size_t len);
static inline void il3820_send_cmd(uint8_t cmd);
static void il3820_send_data(uint8_t *data, uint16_t length);
static inline void il3820_set_window( uint16_t sx, uint16_t ex, uint16_t ys, uint16_t ye);
static inline void il3820_set_cursor(uint16_t sx, uint16_t ys);
static void il3820_update_display(void);
static void il3820_clear_cntlr_mem(uint8_t ram_cmd, bool update);
/* Required by LVGL */
void il3820_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
/* Each byte holds the data of 8 pixels, linelen is the number of bytes
* we need to cover a line of the display. */
size_t linelen = EPD_PANEL_WIDTH / 8;
uint8_t *buffer = (uint8_t*) color_map;
uint16_t x_addr_counter = 0;
uint16_t y_addr_counter = 0;
/* Configure entry mode */
il3820_write_cmd(IL3820_CMD_ENTRY_MODE, &il3820_scan_mode, 1);
/* Configure the window based on the coordinates got from LVGL
* It looks like this epaper display controller doesn't support partial update,
* so the window is always the same, the display size. */
il3820_set_window(0, EPD_PANEL_WIDTH - 1, 0, EPD_PANEL_HEIGHT - 1);
/* Set the cursor at the beginning of the graphic RAM */
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
x_addr_counter = EPD_PANEL_WIDTH - 1;
y_addr_counter = EPD_PANEL_HEIGHT - 1;
#endif
il3820_set_cursor(x_addr_counter, y_addr_counter);
il3820_send_cmd(IL3820_CMD_WRITE_RAM);
/* Write the pixel data to graphic RAM, linelen bytes at the time. */
for(size_t row = 0; row <= (EPD_PANEL_HEIGHT - 1); row++){
il3820_send_data(buffer, linelen);
buffer += IL3820_COLUMNS;
}
il3820_set_window(0, EPD_PANEL_WIDTH - 1, 0, EPD_PANEL_HEIGHT - 1);
il3820_update_display();
/* IMPORTANT!!!
* Inform the graphics library that you are ready with the flushing */
lv_disp_flush_ready(drv);
}
/* Rotate the display by "software" when using PORTRAIT orientation.
* BIT_SET(byte_index, bit_index) clears the bit_index pixel at byte_index of
* the display buffer.
* BIT_CLEAR(byte_index, bit_index) sets the bit_index pixel at the byte_index
* of the display buffer. */
void il3820_set_px_cb(lv_disp_drv_t * disp_drv, uint8_t* buf,
lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
uint16_t byte_index = 0;
uint8_t bit_index = 0;
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
byte_index = x + ((y >> 3) * EPD_PANEL_HEIGHT);
bit_index = y & 0x7;
if (color.full) {
BIT_SET(buf[byte_index], 7 - bit_index);
} else {
uint16_t mirrored_idx = (EPD_PANEL_HEIGHT - x) + ((y >> 3) * EPD_PANEL_HEIGHT);
BIT_CLEAR(buf[mirrored_idx], 7 - bit_index);
}
#elif defined (CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE)
byte_index = y + ((x >> 3) * EPD_PANEL_HEIGHT);
bit_index = x & 0x7;
if (color.full) {
BIT_SET(buf[byte_index], 7 - bit_index);
} else {
BIT_CLEAR(buf[byte_index], 7 - bit_index);
}
#else
#error "Unsupported orientation used"
#endif
}
/* Required by LVGL */
void il3820_rounder(lv_disp_drv_t * disp_drv, lv_area_t *area) {
area->x1 = area->x1 & ~(0x7);
area->x2 = area->x2 | (0x7);
}
/* main initialization routine */
void il3820_init(void)
{
uint8_t tmp[3] = {0};
/* Initialize non-SPI GPIOs */
gpio_pad_select_gpio(IL3820_DC_PIN);
gpio_set_direction(IL3820_DC_PIN, GPIO_MODE_OUTPUT);
gpio_pad_select_gpio(IL3820_BUSY_PIN);
gpio_set_direction(IL3820_BUSY_PIN, GPIO_MODE_INPUT);
#if IL3820_USE_RST
gpio_pad_select_gpio(IL3820_RST_PIN);
gpio_set_direction(IL3820_RST_PIN, GPIO_MODE_OUTPUT);
/* Harware reset */
gpio_set_level( IL3820_RST_PIN, 0);
vTaskDelay(IL3820_RESET_DELAY / portTICK_RATE_MS);
gpio_set_level( IL3820_RST_PIN, 1);
vTaskDelay(IL3820_RESET_DELAY / portTICK_RATE_MS);
#endif
/* Software reset */
il3820_write_cmd(IL3820_CMD_SW_RESET, NULL, 0);
/* Busy wait for the BUSY signal to go low */
il3820_waitbusy(IL3820_WAIT);
/**/
tmp[0] = ( EPD_PANEL_HEIGHT - 1) & 0xFF;
tmp[1] = ( EPD_PANEL_HEIGHT >> 8 );
tmp[2] = 0; // GD = 0; SM = 0; TB = 0;
il3820_write_cmd(IL3820_CMD_GDO_CTRL, tmp, 3);
/**/
il3820_write_cmd(IL3820_CMD_SOFTSTART, il3820_softstart, sizeof(il3820_softstart));
/* Write VCOM register */
il3820_write_cmd(IL3820_CMD_VCOM_VOLTAGE, il3820_vcom, 1);
/* Set dummy line period (in term of TGate) */
il3820_write_cmd(IL3820_CMD_DUMMY_LINE, il3820_dummyline, 1);
/* Set gate line width (TGate) in us */
il3820_write_cmd(IL3820_CMD_GATE_LINE_WIDTH, il3820_gatetime, 1);
/* Select border waveform for VBD */
il3820_write_cmd(IL3820_CMD_BWF_CTRL, il3820_border, 1);
/**/
il3820_write_cmd(IL3820_CMD_UPDATE_LUT, il3820_lut_initial, sizeof(il3820_lut_initial));
/* Clear control memory and update */
il3820_clear_cntlr_mem(IL3820_CMD_WRITE_RAM, true);
// allow partial updates now
il3820_partial = true;
/* Update LUT */
il3820_write_cmd(IL3820_CMD_UPDATE_LUT, il3820_lut_default, sizeof(il3820_lut_default));
/* Clear control memory and update */
il3820_clear_cntlr_mem(IL3820_CMD_WRITE_RAM, true);
}
/* Enter deep sleep mode */
void il3820_sleep_in(void)
{
uint8_t data[] = {0x01};
/* Wait for the BUSY signal to go low */
il3820_waitbusy(IL3820_WAIT);
il3820_write_cmd(IL3820_CMD_SLEEP_MODE, data, 1);
}
/* TODO: Remove the busy waiting */
static void il3820_waitbusy(int wait_ms)
{
int i = 0;
vTaskDelay(10 / portTICK_RATE_MS); // 10ms delay
for(i = 0; i < (wait_ms * 10); i++) {
if(gpio_get_level(IL3820_BUSY_PIN) != IL3820_BUSY_LEVEL) {
return;
}
vTaskDelay(10 / portTICK_RATE_MS);
}
ESP_LOGE( TAG, "busy exceeded %dms", i*10 );
}
/* Set DC signal to command mode */
static inline void il3820_command_mode(void)
{
gpio_set_level(IL3820_DC_PIN, 0);
}
/* Set DC signal to data mode */
static inline void il3820_data_mode(void)
{
gpio_set_level(IL3820_DC_PIN, 1);
}
static inline void il3820_write_cmd(uint8_t cmd, uint8_t *data, size_t len)
{
disp_wait_for_pending_transactions();
il3820_command_mode();
disp_spi_send_data(&cmd, 1);
if (data != NULL) {
il3820_data_mode();
disp_spi_send_data(data, len);
}
}
/* Send cmd to the display */
static inline void il3820_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
il3820_command_mode();
disp_spi_send_data(&cmd, 1);
}
/* Send length bytes of data to the display */
static void il3820_send_data(uint8_t *data, uint16_t length)
{
disp_wait_for_pending_transactions();
il3820_data_mode();
disp_spi_send_colors(data, length);
}
/* Specify the start/end positions of the window address in the X and Y
* directions by an address unit.
*
* @param sx: X Start position.
* @param ex: X End position.
* @param ys: Y Start position.
* @param ye: Y End position.
*/
static inline void il3820_set_window( uint16_t sx, uint16_t ex, uint16_t ys, uint16_t ye)
{
uint8_t tmp[4] = {0};
tmp[0] = sx / 8;
tmp[1] = ex / 8;
/* Set X address start/end */
il3820_write_cmd(IL3820_CMD_RAM_XPOS_CTRL, tmp, 2);
tmp[0] = ys % 256;
tmp[1] = ys / 256;
tmp[2] = ye % 256;
tmp[3] = ye / 256;
/* Set Y address start/end */
il3820_write_cmd(IL3820_CMD_RAM_YPOS_CTRL, tmp, 4);
}
/* Make initial settings for the RAM X and Y addresses in the address counter
* (AC).
*
* @param sx: RAM X address counter.
* @param ys: RAM Y address counter.
*/
static inline void il3820_set_cursor(uint16_t sx, uint16_t ys)
{
uint8_t tmp[2] = {0};
tmp[0] = sx / 8;
il3820_write_cmd(IL3820_CMD_RAM_XPOS_CNTR, tmp, 1);
tmp[0] = ys % 256;
tmp[1] = ys / 256;
il3820_write_cmd(IL3820_CMD_RAM_YPOS_CNTR, tmp, 2);
}
/* After sending the RAM content we need to send the commands:
* - Display Update Control 2
* - Master Activation
*
* NOTE: Currently we poll for the BUSY signal to go inactive,
* we might want not to do it. */
static void il3820_update_display(void)
{
uint8_t tmp = 0;
if(il3820_partial) {
tmp = IL3820_CTRL2_TO_PATTERN;
} else {
tmp = (IL3820_CTRL2_ENABLE_CLK | IL3820_CTRL2_ENABLE_ANALOG | IL3820_CTRL2_TO_PATTERN);
}
il3820_write_cmd(IL3820_CMD_UPDATE_CTRL2, &tmp, 1);
il3820_write_cmd(IL3820_CMD_MASTER_ACTIVATION, NULL, 0);
/* Poll BUSY signal. */
il3820_waitbusy(IL3820_WAIT);
/* XXX: Figure out what does this command do. */
il3820_write_cmd(IL3820_CMD_TERMINATE_FRAME_RW, NULL, 0);
}
/* Clear the graphic RAM. */
static void il3820_clear_cntlr_mem(uint8_t ram_cmd, bool update)
{
/* Arrays used by SPI must be word alligned */
WORD_ALIGNED_ATTR uint8_t clear_page[IL3820_COLUMNS];
memset(clear_page, 0xff, sizeof clear_page);
/* Configure entry mode */
il3820_write_cmd(IL3820_CMD_ENTRY_MODE, &il3820_scan_mode, 1);
/* Configure the window */
il3820_set_window(0, EPD_PANEL_WIDTH - 1, 0, EPD_PANEL_HEIGHT - 1);
/* Send clear_page buffer to the display */
for(int j = 0; j < EPD_PANEL_HEIGHT; j++) {
il3820_set_cursor(0, j);
il3820_write_cmd(ram_cmd, clear_page, sizeof clear_page);
}
if (update) {
il3820_set_window( 0, EPD_PANEL_WIDTH - 1, 0, EPD_PANEL_HEIGHT - 1);
il3820_update_display();
}
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/il3820.c | C | apache-2.0 | 12,863 |
/**
* @file il3820.h
*
*/
#ifndef IL3820_H
#define IL3820_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "sdkconfig.h"
/* Values for Waveshare 2.9inch e-Paper Module, this values shouldn't be
* swapped to change display orientation */
#define EPD_PANEL_WIDTH LV_HOR_RES_MAX /* 128 */
#define EPD_PANEL_HEIGHT LV_VER_RES_MAX /* 296 */
/* 128 = panel width */
#define IL3820_COLUMNS (EPD_PANEL_WIDTH / 8)
#define IL3820_DC_PIN CONFIG_LV_DISP_PIN_DC
#define IL3820_RST_PIN CONFIG_LV_DISP_PIN_RST
#define IL3820_USE_RST CONFIG_LV_DISP_USE_RST
#define IL3820_BUSY_PIN CONFIG_LV_DISP_PIN_BUSY
#define IL3820_BUSY_LEVEL 1
/* IL3820 commands */
#define IL3820_CMD_GDO_CTRL 0x01
#define IL3820_CMD_GDV_CTRL 0x03
#define IL3820_CMD_SDV_CTRL 0x04
#define IL3820_CMD_SOFTSTART 0x0c
#define IL3820_CMD_GSCAN_START 0x0f
#define IL3820_CMD_SLEEP_MODE 0x10
#define IL3820_CMD_ENTRY_MODE 0x11
#define IL3820_CMD_SW_RESET 0x12
#define IL3820_CMD_TSENS_CTRL 0x1a
#define IL3820_CMD_MASTER_ACTIVATION 0x20
#define IL3820_CMD_UPDATE_CTRL1 0x21
#define IL3820_CMD_UPDATE_CTRL2 0x22
#define IL3820_CMD_WRITE_RAM 0x24
#define IL3820_CMD_WRITE_RED_RAM 0x26
#define IL3820_CMD_VCOM_SENSE 0x28
#define IL3820_CMD_VCOM_SENSE_DURATON 0x29
#define IL3820_CMD_PRGM_VCOM_OTP 0x2a
#define IL3820_CMD_VCOM_VOLTAGE 0x2c
#define IL3820_CMD_PRGM_WS_OTP 0x30
#define IL3820_CMD_UPDATE_LUT 0x32
#define IL3820_CMD_PRGM_OTP_SELECTION 0x36
#define IL3820_CMD_OTP_SELECTION_CTRL 0x37
#define IL3820_CMD_DUMMY_LINE 0x3a
#define IL3820_CMD_GATE_LINE_WIDTH 0x3b
#define IL3820_CMD_BWF_CTRL 0x3c
#define IL3820_CMD_RAM_XPOS_CTRL 0x44
#define IL3820_CMD_RAM_YPOS_CTRL 0x45
#define IL3820_CMD_RAM_XPOS_CNTR 0x4e
#define IL3820_CMD_RAM_YPOS_CNTR 0x4f
#define IL3820_CMD_TERMINATE_FRAME_RW 0xff
/* Data entry sequence modes */
#define IL3820_DATA_ENTRY_MASK 0x07
#define IL3820_DATA_ENTRY_XDYDX 0x00
#define IL3820_DATA_ENTRY_XIYDX 0x01
#define IL3820_DATA_ENTRY_XDYIX 0x02
#define IL3820_DATA_ENTRY_XIYIX 0x03
#define IL3820_DATA_ENTRY_XDYDY 0x04
#define IL3820_DATA_ENTRY_XIYDY 0x05
#define IL3820_DATA_ENTRY_XDYIY 0x06
#define IL3820_DATA_ENTRY_XIYIY 0x07
/* Options for display update */
#define IL3820_CTRL1_INITIAL_UPDATE_LL 0x00
#define IL3820_CTRL1_INITIAL_UPDATE_LH 0x01
#define IL3820_CTRL1_INITIAL_UPDATE_HL 0x02
#define IL3820_CTRL1_INITIAL_UPDATE_HH 0x03
/* Options for display update sequence */
#define IL3820_CTRL2_ENABLE_CLK 0x80
#define IL3820_CTRL2_ENABLE_ANALOG 0x40
#define IL3820_CTRL2_TO_INITIAL 0x08
#define IL3820_CTRL2_TO_PATTERN 0x04
#define IL3820_CTRL2_DISABLE_ANALOG 0x02
#define IL3820_CTRL2_DISABLE_CLK 0x01
#define IL3820_SLEEP_MODE_DSM 0x01
#define IL3820_SLEEP_MODE_PON 0x00
/* time constants in ms */
#define IL3820_RESET_DELAY 20
#define IL3820_BUSY_DELAY 1
// normal wait time max 200ms
#define IL3820_WAIT 20
void il3820_init(void);
void il3820_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
void il3820_fullflush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
void il3820_rounder(lv_disp_drv_t * disp_drv, lv_area_t *area);
void il3820_set_px_cb(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa);
void il3820_sleep_in(void);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __IL3820_REGS_H__ */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/il3820.h | C | apache-2.0 | 3,572 |
/**
* @file ILI9163C.c
*
*/
/*********************
* INCLUDES
*********************/
#include "ili9163c.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "assert.h"
/*********************
* DEFINES
*********************/
#define TAG "ILI9163C"
// ILI9163C specific commands used in init
#define ILI9163C_NOP 0x00
#define ILI9163C_SWRESET 0x01
#define ILI9163C_RDDID 0x04
#define ILI9163C_RDDST 0x09
#define ILI9163C_SLPIN 0x10
#define ILI9163C_SLPOUT 0x11
#define ILI9163C_PTLON 0x12
#define ILI9163C_NORON 0x13
#define ILI9163C_INVOFF 0x20
#define ILI9163C_INVON 0x21
#define ILI9163C_CMD_GAMST 0x26
#define ILI9163C_DISPOFF 0x28
#define ILI9163C_DISPON 0x29
#define ILI9163C_CASET 0x2A
#define ILI9163C_RASET 0x2B
#define ILI9163C_RAMWR 0x2C
#define ILI9163C_COLORSET 0x2D
#define ILI9163C_RAMRD 0x2E
#define ILI9163C_PTLAR 0x30
#define ILI9163C_VSCRDEF 0x33
#define ILI9163C_COLMOD 0x3A
#define ILI9163C_MADCTL 0x36
#define ILI9163C_VSCRSADD 0x37
#define ILI9163C_FRMCTR1 0xB1
#define ILI9163C_FRMCTR2 0xB2
#define ILI9163C_FRMCTR3 0xB3
#define ILI9163C_INVCTR 0xB4
#define ILI9163C_DISSET5 0xB6
#define ILI9163C_SDDC 0xB7
#define ILI9163C_PWCTR1 0xC0
#define ILI9163C_PWCTR2 0xC1
#define ILI9163C_PWCTR3 0xC2
#define ILI9163C_PWCTR4 0xC3
#define ILI9163C_PWCTR5 0xC4
#define ILI9163C_VMCTR1 0xC5
#define ILI9163C_VMCOFFS 0xC7
#define ILI9163C_GAMCTL 0xF2
#define ILI9163C_GMCTRP1 0xE0
#define ILI9163C_GMCTRN1 0xE1
#define ST77XX_MADCTL_MY 0x80
#define ST77XX_MADCTL_MX 0x40
#define ST77XX_MADCTL_MV 0x20 #define
#define ST77XX_MADCTL_ML 0x10
#define ST77XX_MADCTL_RGB 0x00
#define ST77XX_MADCTL_BGR 0x08
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct
{
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void ili9163c_set_orientation(uint8_t orientation);
static void ili9163c_send_cmd(uint8_t cmd);
static void ili9163c_send_data(void *data, uint16_t length);
static void ili9163c_send_color(void *data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ili9163c_init(void)
{
ESP_LOGD(TAG, "Init");
lcd_init_cmd_t ili_init_cmds[] = {
{ILI9163C_SWRESET, {0}, 0x80}, // Software reset, 0 args, w/delay 120ms
{ILI9163C_SLPOUT, {0}, 0x80}, // Out of sleep mode, 0 args, w/delay 5ms
{ILI9163C_CMD_GAMST, {0x04}, 1}, // Gamma Curve
{ILI9163C_FRMCTR1, {0x0C, 0x14}, 2}, // Frame rate ctrl - normal mode
{ILI9163C_INVCTR, {0x07}, 1}, // Display inversion ctrl, 1 arg, no delay:No inversion
{ILI9163C_PWCTR1, {0x0C, 0x05}, 2}, // Power control, 2 args, no delay
{ILI9163C_PWCTR2, {0x02}, 1}, // Power control, 1 arg
{ILI9163C_PWCTR3, {0x02}, 1}, // Power control, 1 arg
{ILI9163C_VMCTR1, {0x20, 0x55}, 2}, // Power control, 1 arg, no delay:
{ILI9163C_VMCOFFS, {0x40}, 1}, // VCOM Offset
#if ILI9163C_INVERT_COLORS == 1
{ILI9163C_INVON, {0}, 0}, // set inverted mode
#else
{ILI9163C_INVOFF, {0}, 0}, // set non-inverted mode
#endif
{ILI9163C_COLMOD, {0x5}, 1}, // set color mode, 1 arg, no delay: 16-bit color
{ILI9163C_SDDC, {0}, 1}, // set source driver direction control
{ILI9163C_GAMCTL, {0x01}, 1}, // set source driver direction control
{ILI9163C_GMCTRP1, {0x36, 0x29, 0x12, 0x22, 0x1C, 0x15, 0x42, 0xB7, 0x2F, 0x13, 0x12, 0x0A, 0x11, 0x0B, 0x06}, 16}, // 16 args, no delay:
{ILI9163C_GMCTRN1, {0x09, 0x16, 0x2D, 0x0D, 0x13, 0x15, 0x40, 0x48, 0x53, 0x0C, 0x1D, 0x25, 0x2E, 0x34, 0x39}, 16}, // 16 args, no delay:
{ILI9163C_NORON, {0}, 0x80}, // Normal display on, no args, w/delay 10 ms delay
{ILI9163C_DISPON, {0}, 0x80}, // Main screen turn on, no args w/delay 100 ms delay
{0, {0}, 0xff}
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ILI9163C_DC);
gpio_set_direction(ILI9163C_DC, GPIO_MODE_OUTPUT);
gpio_pad_select_gpio(ILI9163C_RST);
gpio_set_direction(ILI9163C_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ILI9163C_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ILI9163C_RST, 1);
vTaskDelay(150 / portTICK_RATE_MS);
//Send all the commands
uint16_t cmd = 0;
while (ili_init_cmds[cmd].databytes != 0xff)
{
ili9163c_send_cmd(ili_init_cmds[cmd].cmd);
ili9163c_send_data(ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes & 0x1F);
if (ili_init_cmds[cmd].databytes & 0x80)
{
vTaskDelay(150 / portTICK_RATE_MS);
}
cmd++;
}
ili9163c_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
}
void ili9163c_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
uint8_t data[4];
/*Column addresses*/
ili9163c_send_cmd(ILI9163C_CASET);
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = area->x1 & 0xFF;
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = area->x2 & 0xFF;
ili9163c_send_data(data, 4);
/*Page addresses*/
ili9163c_send_cmd(ILI9163C_RASET);
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = area->y1 & 0xFF;
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = area->y2 & 0xFF;
ili9163c_send_data(data, 4);
/*Memory write*/
ili9163c_send_cmd(ILI9163C_RAMWR);
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
ili9163c_send_color((void *)color_map, size * 2);
}
void ili9163c_sleep_in()
{
uint8_t data[] = {0x08};
ili9163c_send_cmd(ILI9163C_SLPIN);
ili9163c_send_data(&data, 1);
}
void ili9163c_sleep_out()
{
uint8_t data[] = {0x08};
ili9163c_send_cmd(ILI9163C_SLPOUT);
ili9163c_send_data(&data, 1);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ili9163c_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9163C_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void ili9163c_send_data(void *data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9163C_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void ili9163c_send_color(void *data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9163C_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void ili9163c_set_orientation(uint8_t orientation)
{
assert(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"};
ESP_LOGD(TAG, "Display orientation: %s", orientation_str[orientation]);
uint8_t data[] = {0x48, 0x88, 0xA8, 0x68};
ili9163c_send_cmd(ILI9163C_MADCTL);
ili9163c_send_data((void *)&data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9163c.c | C | apache-2.0 | 6,943 |
/**
* @file lv_templ.h
*
*/
#ifndef ILI9163C_H
#define ILI9163C_H
#ifdef __cplusplus
extern "C"
{
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define ILI9163C_DC CONFIG_LV_DISP_PIN_DC
#define ILI9163C_RST CONFIG_LV_DISP_PIN_RST
#define ILI9163C_INVERT_COLORS CONFIG_LV_INVERT_COLORS
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ili9163c_init(void);
void ili9163c_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
void ili9163c_sleep_in(void);
void ili9163c_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ILI9163C_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9163c.h | C | apache-2.0 | 985 |
/**
* @file ili9341.c
*
*/
/*********************
* INCLUDES
*********************/
#include "ili9341.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "ILI9341"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void ili9341_set_orientation(uint8_t orientation);
static void ili9341_send_cmd(uint8_t cmd);
static void ili9341_send_data(void * data, uint16_t length);
static void ili9341_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ili9341_init(void)
{
lcd_init_cmd_t ili_init_cmds[]={
{0xCF, {0x00, 0x83, 0X30}, 3},
{0xED, {0x64, 0x03, 0X12, 0X81}, 4},
{0xE8, {0x85, 0x01, 0x79}, 3},
{0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02}, 5},
{0xF7, {0x20}, 1},
{0xEA, {0x00, 0x00}, 2},
{0xC0, {0x26}, 1}, /*Power control*/
{0xC1, {0x11}, 1}, /*Power control */
{0xC5, {0x35, 0x3E}, 2}, /*VCOM control*/
{0xC7, {0xBE}, 1}, /*VCOM control*/
{0x36, {0x28}, 1}, /*Memory Access Control*/
{0x3A, {0x55}, 1}, /*Pixel Format Set*/
{0xB1, {0x00, 0x1B}, 2},
{0xF2, {0x08}, 1},
{0x26, {0x01}, 1},
{0xE0, {0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00}, 15},
{0XE1, {0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F}, 15},
{0x2A, {0x00, 0x00, 0x00, 0xEF}, 4},
{0x2B, {0x00, 0x00, 0x01, 0x3f}, 4},
{0x2C, {0}, 0},
{0xB7, {0x07}, 1},
{0xB6, {0x0A, 0x82, 0x27, 0x00}, 4},
{0x11, {0}, 0x80},
{0x29, {0}, 0x80},
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ILI9341_DC);
gpio_set_direction(ILI9341_DC, GPIO_MODE_OUTPUT);
#if ILI9341_USE_RST
gpio_pad_select_gpio(ILI9341_RST);
gpio_set_direction(ILI9341_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ILI9341_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ILI9341_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "Initialization.");
//Send all the commands
uint16_t cmd = 0;
while (ili_init_cmds[cmd].databytes!=0xff) {
ili9341_send_cmd(ili_init_cmds[cmd].cmd);
ili9341_send_data(ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes&0x1F);
if (ili_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
ili9341_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
#if ILI9341_INVERT_COLORS == 1
ili9341_send_cmd(0x21);
#else
ili9341_send_cmd(0x20);
#endif
}
void ili9341_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t data[4];
/*Column addresses*/
ili9341_send_cmd(0x2A);
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = area->x1 & 0xFF;
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = area->x2 & 0xFF;
ili9341_send_data(data, 4);
/*Page addresses*/
ili9341_send_cmd(0x2B);
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = area->y1 & 0xFF;
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = area->y2 & 0xFF;
ili9341_send_data(data, 4);
/*Memory write*/
ili9341_send_cmd(0x2C);
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
ili9341_send_color((void*)color_map, size * 2);
}
void ili9341_sleep_in()
{
uint8_t data[] = {0x08};
ili9341_send_cmd(0x10);
ili9341_send_data(&data, 1);
}
void ili9341_sleep_out()
{
uint8_t data[] = {0x08};
ili9341_send_cmd(0x11);
ili9341_send_data(&data, 1);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ili9341_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9341_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void ili9341_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9341_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void ili9341_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9341_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void ili9341_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
#if defined CONFIG_LV_PREDEFINED_DISPLAY_M5STACK
uint8_t data[] = {0x68, 0x68, 0x08, 0x08};
#elif defined (CONFIG_LV_PREDEFINED_DISPLAY_M5CORE2)
uint8_t data[] = {0x08, 0x88, 0x28, 0xE8};
#elif defined (CONFIG_LV_PREDEFINED_DISPLAY_WROVER4)
uint8_t data[] = {0x6C, 0xEC, 0xCC, 0x4C};
#elif defined (CONFIG_LV_PREDEFINED_DISPLAY_NONE)
uint8_t data[] = {0x48, 0x88, 0x28, 0xE8};
#endif
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
ili9341_send_cmd(0x36);
ili9341_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9341.c | C | apache-2.0 | 5,519 |
/**
* @file lv_templ.h
*
*/
#ifndef ILI9341_H
#define ILI9341_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "sdkconfig.h"
/*********************
* DEFINES
*********************/
#define ILI9341_DC CONFIG_LV_DISP_PIN_DC
#define ILI9341_USE_RST CONFIG_LV_DISP_USE_RST
#define ILI9341_RST CONFIG_LV_DISP_PIN_RST
#define ILI9341_INVERT_COLORS CONFIG_LV_INVERT_COLORS
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ili9341_init(void);
void ili9341_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void ili9341_sleep_in(void);
void ili9341_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ILI9341_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9341.h | C | apache-2.0 | 1,015 |
/**
* @file ili9481.c
*/
/*********************
* INCLUDES
*********************/
#include "ili9481.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "ILI9481"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void ili9481_set_orientation(uint8_t orientation);
static void ili9481_send_cmd(uint8_t cmd);
static void ili9481_send_data(void * data, uint16_t length);
static void ili9481_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ili9481_init(void)
{
lcd_init_cmd_t ili_init_cmds[]={
{ILI9481_CMD_SLEEP_OUT, {0x00}, 0x80},
{ILI9481_CMD_POWER_SETTING, {0x07, 0x42, 0x18}, 3},
{ILI9481_CMD_VCOM_CONTROL, {0x00, 0x07, 0x10}, 3},
{ILI9481_CMD_POWER_CONTROL_NORMAL, {0x01, 0x02}, 2},
{ILI9481_CMD_PANEL_DRIVE, {0x10, 0x3B, 0x00, 0x02, 0x11}, 5},
{ILI9481_CMD_FRAME_RATE, {0x03}, 1},
{ILI9481_CMD_FRAME_MEMORY_ACCESS, {0x0, 0x0, 0x0, 0x0}, 4},
//{ILI9481_CMD_DISP_TIMING_NORMAL, {0x10, 0x10, 0x22}, 3},
{ILI9481_CMD_GAMMA_SETTING, {0x00, 0x32, 0x36, 0x45, 0x06, 0x16, 0x37, 0x75, 0x77, 0x54, 0x0C, 0x00}, 12},
{ILI9481_CMD_MEMORY_ACCESS_CONTROL, {0x0A}, 1},
#if ILI9481_INVERT_COLORS
{ILI9481_CMD_DISP_INVERSION_ON, {}, 0},
#endif
{ILI9481_CMD_COLMOD_PIXEL_FORMAT_SET, {0x66}, 1},
{ILI9481_CMD_NORMAL_DISP_MODE_ON, {}, 0x80},
{ILI9481_CMD_DISPLAY_ON, {}, 0x80},
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ILI9481_DC);
gpio_set_direction(ILI9481_DC, GPIO_MODE_OUTPUT);
#if ILI9481_USE_RST
gpio_pad_select_gpio(ILI9481_RST);
gpio_set_direction(ILI9481_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ILI9481_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ILI9481_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "ILI9481 initialization.");
// Exit sleep
ili9481_send_cmd(0x01); /* Software reset */
vTaskDelay(100 / portTICK_RATE_MS);
//Send all the commands
uint16_t cmd = 0;
while (ili_init_cmds[cmd].databytes!=0xff) {
ili9481_send_cmd(ili_init_cmds[cmd].cmd);
ili9481_send_data(ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes&0x1F);
if (ili_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
ili9481_set_orientation(ILI9481_DISPLAY_ORIENTATION);
}
// Flush function based on mvturnho repo
void ili9481_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
lv_color16_t *buffer_16bit = (lv_color16_t *) color_map;
uint8_t *mybuf;
do {
mybuf = (uint8_t *) heap_caps_malloc(3 * size * sizeof(uint8_t), MALLOC_CAP_DMA);
if (mybuf == NULL) ESP_LOGW(TAG, "Could not allocate enough DMA memory!");
} while (mybuf == NULL);
uint32_t LD = 0;
uint32_t j = 0;
for (uint32_t i = 0; i < size; i++) {
LD = buffer_16bit[i].full;
mybuf[j] = (uint8_t) (((LD & 0xF800) >> 8) | ((LD & 0x8000) >> 13));
j++;
mybuf[j] = (uint8_t) ((LD & 0x07E0) >> 3);
j++;
mybuf[j] = (uint8_t) (((LD & 0x001F) << 3) | ((LD & 0x0010) >> 2));
j++;
}
/* Column addresses */
uint8_t xb[] = {
(uint8_t) (area->x1 >> 8) & 0xFF,
(uint8_t) (area->x1) & 0xFF,
(uint8_t) (area->x2 >> 8) & 0xFF,
(uint8_t) (area->x2) & 0xFF,
};
/* Page addresses */
uint8_t yb[] = {
(uint8_t) (area->y1 >> 8) & 0xFF,
(uint8_t) (area->y1) & 0xFF,
(uint8_t) (area->y2 >> 8) & 0xFF,
(uint8_t) (area->y2) & 0xFF,
};
/*Column addresses*/
ili9481_send_cmd(ILI9481_CMD_COLUMN_ADDRESS_SET);
ili9481_send_data(xb, 4);
/*Page addresses*/
ili9481_send_cmd(ILI9481_CMD_PAGE_ADDRESS_SET);
ili9481_send_data(yb, 4);
/*Memory write*/
ili9481_send_cmd(ILI9481_CMD_MEMORY_WRITE);
ili9481_send_color((void *) mybuf, size * 3);
heap_caps_free(mybuf);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ili9481_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9481_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void ili9481_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9481_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void ili9481_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9481_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void ili9481_set_orientation(uint8_t orientation)
{
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
uint8_t data[] = {0x48, 0x4B, 0x28, 0x2B};
ili9481_send_cmd(ILI9481_CMD_MEMORY_ACCESS_CONTROL);
ili9481_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9481.c | C | apache-2.0 | 5,903 |
/**
* @file ili9481.h
*/
#ifndef ILI9481_H
#define ILI9481_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include <stdint.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define ILI9481_DC CONFIG_LV_DISP_PIN_DC
#define ILI9481_RST CONFIG_LV_DISP_PIN_RST
#define ILI9481_USE_RST CONFIG_LV_DISP_USE_RST
#define ILI9481_INVERT_COLORS CONFIG_LV_INVERT_COLORS
#define ILI9481_DISPLAY_ORIENTATION CONFIG_LV_DISPLAY_ORIENTATION
/*******************
* ILI9481 REGS
*********************/
/* MIPI DCS Type1 */
#define ILI9481_CMD_NOP 0x00
#define ILI9481_CMD_SOFTWARE_RESET 0x01
#define ILI9481_CMD_READ_DISP_POWER_MODE 0x0A
#define ILI9481_CMD_READ_DISP_MADCTRL 0x0B // bits 7:3 only
#define ILI9481_CMD_READ_DISP_PIXEL_FORMAT 0x0C
#define ILI9481_CMD_READ_DISP_IMAGE_MODE 0x0D
#define ILI9481_CMD_READ_DISP_SIGNAL_MODE 0x0E
#define ILI9481_CMD_READ_DISP_SELF_DIAGNOSTIC 0x0F // bits 7:6 only
#define ILI9481_CMD_ENTER_SLEEP_MODE 0x10
#define ILI9481_CMD_SLEEP_OUT 0x11
#define ILI9481_CMD_PARTIAL_MODE_ON 0x12
#define ILI9481_CMD_NORMAL_DISP_MODE_ON 0x13
#define ILI9481_CMD_DISP_INVERSION_OFF 0x20
#define ILI9481_CMD_DISP_INVERSION_ON 0x21
#define ILI9481_CMD_DISPLAY_OFF 0x28
#define ILI9481_CMD_DISPLAY_ON 0x29
#define ILI9481_CMD_COLUMN_ADDRESS_SET 0x2A
#define ILI9481_CMD_PAGE_ADDRESS_SET 0x2B
#define ILI9481_CMD_MEMORY_WRITE 0x2C
#define ILI9481_CMD_MEMORY_READ 0x2E
#define ILI9481_CMD_PARTIAL_AREA 0x30
#define ILI9481_CMD_VERT_SCROLL_DEFINITION 0x33
#define ILI9481_CMD_TEARING_EFFECT_LINE_OFF 0x34
#define ILI9481_CMD_TEARING_EFFECT_LINE_ON 0x35
#define ILI9481_CMD_MEMORY_ACCESS_CONTROL 0x36 // bits 7:3,1:0 only
#define ILI9481_CMD_VERT_SCROLL_START_ADDRESS 0x37
#define ILI9481_CMD_IDLE_MODE_OFF 0x38
#define ILI9481_CMD_IDLE_MODE_ON 0x39
#define ILI9481_CMD_COLMOD_PIXEL_FORMAT_SET 0x3A
#define ILI9481_CMD_WRITE_MEMORY_CONTINUE 0x3C
#define ILI9481_CMD_READ_MEMORY_CONTINUE 0x3E
#define ILI9481_CMD_SET_TEAR_SCANLINE 0x44
#define ILI9481_CMD_GET_SCANLINE 0x45
#define ILI9481_DDB_START 0xA1
#define ILI9481_DDB_CONTINUE 0xA8
/* other */
#define ILI9481_CMD_ACCESS_PROTECT 0xB0
#define ILI9481_CMD_LOW_POWER_CONTROL 0xB1
#define ILI9481_CMD_FRAME_MEMORY_ACCESS 0xB3
#define ILI9481_CMD_DISPLAY_MODE 0xB4
#define ILI9481_CMD_DEVICE_CODE 0xBF
#define ILI9481_CMD_PANEL_DRIVE 0xC0
#define ILI9481_CMD_DISP_TIMING_NORMAL 0xC1
#define ILI9481_CMD_DISP_TIMING_PARTIAL 0xC2
#define ILI9481_CMD_DISP_TIMING_IDLE 0xC3
#define ILI9481_CMD_FRAME_RATE 0xC5
#define ILI9481_CMD_INTERFACE_CONTROL 0xC6
#define ILI9481_CMD_GAMMA_SETTING 0xC8
#define ILI9481_CMD_POWER_SETTING 0xD0
#define ILI9481_CMD_VCOM_CONTROL 0xD1
#define ILI9481_CMD_POWER_CONTROL_NORMAL 0xD2
#define ILI9481_CMD_POWER_CONTROL_IDEL 0xD3
#define ILI9481_CMD_POWER_CONTROL_PARTIAL 0xD4
#define ILI9481_CMD_NVMEM_WRITE 0xE0
#define ILI9481_CMD_NVMEM_PROTECTION_KEY 0xE1
#define ILI9481_CMD_NVMEM_STATUS_READ 0xE2
#define ILI9481_CMD_NVMEM_PROTECTION 0xE3
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ili9481_init(void);
void ili9481_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ILI9481_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9481.h | C | apache-2.0 | 4,436 |
/**
* @file mpi3501.c
*
*/
/*********************
* INCLUDES
*********************/
#include "ili9486.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "ILI9486"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void ili9486_set_orientation(uint8_t orientation);
static void ili9486_send_cmd(uint8_t cmd);
static void ili9486_send_data(void * data, uint16_t length);
static void ili9486_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ili9486_init(void)
{
lcd_init_cmd_t ili_init_cmds[]={
{0x11, {0}, 0x80},
{0x3A, {0x55}, 1},
{0x2C, {0x44}, 1},
{0xC5, {0x00, 0x00, 0x00, 0x00}, 4},
{0xE0, {0x0F, 0x1F, 0x1C, 0x0C, 0x0F, 0x08, 0x48, 0x98, 0x37, 0x0A, 0x13, 0x04, 0x11, 0x0D, 0x00}, 15},
{0XE1, {0x0F, 0x32, 0x2E, 0x0B, 0x0D, 0x05, 0x47, 0x75, 0x37, 0x06, 0x10, 0x03, 0x24, 0x20, 0x00}, 15},
{0x20, {0}, 0}, /* display inversion OFF */
{0x36, {0x48}, 1},
{0x29, {0}, 0x80}, /* display on */
{0x00, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ILI9486_DC);
gpio_set_direction(ILI9486_DC, GPIO_MODE_OUTPUT);
#if ILI9486_USE_RST
gpio_pad_select_gpio(ILI9486_RST);
gpio_set_direction(ILI9486_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ILI9486_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ILI9486_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "ILI9486 Initialization.");
//Send all the commands
uint16_t cmd = 0;
while (ili_init_cmds[cmd].databytes!=0xff) {
ili9486_send_cmd(ili_init_cmds[cmd].cmd);
ili9486_send_data(ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes&0x1F);
if (ili_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
ili9486_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
}
void ili9486_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t data[4] = {0};
uint32_t size = 0;
/*Column addresses*/
ili9486_send_cmd(0x2A);
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = area->x1 & 0xFF;
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = area->x2 & 0xFF;
ili9486_send_data(data, 4);
/*Page addresses*/
ili9486_send_cmd(0x2B);
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = area->y1 & 0xFF;
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = area->y2 & 0xFF;
ili9486_send_data(data, 4);
/*Memory write*/
ili9486_send_cmd(0x2C);
size = lv_area_get_width(area) * lv_area_get_height(area);
ili9486_send_color((void*) color_map, size * 2);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ili9486_send_cmd(uint8_t cmd)
{
uint8_t to16bit[] = {
0x00, cmd
};
disp_wait_for_pending_transactions();
gpio_set_level(ILI9486_DC, 0); /*Command mode*/
disp_spi_send_data(to16bit, sizeof to16bit);
}
static void ili9486_send_data(void * data, uint16_t length)
{
uint32_t i;
uint8_t to16bit[32];
uint8_t * dummy = data;
for(i=0; i < (length); i++)
{
to16bit[2*i+1] = dummy[i];
to16bit[2*i] = 0x00;
}
disp_wait_for_pending_transactions();
gpio_set_level(ILI9486_DC, 1); /*Data mode*/
disp_spi_send_data(to16bit, (length*2));
}
static void ili9486_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9486_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void ili9486_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
#if defined (CONFIG_LV_PREDEFINED_DISPLAY_NONE)
uint8_t data[] = {0x48, 0x88, 0x28, 0xE8};
#endif
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
ili9486_send_cmd(0x36);
ili9486_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9486.c | C | apache-2.0 | 4,604 |
/**
* @file ili9486.h
*
*/
#ifndef ILI9486_H
#define ILI9486_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define ILI9486_DC CONFIG_LV_DISP_PIN_DC
#define ILI9486_RST CONFIG_LV_DISP_PIN_RST
#define ILI9486_USE_RST CONFIG_LV_DISP_USE_RST
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ili9486_init(void);
void ili9486_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* ILI9486_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9486.h | C | apache-2.0 | 902 |
/**
* @file ili9488.c
*/
/*********************
* INCLUDES
*********************/
#include "ili9488.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "ILI9488"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void ili9488_set_orientation(uint8_t orientation);
static void ili9488_send_cmd(uint8_t cmd);
static void ili9488_send_data(void * data, uint16_t length);
static void ili9488_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
// From github.com/jeremyjh/ESP32_TFT_library
// From github.com/mvturnho/ILI9488-lvgl-ESP32-WROVER-B
void ili9488_init(void)
{
lcd_init_cmd_t ili_init_cmds[]={
{ILI9488_CMD_SLEEP_OUT, {0x00}, 0x80},
{ILI9488_CMD_POSITIVE_GAMMA_CORRECTION, {0x00, 0x03, 0x09, 0x08, 0x16, 0x0A, 0x3F, 0x78, 0x4C, 0x09, 0x0A, 0x08, 0x16, 0x1A, 0x0F}, 15},
{ILI9488_CMD_NEGATIVE_GAMMA_CORRECTION, {0x00, 0x16, 0x19, 0x03, 0x0F, 0x05, 0x32, 0x45, 0x46, 0x04, 0x0E, 0x0D, 0x35, 0x37, 0x0F}, 15},
{ILI9488_CMD_POWER_CONTROL_1, {0x17, 0x15}, 2},
{ILI9488_CMD_POWER_CONTROL_2, {0x41}, 1},
{ILI9488_CMD_VCOM_CONTROL_1, {0x00, 0x12, 0x80}, 3},
{ILI9488_CMD_MEMORY_ACCESS_CONTROL, {(0x20 | 0x08)}, 1},
{ILI9488_CMD_COLMOD_PIXEL_FORMAT_SET, {0x66}, 1},
{ILI9488_CMD_INTERFACE_MODE_CONTROL, {0x00}, 1},
{ILI9488_CMD_FRAME_RATE_CONTROL_NORMAL, {0xA0}, 1},
{ILI9488_CMD_DISPLAY_INVERSION_CONTROL, {0x02}, 1},
{ILI9488_CMD_DISPLAY_FUNCTION_CONTROL, {0x02, 0x02}, 2},
{ILI9488_CMD_SET_IMAGE_FUNCTION, {0x00}, 1},
{ILI9488_CMD_WRITE_CTRL_DISPLAY, {0x28}, 1},
{ILI9488_CMD_WRITE_DISPLAY_BRIGHTNESS, {0x7F}, 1},
{ILI9488_CMD_ADJUST_CONTROL_3, {0xA9, 0x51, 0x2C, 0x02}, 4},
{ILI9488_CMD_DISPLAY_ON, {0x00}, 0x80},
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ILI9488_DC);
gpio_set_direction(ILI9488_DC, GPIO_MODE_OUTPUT);
#if ILI9488_USE_RST
gpio_pad_select_gpio(ILI9488_RST);
gpio_set_direction(ILI9488_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ILI9488_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ILI9488_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "ILI9488 initialization.");
// Exit sleep
ili9488_send_cmd(0x01); /* Software reset */
vTaskDelay(100 / portTICK_RATE_MS);
//Send all the commands
uint16_t cmd = 0;
while (ili_init_cmds[cmd].databytes!=0xff) {
ili9488_send_cmd(ili_init_cmds[cmd].cmd);
ili9488_send_data(ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes&0x1F);
if (ili_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
ili9488_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
}
// Flush function based on mvturnho repo
void ili9488_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
lv_color16_t *buffer_16bit = (lv_color16_t *) color_map;
uint8_t *mybuf;
do {
mybuf = (uint8_t *) heap_caps_malloc(3 * size * sizeof(uint8_t), MALLOC_CAP_DMA);
if (mybuf == NULL) ESP_LOGW(TAG, "Could not allocate enough DMA memory!");
} while (mybuf == NULL);
uint32_t LD = 0;
uint32_t j = 0;
for (uint32_t i = 0; i < size; i++) {
LD = buffer_16bit[i].full;
mybuf[j] = (uint8_t) (((LD & 0xF800) >> 8) | ((LD & 0x8000) >> 13));
j++;
mybuf[j] = (uint8_t) ((LD & 0x07E0) >> 3);
j++;
mybuf[j] = (uint8_t) (((LD & 0x001F) << 3) | ((LD & 0x0010) >> 2));
j++;
}
/* Column addresses */
uint8_t xb[] = {
(uint8_t) (area->x1 >> 8) & 0xFF,
(uint8_t) (area->x1) & 0xFF,
(uint8_t) (area->x2 >> 8) & 0xFF,
(uint8_t) (area->x2) & 0xFF,
};
/* Page addresses */
uint8_t yb[] = {
(uint8_t) (area->y1 >> 8) & 0xFF,
(uint8_t) (area->y1) & 0xFF,
(uint8_t) (area->y2 >> 8) & 0xFF,
(uint8_t) (area->y2) & 0xFF,
};
/*Column addresses*/
ili9488_send_cmd(ILI9488_CMD_COLUMN_ADDRESS_SET);
ili9488_send_data(xb, 4);
/*Page addresses*/
ili9488_send_cmd(ILI9488_CMD_PAGE_ADDRESS_SET);
ili9488_send_data(yb, 4);
/*Memory write*/
ili9488_send_cmd(ILI9488_CMD_MEMORY_WRITE);
ili9488_send_color((void *) mybuf, size * 3);
heap_caps_free(mybuf);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ili9488_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9488_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void ili9488_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9488_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void ili9488_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ILI9488_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void ili9488_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
#if defined (CONFIG_LV_PREDEFINED_DISPLAY_NONE)
uint8_t data[] = {0x48, 0x88, 0x28, 0xE8};
#endif
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
ili9488_send_cmd(0x36);
ili9488_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9488.c | C | apache-2.0 | 6,147 |
/**
* @file ili9488.h
*/
#ifndef ILI9844_H
#define ILI9844_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include <stdint.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define ILI9488_DC CONFIG_LV_DISP_PIN_DC
#define ILI9488_RST CONFIG_LV_DISP_PIN_RST
#define ILI9488_USE_RST CONFIG_LV_DISP_USE_RSTS
/*******************
* ILI9488 REGS
*********************/
/* Level 1 Commands (from the display Datasheet) */
#define ILI9488_CMD_NOP 0x00
#define ILI9488_CMD_SOFTWARE_RESET 0x01
#define ILI9488_CMD_READ_DISP_ID 0x04
#define ILI9488_CMD_READ_ERROR_DSI 0x05
#define ILI9488_CMD_READ_DISP_STATUS 0x09
#define ILI9488_CMD_READ_DISP_POWER_MODE 0x0A
#define ILI9488_CMD_READ_DISP_MADCTRL 0x0B
#define ILI9488_CMD_READ_DISP_PIXEL_FORMAT 0x0C
#define ILI9488_CMD_READ_DISP_IMAGE_MODE 0x0D
#define ILI9488_CMD_READ_DISP_SIGNAL_MODE 0x0E
#define ILI9488_CMD_READ_DISP_SELF_DIAGNOSTIC 0x0F
#define ILI9488_CMD_ENTER_SLEEP_MODE 0x10
#define ILI9488_CMD_SLEEP_OUT 0x11
#define ILI9488_CMD_PARTIAL_MODE_ON 0x12
#define ILI9488_CMD_NORMAL_DISP_MODE_ON 0x13
#define ILI9488_CMD_DISP_INVERSION_OFF 0x20
#define ILI9488_CMD_DISP_INVERSION_ON 0x21
#define ILI9488_CMD_PIXEL_OFF 0x22
#define ILI9488_CMD_PIXEL_ON 0x23
#define ILI9488_CMD_DISPLAY_OFF 0x28
#define ILI9488_CMD_DISPLAY_ON 0x29
#define ILI9488_CMD_COLUMN_ADDRESS_SET 0x2A
#define ILI9488_CMD_PAGE_ADDRESS_SET 0x2B
#define ILI9488_CMD_MEMORY_WRITE 0x2C
#define ILI9488_CMD_MEMORY_READ 0x2E
#define ILI9488_CMD_PARTIAL_AREA 0x30
#define ILI9488_CMD_VERT_SCROLL_DEFINITION 0x33
#define ILI9488_CMD_TEARING_EFFECT_LINE_OFF 0x34
#define ILI9488_CMD_TEARING_EFFECT_LINE_ON 0x35
#define ILI9488_CMD_MEMORY_ACCESS_CONTROL 0x36
#define ILI9488_CMD_VERT_SCROLL_START_ADDRESS 0x37
#define ILI9488_CMD_IDLE_MODE_OFF 0x38
#define ILI9488_CMD_IDLE_MODE_ON 0x39
#define ILI9488_CMD_COLMOD_PIXEL_FORMAT_SET 0x3A
#define ILI9488_CMD_WRITE_MEMORY_CONTINUE 0x3C
#define ILI9488_CMD_READ_MEMORY_CONTINUE 0x3E
#define ILI9488_CMD_SET_TEAR_SCANLINE 0x44
#define ILI9488_CMD_GET_SCANLINE 0x45
#define ILI9488_CMD_WRITE_DISPLAY_BRIGHTNESS 0x51
#define ILI9488_CMD_READ_DISPLAY_BRIGHTNESS 0x52
#define ILI9488_CMD_WRITE_CTRL_DISPLAY 0x53
#define ILI9488_CMD_READ_CTRL_DISPLAY 0x54
#define ILI9488_CMD_WRITE_CONTENT_ADAPT_BRIGHTNESS 0x55
#define ILI9488_CMD_READ_CONTENT_ADAPT_BRIGHTNESS 0x56
#define ILI9488_CMD_WRITE_MIN_CAB_LEVEL 0x5E
#define ILI9488_CMD_READ_MIN_CAB_LEVEL 0x5F
#define ILI9488_CMD_READ_ABC_SELF_DIAG_RES 0x68
#define ILI9488_CMD_READ_ID1 0xDA
#define ILI9488_CMD_READ_ID2 0xDB
#define ILI9488_CMD_READ_ID3 0xDC
/* Level 2 Commands (from the display Datasheet) */
#define ILI9488_CMD_INTERFACE_MODE_CONTROL 0xB0
#define ILI9488_CMD_FRAME_RATE_CONTROL_NORMAL 0xB1
#define ILI9488_CMD_FRAME_RATE_CONTROL_IDLE_8COLOR 0xB2
#define ILI9488_CMD_FRAME_RATE_CONTROL_PARTIAL 0xB3
#define ILI9488_CMD_DISPLAY_INVERSION_CONTROL 0xB4
#define ILI9488_CMD_BLANKING_PORCH_CONTROL 0xB5
#define ILI9488_CMD_DISPLAY_FUNCTION_CONTROL 0xB6
#define ILI9488_CMD_ENTRY_MODE_SET 0xB7
#define ILI9488_CMD_BACKLIGHT_CONTROL_1 0xB9
#define ILI9488_CMD_BACKLIGHT_CONTROL_2 0xBA
#define ILI9488_CMD_HS_LANES_CONTROL 0xBE
#define ILI9488_CMD_POWER_CONTROL_1 0xC0
#define ILI9488_CMD_POWER_CONTROL_2 0xC1
#define ILI9488_CMD_POWER_CONTROL_NORMAL_3 0xC2
#define ILI9488_CMD_POWER_CONTROL_IDEL_4 0xC3
#define ILI9488_CMD_POWER_CONTROL_PARTIAL_5 0xC4
#define ILI9488_CMD_VCOM_CONTROL_1 0xC5
#define ILI9488_CMD_CABC_CONTROL_1 0xC6
#define ILI9488_CMD_CABC_CONTROL_2 0xC8
#define ILI9488_CMD_CABC_CONTROL_3 0xC9
#define ILI9488_CMD_CABC_CONTROL_4 0xCA
#define ILI9488_CMD_CABC_CONTROL_5 0xCB
#define ILI9488_CMD_CABC_CONTROL_6 0xCC
#define ILI9488_CMD_CABC_CONTROL_7 0xCD
#define ILI9488_CMD_CABC_CONTROL_8 0xCE
#define ILI9488_CMD_CABC_CONTROL_9 0xCF
#define ILI9488_CMD_NVMEM_WRITE 0xD0
#define ILI9488_CMD_NVMEM_PROTECTION_KEY 0xD1
#define ILI9488_CMD_NVMEM_STATUS_READ 0xD2
#define ILI9488_CMD_READ_ID4 0xD3
#define ILI9488_CMD_ADJUST_CONTROL_1 0xD7
#define ILI9488_CMD_READ_ID_VERSION 0xD8
#define ILI9488_CMD_POSITIVE_GAMMA_CORRECTION 0xE0
#define ILI9488_CMD_NEGATIVE_GAMMA_CORRECTION 0xE1
#define ILI9488_CMD_DIGITAL_GAMMA_CONTROL_1 0xE2
#define ILI9488_CMD_DIGITAL_GAMMA_CONTROL_2 0xE3
#define ILI9488_CMD_SET_IMAGE_FUNCTION 0xE9
#define ILI9488_CMD_ADJUST_CONTROL_2 0xF2
#define ILI9488_CMD_ADJUST_CONTROL_3 0xF7
#define ILI9488_CMD_ADJUST_CONTROL_4 0xF8
#define ILI9488_CMD_ADJUST_CONTROL_5 0xF9
#define ILI9488_CMD_SPI_READ_SETTINGS 0xFB
#define ILI9488_CMD_ADJUST_CONTROL_6 0xFC
#define ILI9488_CMD_ADJUST_CONTROL_7 0xFF
/**********************
* TYPEDEFS
**********************/
typedef struct {
uint8_t red;
uint8_t green;
uint8_t blue;
} lv_color_custom_t;
/**********************
* GLOBAL PROTOTYPES
**********************/
void ili9488_init(void);
void ili9488_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ILI9488_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ili9488.h | C | apache-2.0 | 6,534 |
/**
@file jd79653a.c
@brief GoodDisplay GDEW0154M09 e-paper display w/ FitiPower JD79653A
@version 1.0
@date 2020-08-28
@author Jackson Ming Hu <huming2207@gmail.com>
@section LICENSE
MIT License
Copyright (c) 2020 Jackson Ming Hu
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/event_groups.h>
#include <driver/gpio.h>
#include <esp_log.h>
#include "disp_spi.h"
#include "jd79653a.h"
#define TAG "lv_jd79653a"
#define PIN_DC CONFIG_LV_DISP_PIN_DC
#define PIN_DC_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_DC)))
#define PIN_RST CONFIG_LV_DISP_PIN_RST
#define PIN_RST_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_RST)))
#define PIN_BUSY CONFIG_LV_DISP_PIN_BUSY
#define PIN_BUSY_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_BUSY)))
#define EVT_BUSY (1UL << 0UL)
#define EPD_WIDTH LV_HOR_RES_MAX
#define EPD_HEIGHT LV_VER_RES_MAX
#define EPD_ROW_LEN (EPD_HEIGHT / 8u)
#define EPD_PARTIAL_CNT 5;
#define BIT_SET(a, b) ((a) |= (1U << (b)))
#define BIT_CLEAR(a, b) ((a) &= ~(1U << (b)))
static uint8_t partial_counter = 0;
typedef struct
{
uint8_t cmd;
uint8_t data[3];
size_t len;
} jd79653a_seq_t;
#define EPD_SEQ_LEN(x) ((sizeof(x) / sizeof(jd79653a_seq_t)))
static const uint8_t lut_vcom_dc1[] = {
0x01, 0x04, 0x04, 0x03, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const uint8_t lut_ww1[] = {
0x01, 0x04, 0x04, 0x03, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const uint8_t lut_bw1[] = {
0x01, 0x84, 0x84, 0x83, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const uint8_t lut_wb1[] = {
0x01, 0x44, 0x44, 0x43, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const uint8_t lut_bb1[] = {
0x01, 0x04, 0x04, 0x03, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const jd79653a_seq_t init_seq[] = {
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT_INVERTED)
{0x00, {0xd3, 0x0e}, 2}, // Panel settings
#elif defined(CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
{0x00, {0xdf, 0x0e}, 2}, // Panel settings
#else
#error "Unsupported orientation - only portrait modes are supported for now"
#endif
{0x4d, {0x55}, 1}, // Undocumented secret from demo code
{0xaa, {0x0f}, 1}, // Undocumented secret from demo code
{0xe9, {0x02}, 1}, // Undocumented secret from demo code
{0xb6, {0x11}, 1}, // Undocumented secret from demo code
{0xf3, {0x0a}, 1}, // Undocumented secret from demo code
{0x61, {0xc8, 0x00, 0xc8}, 3}, // Resolution settings
{0x60, {0x00}, 1}, // TCON
{0x50, {0x97}, 1}, // VCOM sequence
{0xe3, {0x00}, 1}, // Power saving settings
};
static const jd79653a_seq_t power_on_seq[] = {
{0x50, {0x97}, 1}, // VCOM sequence
{0x04, {}, 0}, // Power on
};
static const jd79653a_seq_t power_off_seq[] = {
{0x50, {0xf7}, 1}, // VCOM sequence
{0x02, {}, 0}, // Power off
};
static EventGroupHandle_t jd79653a_evts = NULL;
static void IRAM_ATTR jd79653a_busy_intr(void *arg)
{
BaseType_t xResult;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xResult = xEventGroupSetBitsFromISR(jd79653a_evts, EVT_BUSY, &xHigherPriorityTaskWoken);
if (xResult == pdPASS) {
portYIELD_FROM_ISR();
}
}
static void jd79653a_spi_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 0); // DC = 0 for command
disp_spi_send_data(&cmd, 1);
}
static void jd79653a_spi_send_data(uint8_t *data, size_t len)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 1); // DC = 1 for data
disp_spi_send_data(data, len);
}
static void jd79653a_spi_send_fb(uint8_t *data, size_t len)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 1); // DC = 1 for data
disp_spi_send_colors(data, len);
}
static void jd79653a_spi_send_seq(const jd79653a_seq_t *seq, size_t len)
{
ESP_LOGD(TAG, "Writing cmd/data sequence, count %u", len);
if (!seq || len < 1) return;
for (size_t cmd_idx = 0; cmd_idx < len; cmd_idx++) {
jd79653a_spi_send_cmd(seq[cmd_idx].cmd);
if (seq[cmd_idx].len > 0) {
jd79653a_spi_send_data((uint8_t *) seq[cmd_idx].data, seq[cmd_idx].len);
}
}
}
static esp_err_t jd79653a_wait_busy(uint32_t timeout_ms)
{
uint32_t wait_ticks = (timeout_ms == 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms));
EventBits_t bits = xEventGroupWaitBits(jd79653a_evts,
EVT_BUSY, // Wait for busy bit
pdTRUE, pdTRUE, // Clear on exit, wait for all
wait_ticks); // Timeout
return ((bits & EVT_BUSY) != 0) ? ESP_OK : ESP_ERR_TIMEOUT;
}
static void jd79653a_power_on()
{
jd79653a_spi_send_seq(power_on_seq, EPD_SEQ_LEN(power_on_seq));
vTaskDelay(pdMS_TO_TICKS(10));
jd79653a_wait_busy(0);
}
static void jd79653a_power_off()
{
jd79653a_spi_send_seq(power_off_seq, EPD_SEQ_LEN(power_off_seq));
vTaskDelay(pdMS_TO_TICKS(10));
jd79653a_wait_busy(0);
}
static void jd79653a_load_partial_lut()
{
jd79653a_spi_send_cmd(0x20); // LUT VCOM register
jd79653a_spi_send_data((uint8_t *)lut_vcom_dc1, sizeof(lut_vcom_dc1));
jd79653a_spi_send_cmd(0x21); // LUT White-to-White
jd79653a_spi_send_data((uint8_t *)lut_ww1, sizeof(lut_ww1));
jd79653a_spi_send_cmd(0x22); // LUT Black-to-White
jd79653a_spi_send_data((uint8_t *)lut_bw1, sizeof(lut_bw1));
jd79653a_spi_send_cmd(0x23); // LUT White-to-Black
jd79653a_spi_send_data((uint8_t *)lut_wb1,sizeof(lut_wb1));
jd79653a_spi_send_cmd(0x24); // LUT Black-to-Black
jd79653a_spi_send_data((uint8_t *)lut_bb1, sizeof(lut_bb1));
}
static void jd79653a_partial_in()
{
ESP_LOGD(TAG, "Partial in!");
// Panel setting: accept LUT from registers instead of OTP
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT_INVERTED)
uint8_t pst_use_reg_lut[] = { 0xf3, 0x0e };
#elif defined(CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
uint8_t pst_use_reg_lut[] = { 0xff, 0x0e };
#else
#error "Unsupported orientation - only portrait modes are supported for now"
#endif
jd79653a_spi_send_cmd(0x00);
jd79653a_spi_send_data(pst_use_reg_lut, sizeof(pst_use_reg_lut));
// WORKAROUND: need to ignore OLD framebuffer or otherwise partial refresh won't work
uint8_t vcom = 0xb7;
jd79653a_spi_send_cmd(0x50);
jd79653a_spi_send_data(&vcom, 1);
// Dump LUT in
jd79653a_load_partial_lut();
// Go partial!
jd79653a_spi_send_cmd(0x91);
}
static void jd79653a_partial_out()
{
ESP_LOGD(TAG, "Partial out!");
// Panel setting: use LUT from OTP
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT_INVERTED)
uint8_t pst_use_otp_lut[] = { 0xd3, 0x0e };
#elif defined(CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
uint8_t pst_use_otp_lut[] = { 0xdf, 0x0e };
#else
#error "Unsupported orientation - only portrait modes are supported for now"
#endif
jd79653a_spi_send_cmd(0x00);
jd79653a_spi_send_data(pst_use_otp_lut, sizeof(pst_use_otp_lut));
// WORKAROUND: re-enable OLD framebuffer to get a better full refresh
uint8_t vcom = 0x97;
jd79653a_spi_send_cmd(0x50);
jd79653a_spi_send_data(&vcom, 1);
// Out from partial!
jd79653a_spi_send_cmd(0x92);
}
static void jd79653a_update_partial(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t *data)
{
jd79653a_power_on();
jd79653a_partial_in();
ESP_LOGD(TAG, "x1: 0x%x, x2: 0x%x, y1: 0x%x, y2: 0x%x", x1, x2, y1, y2);
size_t len = ((x2 - x1 + 1) * (y2 - y1 + 1)) / 8;
ESP_LOGD(TAG, "Writing PARTIAL LVGL fb with len: %u", len);
// Set partial window
uint8_t ptl_setting[7] = { x1, x2, 0, y1, 0, y2, 0x01 };
jd79653a_spi_send_cmd(0x90);
jd79653a_spi_send_data(ptl_setting, sizeof(ptl_setting));
uint8_t *data_ptr = data;
jd79653a_spi_send_cmd(0x13);
for (size_t h_idx = 0; h_idx < EPD_HEIGHT; h_idx++) {
jd79653a_spi_send_data(data_ptr, EPD_ROW_LEN);
data_ptr += EPD_ROW_LEN;
len -= EPD_ROW_LEN;
}
ESP_LOGD(TAG, "Partial wait start");
jd79653a_spi_send_cmd(0x12);
jd79653a_wait_busy(0);
ESP_LOGD(TAG, "Partial updated");
jd79653a_partial_out();
jd79653a_power_off();
}
void jd79653a_fb_set_full_color(uint8_t color)
{
jd79653a_power_on();
uint8_t old_data[EPD_ROW_LEN];
memset(old_data, ~(color), EPD_ROW_LEN);
// Fill OLD data (maybe not necessary)
jd79653a_spi_send_cmd(0x10);
for (size_t idx = 0; idx < EPD_HEIGHT; idx++) {
jd79653a_spi_send_data(old_data, EPD_ROW_LEN);
}
// Fill NEW data
jd79653a_spi_send_cmd(0x13);
for (size_t h_idx = 0; h_idx < EPD_HEIGHT; h_idx++) {
for (size_t w_idx = 0; w_idx < EPD_ROW_LEN; w_idx++) {
jd79653a_spi_send_data(&color, sizeof(color));
}
}
jd79653a_spi_send_cmd(0x12); // Issue refresh command
vTaskDelay(pdMS_TO_TICKS(100));
jd79653a_wait_busy(0);
jd79653a_power_off();
}
void jd79653a_fb_full_update(uint8_t *data, size_t len)
{
jd79653a_power_on();
ESP_LOGD(TAG, "Performing full update, len: %u", len);
uint8_t *data_ptr = data;
// Fill OLD data (maybe not necessary)
uint8_t old_data[EPD_ROW_LEN] = { 0 };
jd79653a_spi_send_cmd(0x10);
for (size_t idx = 0; idx < EPD_HEIGHT; idx++) {
jd79653a_spi_send_data(old_data, EPD_ROW_LEN);
}
// Fill NEW data
jd79653a_spi_send_cmd(0x13);
for (size_t h_idx = 0; h_idx < EPD_HEIGHT; h_idx++) {
jd79653a_spi_send_data(data_ptr, EPD_ROW_LEN);
data_ptr += EPD_ROW_LEN;
len -= EPD_ROW_LEN;
}
ESP_LOGD(TAG, "Rest len: %u", len);
jd79653a_spi_send_cmd(0x12); // Issue refresh command
vTaskDelay(pdMS_TO_TICKS(100));
jd79653a_wait_busy(0);
jd79653a_power_off();
}
void jd79653a_lv_set_fb_cb(struct _disp_drv_t *disp_drv, uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
uint16_t byte_index = (x >> 3u) + (y * EPD_ROW_LEN);
uint8_t bit_index = x & 0x07u;
if (color.full) {
BIT_SET(buf[byte_index], 7 - bit_index);
} else {
BIT_CLEAR(buf[byte_index], 7 - bit_index);
}
}
void jd79653a_lv_rounder_cb(struct _disp_drv_t *disp_drv, lv_area_t *area)
{
// Always send full framebuffer if it's not in partial mode
area->x1 = 0;
area->y1 = 0;
area->x2 = EPD_WIDTH - 1;
area->y2 = EPD_HEIGHT - 1;
}
void jd79653a_lv_fb_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
size_t len = ((area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1)) / 8;
ESP_LOGD(TAG, "x1: 0x%x, x2: 0x%x, y1: 0x%x, y2: 0x%x", area->x1, area->x2, area->y1, area->y2);
ESP_LOGD(TAG, "Writing LVGL fb with len: %u, partial counter: %u", len, partial_counter);
uint8_t *buf = (uint8_t *) color_map;
if (partial_counter == 0) {
ESP_LOGD(TAG, "Refreshing in FULL");
jd79653a_fb_full_update(buf, ((EPD_HEIGHT * EPD_WIDTH) / 8));
partial_counter = EPD_PARTIAL_CNT; // Reset partial counter here
} else {
jd79653a_update_partial(area->x1, area->y1, area->x2, area->y2, buf);
partial_counter -= 1; // ...or otherwise, decrease 1
}
lv_disp_flush_ready(drv);
}
void jd79653a_deep_sleep()
{
jd79653a_spi_send_seq(power_off_seq, EPD_SEQ_LEN(power_off_seq));
jd79653a_wait_busy(1000);
uint8_t check_code = 0xa5;
jd79653a_spi_send_cmd(0x07);
jd79653a_spi_send_data(&check_code, sizeof(check_code));
}
void jd79653a_init()
{
// Initialise event group
jd79653a_evts = xEventGroupCreate();
if (!jd79653a_evts) {
ESP_LOGE(TAG, "Failed when initialising event group!");
return;
}
// Setup output pins, output (PP)
gpio_config_t out_io_conf = {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = PIN_DC_BIT | PIN_RST_BIT,
.pull_down_en = 0,
.pull_up_en = 0,
};
ESP_ERROR_CHECK(gpio_config(&out_io_conf));
// Setup input pin, pull-up, input
gpio_config_t in_io_conf = {
.intr_type = GPIO_INTR_POSEDGE,
.mode = GPIO_MODE_INPUT,
.pin_bit_mask = PIN_BUSY_BIT,
.pull_down_en = 0,
.pull_up_en = 1,
};
ESP_ERROR_CHECK(gpio_config(&in_io_conf));
gpio_install_isr_service(0);
gpio_isr_handler_add(PIN_BUSY, jd79653a_busy_intr, (void *) PIN_BUSY);
// Hardware reset
gpio_set_level(PIN_RST, 0);
vTaskDelay(pdMS_TO_TICKS(15)); // At least 10ms, leave 15ms for now just in case...
gpio_set_level(PIN_RST, 1);
vTaskDelay(pdMS_TO_TICKS(120));
// Dump in initialise sequence
jd79653a_spi_send_seq(init_seq, EPD_SEQ_LEN(init_seq));
ESP_LOGI(TAG, "Panel init sequence sent");
// Check BUSY status here
jd79653a_wait_busy(0);
ESP_LOGI(TAG, "Panel is up!");
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/jd79653a.c | C | apache-2.0 | 15,843 |
/**
* @file il3820.h
*
*/
#ifndef JD79653A_H
#define JD79653A_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
void jd79653a_init();
void jd79653a_deep_sleep();
void jd79653a_lv_set_fb_cb(struct _disp_drv_t * disp_drv, uint8_t* buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa);
void jd79653a_lv_rounder_cb(struct _disp_drv_t * disp_drv, lv_area_t *area);
void jd79653a_lv_fb_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
void jd79653a_fb_set_full_color(uint8_t color);
void jd79653a_fb_full_update(uint8_t *data, size_t len);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif // JD79653A_H
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/jd79653a.h | C | apache-2.0 | 792 |
/**
* @file ra8875.c
*
*/
/*********************
* INCLUDES
*********************/
#include "ra8875.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define DEBUG false
#define TAG "RA8875"
#define DIV_ROUND_UP(n, d) (((n)+(d)-1)/(d))
#define SPI_CLOCK_SPEED_SLOW_HZ 1000000
#define RA8875_MODE_DATA_WRITE (0x00)
#define RA8875_MODE_DATA_READ (0x40)
#define RA8875_MODE_CMD_WRITE (0x80)
#define RA8875_MODE_STATUS_READ (0xC0)
#if (LV_COLOR_DEPTH == 8)
#define SYSR_VAL (0x00)
#elif (LV_COLOR_DEPTH == 16)
#define SYSR_VAL (0x08)
#else
#error "Unsupported color depth (LV_COLOR_DEPTH)"
#endif
#define BYTES_PER_PIXEL (LV_COLOR_DEPTH / 8)
#define HDWR_VAL (LV_HOR_RES_MAX/8 - 1)
#define VDHR_VAL (LV_VER_RES_MAX - 1)
#define VDIR_MASK (1 << 2)
#define HDIR_MASK (1 << 3)
#if ( CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT_INVERTED || CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE_INVERTED )
#if CONFIG_LV_INVERT_DISPLAY
#define DPCR_VAL (VDIR_MASK)
#else
#define DPCR_VAL (VDIR_MASK | HDIR_MASK)
#endif
#else
#if CONFIG_LV_INVERT_DISPLAY
#define DPCR_VAL (HDIR_MASK)
#else
#define DPCR_VAL (0x00)
#endif
#endif
#if CONFIG_LV_DISP_RA8875_PCLK_INVERT
#define PCSR_VAL (0x80 | CONFIG_LV_DISP_RA8875_PCLK_MULTIPLIER)
#else
#define PCSR_VAL (CONFIG_LV_DISP_RA8875_PCLK_MULTIPLIER)
#endif
// Calculate horizontal display parameters
#if (CONFIG_LV_DISP_RA8875_HORI_NON_DISP_PERIOD >= 260)
#define HNDR_VAL (31)
#else
#define HNDR_VAL ((CONFIG_LV_DISP_RA8875_HORI_NON_DISP_PERIOD-12) / 8)
#endif
#define HNDFT (CONFIG_LV_DISP_RA8875_HORI_NON_DISP_PERIOD-(8*HNDR_VAL)-12)
#if LVGL_DISP_RA8875_DE_POLARITY
#define HNDFTR_VAL (0x80 | HNDFT)
#else
#define HNDFTR_VAL (HNDFT)
#endif
#define HSTR_VAL (CONFIG_LV_DISP_RA8875_HSYNC_START/8 - 1)
#define HPW (CONFIG_LV_DISP_RA8875_HSYNC_PW/8 - 1)
#if LVGL_DISP_RA8875_HSYNC_POLARITY
#define HPWR_VAL (0x80 | HPW)
#else
#define HPWR_VAL (HPW)
#endif
// Calculate vertical display parameters
#define VNDR_VAL (CONFIG_LV_DISP_RA8875_VERT_NON_DISP_PERIOD - 1)
#define VSTR_VAL (CONFIG_LV_DISP_RA8875_VSYNC_START - 1)
#define VPW (CONFIG_LV_DISP_RA8875_VSYNC_PW - 1)
#if LVGL_DISP_RA8875_VSYNC_POLARITY
#define VPWR_VAL (0x80 | VPW)
#else
#define VPWR_VAL (VPW)
#endif
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void ra8875_configure_clocks(bool high_speed);
static void ra8875_set_memory_write_cursor(unsigned int x, unsigned int y);
static void ra8875_set_window(unsigned int xs, unsigned int xe, unsigned int ys, unsigned int ye);
static void ra8875_send_buffer(uint8_t * data, size_t length, bool signal_flush);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ra8875_init(void)
{
unsigned int i = 0;
struct {
uint8_t cmd; // Register address of command
uint8_t data; // Value to write to register
} init_cmds[] = {
{RA8875_REG_SYSR, SYSR_VAL}, // System Configuration Register (SYSR)
{RA8875_REG_HDWR, HDWR_VAL}, // LCD Horizontal Display Width Register (HDWR)
{RA8875_REG_HNDFTR, HNDFTR_VAL}, // Horizontal Non-Display Period Fine Tuning Option Register (HNDFTR)
{RA8875_REG_HNDR, HNDR_VAL}, // Horizontal Non-Display Period Register (HNDR)
{RA8875_REG_HSTR, HSTR_VAL}, // HSYNC Start Position Register (HSTR)
{RA8875_REG_HPWR, HPWR_VAL}, // HSYNC Pulse Width Register (HPWR)
{RA8875_REG_VDHR0, VDHR_VAL & 0x0FF}, // LCD Vertical Display Height Register (VDHR0)
{RA8875_REG_VDHR1, VDHR_VAL >> 8}, // LCD Vertical Display Height Register0 (VDHR1)
{RA8875_REG_VNDR0, VNDR_VAL & 0x0FF}, // LCD Vertical Non-Display Period Register (VNDR0)
{RA8875_REG_VNDR1, VNDR_VAL >> 8}, // LCD Vertical Non-Display Period Register (VNDR1)
{RA8875_REG_VSTR0, VSTR_VAL & 0x0FF}, // VSYNC Start Position Register (VSTR0)
{RA8875_REG_VSTR1, VSTR_VAL >> 8}, // VSYNC Start Position Register (VSTR1)
{RA8875_REG_VPWR, VPWR_VAL}, // VSYNC Pulse Width Register (VPWR)
{RA8875_REG_DPCR, DPCR_VAL}, // Display Configuration Register (DPCR)
{RA8875_REG_MWCR0, 0x00}, // Memory Write Control Register 0 (MWCR0)
{RA8875_REG_MWCR1, 0x00}, // Memory Write Control Register 1 (MWCR1)
{RA8875_REG_LTPR0, 0x00}, // Layer Transparency Register0 (LTPR0)
{RA8875_REG_LTPR1, 0x00}, // Layer Transparency Register1 (LTPR1)
};
#define INIT_CMDS_SIZE (sizeof(init_cmds)/sizeof(init_cmds[0]))
ESP_LOGI(TAG, "Initializing RA8875...");
// Initialize non-SPI GPIOs
#if RA8875_USE_RST
gpio_pad_select_gpio(RA8875_RST);
gpio_set_direction(RA8875_RST, GPIO_MODE_OUTPUT);
// Reset the RA8875
gpio_set_level(RA8875_RST, 0);
vTaskDelay(DIV_ROUND_UP(100, portTICK_RATE_MS));
gpio_set_level(RA8875_RST, 1);
vTaskDelay(DIV_ROUND_UP(100, portTICK_RATE_MS));
#endif
// Initalize RA8875 clocks (SPI must be decelerated before initializing clocks)
disp_spi_change_device_speed(SPI_CLOCK_SPEED_SLOW_HZ);
ra8875_configure_clocks(true);
disp_spi_change_device_speed(-1);
// Send all the commands
for (i = 0; i < INIT_CMDS_SIZE; i++) {
ra8875_write_cmd(init_cmds[i].cmd, init_cmds[i].data);
}
// Perform a memory clear (wait maximum of 100 ticks)
ra8875_write_cmd(RA8875_REG_MCLR, 0x80);
for(i = 100; i != 0; i--) {
if ((ra8875_read_cmd(RA8875_REG_MCLR) & 0x80) == 0x00) {
break;
}
vTaskDelay(1);
}
if (i == 0) {
ESP_LOGW(TAG, "WARNING: Memory clear timed out; RA8875 may be unresponsive.");
}
// Enable the display
ra8875_enable_display(true);
}
void ra8875_enable_display(bool enable)
{
ESP_LOGI(TAG, "%s display.", enable ? "Enabling" : "Disabling");
uint8_t val = enable ? (0x80) : (0x00);
ra8875_write_cmd(RA8875_REG_PWRR, val); // Power and Display Control Register (PWRR)
}
void ra8875_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
static lv_coord_t x1 = LV_COORD_MIN;
static lv_coord_t x2 = LV_COORD_MIN;
static lv_coord_t x = LV_COORD_MIN;
static lv_coord_t y = LV_COORD_MIN;
size_t linelen = (area->x2 - area->x1 + 1);
uint8_t * buffer = (uint8_t*)color_map;
#if DEBUG
ESP_LOGI(TAG, "flush: %d,%d at %d,%d", area->x1, area->x2, area->y1, area->y2 );
#endif
// Get lock
disp_spi_acquire();
// Set window if needed
if ((x1 != area->x1) || (x2 != area->x2)) {
#if DEBUG
ESP_LOGI(TAG, "flush: set window (x1,x2): %d,%d -> %d,%d", x1, x2, area->x1, area->x2);
#endif
ra8875_set_window(area->x1, area->x2, 0, LV_VER_RES_MAX-1);
x1 = area->x1;
x2 = area->x2;
}
// Set cursor if needed
if ((x != area->x1) || (y != area->y1)) {
#if DEBUG
ESP_LOGI(TAG, "flush: set cursor (x,y): %d,%d -> %d,%d", x, y, area->x1, area->y1);
#endif
ra8875_set_memory_write_cursor(area->x1, area->y1);
x = area->x1;
}
// Update to future cursor location
y = area->y2 + 1;
if (y >= LV_VER_RES_MAX) {
y = 0;
}
// Write data
ra8875_send_buffer(buffer, (area->y2 - area->y1 + 1)*BYTES_PER_PIXEL*linelen, true);
// Release lock
disp_spi_release();
}
void ra8875_sleep_in(void)
{
disp_spi_change_device_speed(SPI_CLOCK_SPEED_SLOW_HZ);
ra8875_configure_clocks(false);
ra8875_write_cmd(RA8875_REG_PWRR, 0x00); // Power and Display Control Register (PWRR)
vTaskDelay(DIV_ROUND_UP(20, portTICK_RATE_MS));
ra8875_write_cmd(RA8875_REG_PWRR, 0x02); // Power and Display Control Register (PWRR)
}
void ra8875_sleep_out(void)
{
ra8875_write_cmd(RA8875_REG_PWRR, 0x00); // Power and Display Control Register (PWRR)
vTaskDelay(DIV_ROUND_UP(20, portTICK_RATE_MS));
ra8875_configure_clocks(true);
disp_spi_change_device_speed(-1);
ra8875_write_cmd(RA8875_REG_PWRR, 0x80); // Power and Display Control Register (PWRR)
vTaskDelay(DIV_ROUND_UP(20, portTICK_RATE_MS));
}
uint8_t ra8875_read_cmd(uint8_t cmd)
{
uint8_t buf[4] = {RA8875_MODE_CMD_WRITE, cmd, RA8875_MODE_DATA_READ, 0x00};
disp_spi_transaction(buf, sizeof(buf), (disp_spi_send_flag_t)(DISP_SPI_RECEIVE | DISP_SPI_SEND_POLLING), buf, 0, 0);
return buf[3];
}
void ra8875_write_cmd(uint8_t cmd, uint8_t data)
{
uint8_t buf[4] = {RA8875_MODE_CMD_WRITE, cmd, RA8875_MODE_DATA_WRITE, data};
disp_spi_send_data(buf, sizeof(buf));
}
/**********************
* STATIC FUNCTIONS
**********************/
void ra8875_configure_clocks(bool high_speed)
{
uint8_t val;
val = high_speed ? ((CONFIG_LV_DISP_RA8875_PLLDIVM << 7) | CONFIG_LV_DISP_RA8875_PLLDIVN) : 0x07;
ra8875_write_cmd(RA8875_REG_PLLC1, val); // PLL Control Register 1 (PLLC1)
vTaskDelay(1);
val = high_speed ? CONFIG_LV_DISP_RA8875_PLLDIVK : 0x03;
ra8875_write_cmd(RA8875_REG_PLLC2, val); // PLL Control Register 2 (PLLC2)
vTaskDelay(1);
ra8875_write_cmd(RA8875_REG_PCSR, PCSR_VAL); // Pixel Clock Setting Register (PCSR)
vTaskDelay(DIV_ROUND_UP(20, portTICK_RATE_MS));
}
static void ra8875_set_window(unsigned int xs, unsigned int xe, unsigned int ys, unsigned int ye)
{
ra8875_write_cmd(RA8875_REG_HSAW0, (uint8_t)(xs & 0x0FF)); // Horizontal Start Point 0 of Active Window (HSAW0)
ra8875_write_cmd(RA8875_REG_HSAW1, (uint8_t)(xs >> 8)); // Horizontal Start Point 1 of Active Window (HSAW1)
ra8875_write_cmd(RA8875_REG_VSAW0, (uint8_t)(ys & 0x0FF)); // Vertical Start Point 0 of Active Window (VSAW0)
ra8875_write_cmd(RA8875_REG_VSAW1, (uint8_t)(ys >> 8)); // Vertical Start Point 1 of Active Window (VSAW1)
ra8875_write_cmd(RA8875_REG_HEAW0, (uint8_t)(xe & 0x0FF)); // Horizontal End Point 0 of Active Window (HEAW0)
ra8875_write_cmd(RA8875_REG_HEAW1, (uint8_t)(xe >> 8)); // Horizontal End Point 1 of Active Window (HEAW1)
ra8875_write_cmd(RA8875_REG_VEAW0, (uint8_t)(ye & 0x0FF)); // Vertical End Point of Active Window 0 (VEAW0)
ra8875_write_cmd(RA8875_REG_VEAW1, (uint8_t)(ye >> 8)); // Vertical End Point of Active Window 1 (VEAW1)
}
static void ra8875_set_memory_write_cursor(unsigned int x, unsigned int y)
{
ra8875_write_cmd(RA8875_REG_CURH0, (uint8_t)(x & 0x0FF)); // Memory Write Cursor Horizontal Position Register 0 (CURH0)
ra8875_write_cmd(RA8875_REG_CURH1, (uint8_t)(x >> 8)); // Memory Write Cursor Horizontal Position Register 1 (CURH1)
ra8875_write_cmd(RA8875_REG_CURV0, (uint8_t)(y & 0x0FF)); // Memory Write Cursor Vertical Position Register 0 (CURV0)
ra8875_write_cmd(RA8875_REG_CURV1, (uint8_t)(y >> 8)); // Memory Write Cursor Vertical Position Register 1 (CURV1)
}
static void ra8875_send_buffer(uint8_t * data, size_t length, bool signal_flush)
{
disp_spi_send_flag_t flags = DISP_SPI_SEND_QUEUED | DISP_SPI_ADDRESS_24;
if (signal_flush) {
flags |= DISP_SPI_SIGNAL_FLUSH;
}
const uint64_t prefix = (RA8875_MODE_CMD_WRITE << 16) // Command write mode
| (RA8875_REG_MRWC << 8) // Memory Read/Write Command (MRWC)
| (RA8875_MODE_DATA_WRITE); // Data write mode
disp_spi_transaction(data, length, flags, NULL, prefix, 0);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ra8875.c | C | apache-2.0 | 12,102 |
/**
* @file ra8875.h
*
*/
#ifndef RA8875_H
#define RA8875_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
#define RA8875_RST CONFIG_LV_DISP_PIN_RST
#define RA8875_USE_RST CONFIG_LV_DISP_USE_RST
// System & Configuration Registers
#define RA8875_REG_PWRR (0x01) // Power and Display Control Register (PWRR)
#define RA8875_REG_MRWC (0x02) // Memory Read/Write Command (MRWC)
#define RA8875_REG_PCSR (0x04) // Pixel Clock Setting Register (PCSR)
#define RA8875_REG_SYSR (0x10) // System Configuration Register (SYSR)
#define RA8875_REG_HDWR (0x14) // LCD Horizontal Display Width Register (HDWR)
#define RA8875_REG_HNDFTR (0x15) // Horizontal Non-Display Period Fine Tuning Option Register (HNDFTR)
#define RA8875_REG_HNDR (0x16) // LCD Horizontal Non-Display Period Register (HNDR)
#define RA8875_REG_HSTR (0x17) // HSYNC Start Position Register (HSTR)
#define RA8875_REG_HPWR (0x18) // HSYNC Pulse Width Register (HPWR)
#define RA8875_REG_VDHR0 (0x19) // LCD Vertical Display Height Register (VDHR0)
#define RA8875_REG_VDHR1 (0x1A) // LCD Vertical Display Height Register (VDHR1)
#define RA8875_REG_VNDR0 (0x1B) // LCD Vertical Non-Display Period Register (VNDR0)
#define RA8875_REG_VNDR1 (0x1C) // LCD Vertical Non-Display Period Register (VNDR1)
#define RA8875_REG_VSTR0 (0x1D) // VSYNC Start Position Register (VSTR0)
#define RA8875_REG_VSTR1 (0x1E) // VSYNC Start Position Register (VSTR1)
#define RA8875_REG_VPWR (0x1F) // VSYNC Pulse Width Register (VPWR)
// LCD Display Control Registers
#define RA8875_REG_DPCR (0x20) // Display Configuration Register (DPCR)
// Active Window & Scroll Window Setting Registers
#define RA8875_REG_HSAW0 (0x30) // Horizontal Start Point 0 of Active Window (HSAW0)
#define RA8875_REG_HSAW1 (0x31) // Horizontal Start Point 1 of Active Window (HSAW1)
#define RA8875_REG_VSAW0 (0x32) // Vertical Start Point 0 of Active Window (VSAW0)
#define RA8875_REG_VSAW1 (0x33) // Vertical Start Point 1 of Active Window (VSAW1)
#define RA8875_REG_HEAW0 (0x34) // Horizontal End Point 0 of Active Window (HEAW0)
#define RA8875_REG_HEAW1 (0x35) // Horizontal End Point 1 of Active Window (HEAW1)
#define RA8875_REG_VEAW0 (0x36) // Vertical End Point 0 of Active Window (VEAW0)
#define RA8875_REG_VEAW1 (0x37) // Vertical End Point 1 of Active Window (VEAW1)
// Cursor Setting Registers
#define RA8875_REG_MWCR0 (0x40) // Memory Write Control Register 0 (MWCR0)
#define RA8875_REG_MWCR1 (0x41) // Memory Write Control Register 1 (MWCR1)
#define RA8875_REG_CURH0 (0x46) // Memory Write Cursor Horizontal Position Register 0 (CURH0)
#define RA8875_REG_CURH1 (0x47) // Memory Write Cursor Horizontal Position Register 1 (CURH1)
#define RA8875_REG_CURV0 (0x48) // Memory Write Cursor Vertical Position Register 0 (CURV0)
#define RA8875_REG_CURV1 (0x49) // Memory Write Cursor Vertical Position Register 1 (CURV1)
// Block Transfer Engine(BTE) Control Registers
#define RA8875_REG_LTPR0 (0x52) // Layer Transparency Register 0 (LTPR0)
#define RA8875_REG_LTPR1 (0x53) // Layer Transparency Register 1 (LTPR1)
// Touch Panel Control Registers
#define RA8875_REG_TPCR0 (0x70) // Touch Panel Control Register 0 (TPCR0)
#define RA8875_REG_TPCR1 (0x71) // Touch Panel Control Register 1 (TPCR1)
#define RA8875_REG_TPXH (0x72) // Touch Panel X High Byte Data Register (TPXH)
#define RA8875_REG_TPYH (0x73) // Touch Panel Y High Byte Data Register (TPYH)
#define RA8875_REG_TPXYL (0x74) // Touch Panel X/Y Low Byte Data Register (TPXYL)
// PLL Setting Registers
#define RA8875_REG_PLLC1 (0x88) // PLL Control Register 1 (PLLC1)
#define RA8875_REG_PLLC2 (0x89) // PLL Control Register 2 (PLLC2)
// Memory Clear Register
#define RA8875_REG_MCLR (0x8E) // Memory Clear Control Register (MCLR)
// Interrupt Control Registers
#define RA8875_REG_INTC1 (0xF0) // Interrupt Control Register1 (INTC1)
#define RA8875_REG_INTC2 (0xF1) // Interrupt Control Register1 (INTC2)
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ra8875_init(void);
void ra8875_enable_display(bool enable);
void ra8875_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void ra8875_sleep_in(void);
void ra8875_sleep_out(void);
uint8_t ra8875_read_cmd(uint8_t cmd);
void ra8875_write_cmd(uint8_t cmd, uint8_t data);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*RA8875_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ra8875.h | C | apache-2.0 | 4,921 |
/**
* @file sh1107.c
*
*/
/*********************
* INCLUDES
*********************/
#include "sh1107.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "SH1107"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void sh1107_send_cmd(uint8_t cmd);
static void sh1107_send_data(void * data, uint16_t length);
static void sh1107_send_color(void * data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
#define BIT_SET(a,b) ((a) |= (1U<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1U<<(b)))
/**********************
* GLOBAL FUNCTIONS
**********************/
void sh1107_init(void)
{
// Use Double Bytes Commands if necessary, but not Command+Data
// Initialization taken from https://github.com/nopnop2002/esp-idf-m5stick
lcd_init_cmd_t init_cmds[]={
{0xAE, {0}, 0}, // Turn display off
{0xDC, {0}, 0}, // Set display start line
{0x00, {0}, 0}, // ...value
{0x81, {0}, 0}, // Set display contrast
{0x2F, {0}, 0}, // ...value
{0x20, {0}, 0}, // Set memory mode
{0xA0, {0}, 0}, // Non-rotated display
#if defined CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
{0xC8, {0}, 0}, // flipped vertical
#elif defined CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT
{0xC7, {0}, 0}, // flipped vertical
#endif
{0xA8, {0}, 0}, // Set multiplex ratio
{0x7F, {0}, 0}, // ...value
{0xD3, {0}, 0}, // Set display offset to zero
{0x60, {0}, 0}, // ...value
{0xD5, {0}, 0}, // Set display clock divider
{0x51, {0}, 0}, // ...value
{0xD9, {0}, 0}, // Set pre-charge
{0x22, {0}, 0}, // ...value
{0xDB, {0}, 0}, // Set com detect
{0x35, {0}, 0}, // ...value
{0xB0, {0}, 0}, // Set page address
{0xDA, {0}, 0}, // Set com pins
{0x12, {0}, 0}, // ...value
{0xA4, {0}, 0}, // output ram to display
#if defined CONFIG_LV_INVERT_COLORS
{0xA7, {0}, 0}, // inverted display
#else
{0xA6, {0}, 0}, // Non-inverted display
#endif
{0xAF, {0}, 0}, // Turn display on
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(SH1107_DC);
gpio_set_direction(SH1107_DC, GPIO_MODE_OUTPUT);
#if SH1107_USE_RST
gpio_pad_select_gpio(SH1107_RST);
gpio_set_direction(SH1107_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(SH1107_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(SH1107_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
//Send all the commands
uint16_t cmd = 0;
while (init_cmds[cmd].databytes!=0xff) {
sh1107_send_cmd(init_cmds[cmd].cmd);
sh1107_send_data(init_cmds[cmd].data, init_cmds[cmd].databytes&0x1F);
if (init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
}
void sh1107_set_px_cb(struct _disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
/* buf_w will be ignored, the configured CONFIG_LV_DISPLAY_HEIGHT and _WIDTH,
and CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE and _PORTRAIT will be used. */
uint16_t byte_index = 0;
uint8_t bit_index = 0;
#if defined CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
byte_index = y + (( x>>3 ) * LV_VER_RES_MAX);
bit_index = x & 0x7;
#elif defined CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT
byte_index = x + (( y>>3 ) * LV_HOR_RES_MAX);
bit_index = y & 0x7;
#endif
if ((color.full == 0) && (LV_OPA_TRANSP != opa)) {
BIT_SET(buf[byte_index], bit_index);
} else {
BIT_CLEAR(buf[byte_index], bit_index);
}
}
void sh1107_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t columnLow = area->x1 & 0x0F;
uint8_t columnHigh = (area->x1 >> 4) & 0x0F;
uint8_t row1 = 0, row2 = 0;
uint32_t size = 0;
void *ptr;
#if defined CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
row1 = area->x1>>3;
row2 = area->x2>>3;
#else
row1 = area->y1>>3;
row2 = area->y2>>3;
#endif
for(int i = row1; i < row2+1; i++){
sh1107_send_cmd(0x10 | columnHigh); // Set Higher Column Start Address for Page Addressing Mode
sh1107_send_cmd(0x00 | columnLow); // Set Lower Column Start Address for Page Addressing Mode
sh1107_send_cmd(0xB0 | i); // Set Page Start Address for Page Addressing Mode
size = area->y2 - area->y1 + 1;
#if defined CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
ptr = color_map + i * LV_VER_RES_MAX;
#else
ptr = color_map + i * LV_HOR_RES_MAX;
#endif
if(i != row2){
sh1107_send_data( (void *) ptr, size);
} else {
// complete sending data by sh1107_send_color() and thus call lv_flush_ready()
sh1107_send_color( (void *) ptr, size);
}
}
}
void sh1107_rounder(struct _disp_drv_t * disp_drv, lv_area_t *area)
{
// workaround: always send complete size display buffer
area->x1 = 0;
area->y1 = 0;
area->x2 = LV_HOR_RES_MAX-1;
area->y2 = LV_VER_RES_MAX-1;
}
void sh1107_sleep_in()
{
sh1107_send_cmd(0xAE);
}
void sh1107_sleep_out()
{
sh1107_send_cmd(0xAF);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void sh1107_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(SH1107_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void sh1107_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(SH1107_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void sh1107_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(SH1107_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/sh1107.c | C | apache-2.0 | 6,287 |
/**
* @file lv_templ.h
*
*/
#ifndef SH1107_H
#define SH1107_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define SH1107_DC CONFIG_LV_DISP_PIN_DC
#define SH1107_RST CONFIG_LV_DISP_PIN_RST
#define SH1107_USE_RST CONFIG_LV_DISP_USE_RST
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void sh1107_init(void);
void sh1107_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void sh1107_rounder(struct _disp_drv_t * disp_drv, lv_area_t *area);
void sh1107_set_px_cb(struct _disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa);
void sh1107_sleep_in(void);
void sh1107_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*SH1107_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/sh1107.h | C | apache-2.0 | 1,172 |
/**
* @file ssd1306.c
*
* Code from https://github.com/yanbe/ssd1306-esp-idf-i2c.git is used as a starting point,
* in addition to code from https://github.com/espressif/esp-iot-solution.
*
* Definitions are borrowed from:
* http://robotcantalk.blogspot.com/2015/03/interfacing-arduino-with-ssd1306-driven.html
*
* For LVGL the forum has been used, in particular: https://blog.littlevgl.com/2019-05-06/oled
*/
/*********************
* INCLUDES
*********************/
#include "assert.h"
#include "lvgl_i2c/i2c_manager.h"
#include "ssd1306.h"
/*********************
* DEFINES
*********************/
#define TAG "SSD1306"
#define OLED_I2C_PORT (CONFIG_LV_I2C_DISPLAY_PORT)
// SLA (0x3C) + WRITE_MODE (0x00) = 0x78 (0b01111000)
#define OLED_I2C_ADDRESS 0x3C
#define OLED_WIDTH 128
#define OLED_HEIGHT 64
#define OLED_COLUMNS 128
#define OLED_PAGES 8
#define OLED_PIXEL_PER_PAGE 8
// Control byte
#define OLED_CONTROL_BYTE_CMD_SINGLE 0x80
#define OLED_CONTROL_BYTE_CMD_STREAM 0x00
#define OLED_CONTROL_BYTE_DATA_STREAM 0x40
// Fundamental commands (pg.28)
#define OLED_CMD_SET_CONTRAST 0x81 // follow with 0x7F
#define OLED_CMD_DISPLAY_RAM 0xA4
#define OLED_CMD_DISPLAY_ALLON 0xA5
#define OLED_CMD_DISPLAY_NORMAL 0xA6
#define OLED_CMD_DISPLAY_INVERTED 0xA7
#define OLED_CMD_DISPLAY_OFF 0xAE
#define OLED_CMD_DISPLAY_ON 0xAF
// Addressing Command Table (pg.30)
#define OLED_CMD_SET_MEMORY_ADDR_MODE 0x20 // follow with 0x00 = HORZ mode
#define OLED_CMD_SET_COLUMN_RANGE 0x21 // can be used only in HORZ/VERT mode - follow with 0x00 and 0x7F = COL127
#define OLED_CMD_SET_PAGE_RANGE 0x22 // can be used only in HORZ/VERT mode - follow with 0x00 and 0x07 = PAGE7
// Hardware Config (pg.31)
#define OLED_CMD_SET_DISPLAY_START_LINE 0x40
#define OLED_CMD_SET_SEGMENT_REMAP 0xA1
#define OLED_CMD_SET_MUX_RATIO 0xA8 // follow with 0x3F = 64 MUX
#define OLED_CMD_SET_COM_SCAN_MODE_NORMAL 0xC0
#define OLED_CMD_SET_COM_SCAN_MODE_REMAP 0xC8
#define OLED_CMD_SET_DISPLAY_OFFSET 0xD3 // follow with 0x00
#define OLED_CMD_SET_COM_PIN_MAP 0xDA // follow with 0x12
#define OLED_CMD_NOP 0xE3 // NOP
// Timing and Driving Scheme (pg.32)
#define OLED_CMD_SET_DISPLAY_CLK_DIV 0xD5 // follow with 0x80
#define OLED_CMD_SET_PRECHARGE 0xD9 // follow with 0xF1
#define OLED_CMD_SET_VCOMH_DESELCT 0xDB // follow with 0x30
// Charge Pump (pg.62)
#define OLED_CMD_SET_CHARGE_PUMP 0x8D // follow with 0x14
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static uint8_t send_data(lv_disp_drv_t *disp_drv, void *bytes, size_t bytes_len);
static uint8_t send_pixels(lv_disp_drv_t *disp_drv, void *color_buffer, size_t buffer_len);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
#define BIT_SET(a,b) ((a) |= (1U<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1U<<(b)))
/**********************
* GLOBAL FUNCTIONS
**********************/
void ssd1306_init(void)
{
uint8_t orientation_1 = 0;
uint8_t orientation_2 = 0;
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE)
orientation_1 = OLED_CMD_SET_SEGMENT_REMAP;
orientation_2 = OLED_CMD_SET_COM_SCAN_MODE_REMAP;
#elif defined (CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE_INVERTED)
orientation_1 = 0xA0;
orientation_2 = OLED_CMD_SET_COM_SCAN_MODE_NORMAL;
#else
#error "Unsupported orientation"
#endif
uint8_t display_mode = 0;
#if defined CONFIG_LV_INVERT_COLORS
display_mode = OLED_CMD_DISPLAY_INVERTED;
#else
display_mode = OLED_CMD_DISPLAY_NORMAL;
#endif
uint8_t conf[] = {
OLED_CONTROL_BYTE_CMD_STREAM,
OLED_CMD_SET_CHARGE_PUMP,
0x14,
orientation_1,
orientation_2,
OLED_CMD_SET_CONTRAST,
0xFF,
display_mode,
OLED_CMD_DISPLAY_ON
};
uint8_t err = send_data(NULL, conf, sizeof(conf));
assert(0 == err);
}
void ssd1306_set_px_cb(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
uint16_t byte_index = x + (( y>>3 ) * buf_w);
uint8_t bit_index = y & 0x7;
if ((color.full == 0) && (LV_OPA_TRANSP != opa)) {
BIT_SET(buf[byte_index], bit_index);
} else {
BIT_CLEAR(buf[byte_index], bit_index);
}
}
void ssd1306_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
{
/* Divide by 8 */
uint8_t row1 = area->y1 >> 3;
uint8_t row2 = area->y2 >> 3;
uint8_t conf[] = {
OLED_CONTROL_BYTE_CMD_STREAM,
OLED_CMD_SET_MEMORY_ADDR_MODE,
0x00,
OLED_CMD_SET_COLUMN_RANGE,
(uint8_t) area->x1,
(uint8_t) area->x2,
OLED_CMD_SET_PAGE_RANGE,
row1,
row2,
};
uint8_t err = send_data(disp_drv, conf, sizeof(conf));
assert(0 == err);
err = send_pixels(disp_drv, color_p, OLED_COLUMNS * (1 + row2 - row1));
assert(0 == err);
lv_disp_flush_ready(disp_drv);
}
void ssd1306_rounder(lv_disp_drv_t * disp_drv, lv_area_t *area)
{
uint8_t hor_max = disp_drv->hor_res;
uint8_t ver_max = disp_drv->ver_res;
area->x1 = 0;
area->y1 = 0;
area->x2 = hor_max - 1;
area->y2 = ver_max - 1;
}
void ssd1306_sleep_in(void)
{
uint8_t conf[] = {
OLED_CONTROL_BYTE_CMD_STREAM,
OLED_CMD_DISPLAY_OFF
};
uint8_t err = send_data(NULL, conf, sizeof(conf));
assert(0 == err);
}
void ssd1306_sleep_out(void)
{
uint8_t conf[] = {
OLED_CONTROL_BYTE_CMD_STREAM,
OLED_CMD_DISPLAY_ON
};
uint8_t err = send_data(NULL, conf, sizeof(conf));
assert(0 == err);
}
/**********************
* STATIC FUNCTIONS
**********************/
static uint8_t send_data(lv_disp_drv_t *disp_drv, void *bytes, size_t bytes_len)
{
(void) disp_drv;
uint8_t *data = (uint8_t *) bytes;
return lvgl_i2c_write(OLED_I2C_PORT, OLED_I2C_ADDRESS, data[0], data + 1, bytes_len - 1 );
}
static uint8_t send_pixels(lv_disp_drv_t *disp_drv, void *color_buffer, size_t buffer_len)
{
(void) disp_drv;
return lvgl_i2c_write(OLED_I2C_PORT, OLED_I2C_ADDRESS, OLED_CONTROL_BYTE_DATA_STREAM, color_buffer, buffer_len);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ssd1306.c | C | apache-2.0 | 6,703 |
/**
* @file lv_templ.h
*
*/
#ifndef SSD1306_H
#define SSD1306_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define SSD1306_DISPLAY_ORIENTATION TFT_ORIENTATION_LANDSCAPE
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ssd1306_init(void);
void ssd1306_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void ssd1306_rounder(lv_disp_drv_t * disp_drv, lv_area_t *area);
void ssd1306_set_px_cb(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa);
void ssd1306_sleep_in(void);
void ssd1306_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*SSD1306_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/ssd1306.h | C | apache-2.0 | 1,098 |
/**
* @file st7735s.c
*
*/
/*********************
* INCLUDES
*********************/
#include "st7735s.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#ifdef CONFIG_LV_M5STICKC_HANDLE_AXP192
#include "lvgl_i2c/i2c_manager.h"
#endif
/*********************
* DEFINES
*********************/
#define TAG "ST7735S"
#define AXP192_I2C_ADDRESS 0x34
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void st7735s_send_cmd(uint8_t cmd);
static void st7735s_send_data(void * data, uint16_t length);
static void st7735s_send_color(void * data, uint16_t length);
static void st7735s_set_orientation(uint8_t orientation);
static void axp192_write_byte(uint8_t addr, uint8_t data);
static void axp192_init();
static void axp192_sleep_in();
static void axp192_sleep_out();
/**********************
* STATIC VARIABLES
**********************/
uint8_t st7735s_portrait_mode = 0;
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void st7735s_init(void)
{
#ifdef CONFIG_LV_M5STICKC_HANDLE_AXP192
axp192_init();
#endif
lcd_init_cmd_t init_cmds[]={
{ST7735_SWRESET, {0}, 0x80}, // Software reset, 0 args, w/delay 150
{ST7735_SLPOUT, {0}, 0x80}, // Out of sleep mode, 0 args, w/delay 500
{ST7735_FRMCTR1, {0x01, 0x2C, 0x2D}, 3}, // Frame rate ctrl - normal mode, 3 args: Rate = fosc/(1x2+40) * (LINE+2C+2D)
{ST7735_FRMCTR2, {0x01, 0x2C, 0x2D}, 3}, // Frame rate control - idle mode, 3 args:Rate = fosc/(1x2+40) * (LINE+2C+2D)
{ST7735_FRMCTR3, {0x01, 0x2C, 0x2D,0x01, 0x2C, 0x2D}, 6}, //Frame rate ctrl - partial mode, 6 args:Dot inversion mode. Line inversion mode
{ST7735_INVCTR, {0x07}, 1}, // Display inversion ctrl, 1 arg, no delay:No inversion
{ST7735_PWCTR1, {0xA2,0x02, 0x84}, 3}, // Power control, 3 args, no delay:-4.6V AUTO mode
{ST7735_PWCTR2, {0xC5}, 1}, // Power control, 1 arg, no delay:VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD
{ST7735_PWCTR3, {0x0A, 0x00}, 2}, // Power control, 2 args, no delay: Opamp current small, Boost frequency
{ST7735_PWCTR4, {0x8A,0x2A }, 2}, // Power control, 2 args, no delay: BCLK/2, Opamp current small & Medium low
{ST7735_PWCTR5, {0x8A, 0xEE}, 2}, // Power control, 2 args, no delay:
{ST7735_VMCTR1, {0x0E}, 1}, // Power control, 1 arg, no delay:
#if ST7735S_INVERT_COLORS == 1
{ST7735_INVON, {0}, 0}, // set inverted mode
#else
{ST7735_INVOFF, {0}, 0}, // set non-inverted mode
#endif
{ST7735_COLMOD, {0x05}, 1}, // set color mode, 1 arg, no delay: 16-bit color
{ST7735_GMCTRP1, {0x02, 0x1c, 0x07, 0x12,
0x37, 0x32, 0x29, 0x2d,
0x29, 0x25, 0x2B, 0x39,
0x00, 0x01, 0x03, 0x10}, 16}, // 16 args, no delay:
{ST7735_GMCTRN1, {0x03, 0x1d, 0x07, 0x06,
0x2E, 0x2C, 0x29, 0x2D,
0x2E, 0x2E, 0x37, 0x3F,
0x00, 0x00, 0x02, 0x10}, 16}, // 16 args, no delay:
{ST7735_NORON, {0}, TFT_INIT_DELAY}, // Normal display on, no args, w/delay 10 ms delay
{ST7735_DISPON, {0}, TFT_INIT_DELAY}, // Main screen turn on, no args w/delay 100 ms delay
{0, {0}, 0xff}
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ST7735S_DC);
gpio_set_direction(ST7735S_DC, GPIO_MODE_OUTPUT);
#if ST7735S_USE_RST
gpio_pad_select_gpio(ST7735S_RST);
gpio_set_direction(ST7735S_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ST7735S_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ST7735S_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "ST7735S initialization.");
//Send all the commands
uint16_t cmd = 0;
while (init_cmds[cmd].databytes!=0xff) {
st7735s_send_cmd(init_cmds[cmd].cmd);
st7735s_send_data(init_cmds[cmd].data, init_cmds[cmd].databytes&0x1F);
if (init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
#if (CONFIG_LV_DISPLAY_ORIENTATION == 0) || (CONFIG_LV_DISPLAY_ORIENTATION == 1)
st7735s_portrait_mode = 1;
#else
st7735s_portrait_mode = 0;
#endif
st7735s_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
}
void st7735s_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t data[4];
/*Column addresses*/
st7735s_send_cmd(0x2A);
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = (area->x1 & 0xFF) + (st7735s_portrait_mode ? COLSTART : ROWSTART);
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = (area->x2 & 0xFF) + (st7735s_portrait_mode ? COLSTART : ROWSTART);
st7735s_send_data(data, 4);
/*Page addresses*/
st7735s_send_cmd(0x2B);
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = (area->y1 & 0xFF) + (st7735s_portrait_mode ? ROWSTART : COLSTART);
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = (area->y2 & 0xFF) + (st7735s_portrait_mode ? ROWSTART : COLSTART);
st7735s_send_data(data, 4);
/*Memory write*/
st7735s_send_cmd(0x2C);
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
st7735s_send_color((void*)color_map, size * 2);
}
void st7735s_sleep_in()
{
st7735s_send_cmd(0x10);
#ifdef CONFIG_LV_M5STICKC_HANDLE_AXP192
axp192_sleep_in();
#endif
}
void st7735s_sleep_out()
{
#ifdef CONFIG_LV_M5STICKC_HANDLE_AXP192
axp192_sleep_out();
#endif
st7735s_send_cmd(0x11);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void st7735s_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7735S_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void st7735s_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7735S_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void st7735s_send_color(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7735S_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void st7735s_set_orientation(uint8_t orientation)
{
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGD(TAG, "Display orientation: %s", orientation_str[orientation]);
/*
Portrait: 0xC8 = ST77XX_MADCTL_MX | ST77XX_MADCTL_MY | ST77XX_MADCTL_BGR
Landscape: 0xA8 = ST77XX_MADCTL_MY | ST77XX_MADCTL_MV | ST77XX_MADCTL_BGR
Remark: "inverted" is ignored here
*/
uint8_t data[] = {0xC8, 0xC8, 0xA8, 0xA8};
ESP_LOGD(TAG, "0x36 command value: 0x%02X", data[orientation]);
st7735s_send_cmd(ST7735_MADCTL);
st7735s_send_data((void *) &data[orientation], 1);
}
#ifdef CONFIG_LV_M5STICKC_HANDLE_AXP192
static void axp192_write_byte(uint8_t addr, uint8_t data)
{
err = lvgl_i2c_write(CONFIG_LV_I2C_DISPLAY_PORT, AXP192_I2C_ADDRESS, addr, &data, 1);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "AXP192 send failed. code: 0x%.2X", ret);
}
}
static void axp192_init()
{
// information on how to init and use AXP192 ifor M5StickC taken from
// https://forum.m5stack.com/topic/1025/m5stickc-turn-off-screen-completely
axp192_write_byte(0x10, 0xFF); // OLED_VPP Enable
axp192_write_byte(0x28, 0xCC); // Enable LDO2&LDO3, LED&TFT 3.0V
axp192_sleep_out();
ESP_LOGI(TAG, "AXP192 initialized, power enabled for LDO2 and LDO3");
}
static void axp192_sleep_in()
{
axp192_write_byte(0x12, 0x4b);
}
static void axp192_sleep_out()
{
axp192_write_byte(0x12, 0x4d);
}
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7735s.c | C | apache-2.0 | 8,080 |
/**
* @file lv_templ.h
*
*/
#ifndef ST7735S_H
#define ST7735S_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
#define DISP_BUF_SIZE (LV_HOR_RES_MAX * 40)
#define ST7735S_DC CONFIG_LV_DISP_PIN_DC
#define ST7735S_RST CONFIG_LV_DISP_PIN_RST
#define ST7735S_USE_RST CONFIG_LV_DISP_USE_RST
#define ST7735S_INVERT_COLORS CONFIG_LV_INVERT_COLORS
// Defines are taken from
// https://raw.githubusercontent.com/m5stack/M5StickC/master/src/utility/ST7735_Defines.h
// and are modified to fit to the M5StickC device, and are taken from
// https://github.com/adafruit/Adafruit-ST7735-Library
//
#define ST7735_GREENTAB160x80 // For 160 x 80 display (BGR, inverted, 26 / 1 offset)
#define COLSTART 26
#define ROWSTART 1
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80
#define TFT_NOP 0x00
#define TFT_SWRST 0x01
#define TFT_CASET 0x2A
#define TFT_PASET 0x2B
#define TFT_RAMWR 0x2C
#define TFT_RAMRD 0x2E
#define TFT_IDXRD 0x00
#define TFT_MADCTL 0x36
#define TFT_MAD_MY 0x80
#define TFT_MAD_MX 0x40
#define TFT_MAD_MV 0x20
#define TFT_MAD_ML 0x10
#define TFT_MAD_BGR 0x08
#define TFT_MAD_MH 0x04
#define TFT_MAD_RGB 0x00
#define TFT_INVOFF 0x20
#define TFT_INVON 0x21
// ST7735 specific commands used in init
#define ST7735_NOP 0x00
#define ST7735_SWRESET 0x01
#define ST7735_RDDID 0x04
#define ST7735_RDDST 0x09
#define ST7735_SLPIN 0x10
#define ST7735_SLPOUT 0x11
#define ST7735_PTLON 0x12
#define ST7735_NORON 0x13
#define ST7735_INVOFF 0x20
#define ST7735_INVON 0x21
#define ST7735_DISPOFF 0x28
#define ST7735_DISPON 0x29
#define ST7735_CASET 0x2A
#define ST7735_RASET 0x2B
#define ST7735_RAMWR 0x2C
#define ST7735_RAMRD 0x2E
#define ST7735_PTLAR 0x30
#define ST7735_VSCRDEF 0x33
#define ST7735_COLMOD 0x3A
#define ST7735_MADCTL 0x36
#define ST7735_VSCRSADD 0x37
#define ST7735_FRMCTR1 0xB1
#define ST7735_FRMCTR2 0xB2
#define ST7735_FRMCTR3 0xB3
#define ST7735_INVCTR 0xB4
#define ST7735_DISSET5 0xB6
#define ST7735_PWCTR1 0xC0
#define ST7735_PWCTR2 0xC1
#define ST7735_PWCTR3 0xC2
#define ST7735_PWCTR4 0xC3
#define ST7735_PWCTR5 0xC4
#define ST7735_VMCTR1 0xC5
#define ST7735_RDID1 0xDA
#define ST7735_RDID2 0xDB
#define ST7735_RDID3 0xDC
#define ST7735_RDID4 0xDD
#define ST7735_PWCTR6 0xFC
#define ST7735_GMCTRP1 0xE0
#define ST7735_GMCTRN1 0xE1
#define ST77XX_MADCTL_MY 0x80
#define ST77XX_MADCTL_MX 0x40
#define ST77XX_MADCTL_MV 0x20
#define ST77XX_MADCTL_ML 0x10
#define ST77XX_MADCTL_RGB 0x00
#define ST77XX_MADCTL_BGR 0x08
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void st7735s_init(void);
void st7735s_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map);
void st7735s_sleep_in(void);
void st7735s_sleep_out(void);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ST7735S_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7735s.h | C | apache-2.0 | 3,615 |
/**
* @file st7789.c
*
* Mostly taken from lbthomsen/esp-idf-littlevgl github.
*/
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sdkconfig.h"
#include "esp_log.h"
#include "st7789.h"
#include "disp_spi.h"
#include "driver/gpio.h"
/*********************
* DEFINES
*********************/
#define TAG "st7789"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void st7789_set_orientation(uint8_t orientation);
static void st7789_send_color(void *data, size_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void st7789_init(void)
{
lcd_init_cmd_t st7789_init_cmds[] = {
{0xCF, {0x00, 0x83, 0X30}, 3},
{0xED, {0x64, 0x03, 0X12, 0X81}, 4},
{ST7789_PWCTRL2, {0x85, 0x01, 0x79}, 3},
{0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02}, 5},
{0xF7, {0x20}, 1},
{0xEA, {0x00, 0x00}, 2},
{ST7789_LCMCTRL, {0x26}, 1},
{ST7789_IDSET, {0x11}, 1},
{ST7789_VCMOFSET, {0x35, 0x3E}, 2},
{ST7789_CABCCTRL, {0xBE}, 1},
{ST7789_MADCTL, {0x00}, 1}, // Set to 0x28 if your display is flipped
{ST7789_COLMOD, {0x55}, 1},
#if ST7789_INVERT_COLORS == 1
{ST7789_INVON, {0}, 0}, // set inverted mode
#else
{ST7789_INVOFF, {0}, 0}, // set non-inverted mode
#endif
{ST7789_RGBCTRL, {0x00, 0x1B}, 2},
{0xF2, {0x08}, 1},
{ST7789_GAMSET, {0x01}, 1},
{ST7789_PVGAMCTRL, {0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32, 0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17}, 14},
{ST7789_NVGAMCTRL, {0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31, 0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E}, 14},
{ST7789_CASET, {0x00, 0x00, 0x00, 0xEF}, 4},
{ST7789_RASET, {0x00, 0x00, 0x01, 0x3f}, 4},
{ST7789_RAMWR, {0}, 0},
{ST7789_GCTRL, {0x07}, 1},
{0xB6, {0x0A, 0x82, 0x27, 0x00}, 4},
{ST7789_SLPOUT, {0}, 0x80},
{ST7789_DISPON, {0}, 0x80},
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ST7789_DC);
gpio_set_direction(ST7789_DC, GPIO_MODE_OUTPUT);
#if !defined(ST7789_SOFT_RST)
gpio_pad_select_gpio(ST7789_RST);
gpio_set_direction(ST7789_RST, GPIO_MODE_OUTPUT);
#endif
//Reset the display
#if !defined(ST7789_SOFT_RST)
gpio_set_level(ST7789_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ST7789_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#else
st7789_send_cmd(ST7789_SWRESET);
#endif
printf("ST7789 initialization.\n");
//Send all the commands
uint16_t cmd = 0;
while (st7789_init_cmds[cmd].databytes!=0xff) {
st7789_send_cmd(st7789_init_cmds[cmd].cmd);
st7789_send_data(st7789_init_cmds[cmd].data, st7789_init_cmds[cmd].databytes&0x1F);
if (st7789_init_cmds[cmd].databytes & 0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
st7789_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
}
/* The ST7789 display controller can drive 320*240 displays, when using a 240*240
* display there's a gap of 80px, we need to edit the coordinates to take into
* account that gap, this is not necessary in all orientations. */
void st7789_flush(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_map)
{
uint8_t data[4] = {0};
uint16_t offsetx1 = area->x1;
uint16_t offsetx2 = area->x2;
uint16_t offsety1 = area->y1;
uint16_t offsety2 = area->y2;
#if (CONFIG_LV_TFT_DISPLAY_OFFSETS)
offsetx1 += CONFIG_LV_TFT_DISPLAY_X_OFFSET;
offsetx2 += CONFIG_LV_TFT_DISPLAY_X_OFFSET;
offsety1 += CONFIG_LV_TFT_DISPLAY_Y_OFFSET;
offsety2 += CONFIG_LV_TFT_DISPLAY_Y_OFFSET;
#elif (LV_HOR_RES_MAX == 240) && (LV_VER_RES_MAX == 240)
#if (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
offsetx1 += 80;
offsetx2 += 80;
#elif (CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE_INVERTED)
offsety1 += 80;
offsety2 += 80;
#endif
#endif
/*Column addresses*/
st7789_send_cmd(ST7789_CASET);
data[0] = (offsetx1 >> 8) & 0xFF;
data[1] = offsetx1 & 0xFF;
data[2] = (offsetx2 >> 8) & 0xFF;
data[3] = offsetx2 & 0xFF;
st7789_send_data(data, 4);
/*Page addresses*/
st7789_send_cmd(ST7789_RASET);
data[0] = (offsety1 >> 8) & 0xFF;
data[1] = offsety1 & 0xFF;
data[2] = (offsety2 >> 8) & 0xFF;
data[3] = offsety2 & 0xFF;
st7789_send_data(data, 4);
/*Memory write*/
st7789_send_cmd(ST7789_RAMWR);
size_t size = (size_t)lv_area_get_width(area) * (size_t)lv_area_get_height(area);
st7789_send_color((void*)color_map, size * 2);
}
/**********************
* STATIC FUNCTIONS
**********************/
void st7789_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7789_DC, 0);
disp_spi_send_data(&cmd, 1);
}
void st7789_send_data(void * data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7789_DC, 1);
disp_spi_send_data(data, length);
}
static void st7789_send_color(void * data, size_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7789_DC, 1);
disp_spi_send_colors(data, length);
}
static void st7789_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"
};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
uint8_t data[] =
{
#if CONFIG_LV_PREDEFINED_DISPLAY_TTGO
0x60, 0xA0, 0x00, 0xC0
#else
0xC0, 0x00, 0x60, 0xA0
#endif
};
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
st7789_send_cmd(ST7789_MADCTL);
st7789_send_data((void *) &data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7789.c | C | apache-2.0 | 6,237 |
/**
* @file st7789.h
*
* Mostly taken from lbthomsen/esp-idf-littlevgl github.
*/
#ifndef ST7789_H
#define ST7789_H
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
#include "sdkconfig.h"
#define ST7789_DC CONFIG_LV_DISP_PIN_DC
#define ST7789_RST CONFIG_LV_DISP_PIN_RST
#if CONFIG_LV_DISP_USE_RST
#if CONFIG_LV_DISP_ST7789_SOFT_RESET
#define ST7789_SOFT_RST
#endif
#else
#define ST7789_SOFT_RST
#endif
#define ST7789_INVERT_COLORS CONFIG_LV_INVERT_COLORS
/* ST7789 commands */
#define ST7789_NOP 0x00
#define ST7789_SWRESET 0x01
#define ST7789_RDDID 0x04
#define ST7789_RDDST 0x09
#define ST7789_RDDPM 0x0A // Read display power mode
#define ST7789_RDD_MADCTL 0x0B // Read display MADCTL
#define ST7789_RDD_COLMOD 0x0C // Read display pixel format
#define ST7789_RDDIM 0x0D // Read display image mode
#define ST7789_RDDSM 0x0E // Read display signal mode
#define ST7789_RDDSR 0x0F // Read display self-diagnostic result (ST7789V)
#define ST7789_SLPIN 0x10
#define ST7789_SLPOUT 0x11
#define ST7789_PTLON 0x12
#define ST7789_NORON 0x13
#define ST7789_INVOFF 0x20
#define ST7789_INVON 0x21
#define ST7789_GAMSET 0x26 // Gamma set
#define ST7789_DISPOFF 0x28
#define ST7789_DISPON 0x29
#define ST7789_CASET 0x2A
#define ST7789_RASET 0x2B
#define ST7789_RAMWR 0x2C
#define ST7789_RGBSET 0x2D // Color setting for 4096, 64K and 262K colors
#define ST7789_RAMRD 0x2E
#define ST7789_PTLAR 0x30
#define ST7789_VSCRDEF 0x33 // Vertical scrolling definition (ST7789V)
#define ST7789_TEOFF 0x34 // Tearing effect line off
#define ST7789_TEON 0x35 // Tearing effect line on
#define ST7789_MADCTL 0x36 // Memory data access control
#define ST7789_IDMOFF 0x38 // Idle mode off
#define ST7789_IDMON 0x39 // Idle mode on
#define ST7789_RAMWRC 0x3C // Memory write continue (ST7789V)
#define ST7789_RAMRDC 0x3E // Memory read continue (ST7789V)
#define ST7789_COLMOD 0x3A
#define ST7789_RAMCTRL 0xB0 // RAM control
#define ST7789_RGBCTRL 0xB1 // RGB control
#define ST7789_PORCTRL 0xB2 // Porch control
#define ST7789_FRCTRL1 0xB3 // Frame rate control
#define ST7789_PARCTRL 0xB5 // Partial mode control
#define ST7789_GCTRL 0xB7 // Gate control
#define ST7789_GTADJ 0xB8 // Gate on timing adjustment
#define ST7789_DGMEN 0xBA // Digital gamma enable
#define ST7789_VCOMS 0xBB // VCOMS setting
#define ST7789_LCMCTRL 0xC0 // LCM control
#define ST7789_IDSET 0xC1 // ID setting
#define ST7789_VDVVRHEN 0xC2 // VDV and VRH command enable
#define ST7789_VRHS 0xC3 // VRH set
#define ST7789_VDVSET 0xC4 // VDV setting
#define ST7789_VCMOFSET 0xC5 // VCOMS offset set
#define ST7789_FRCTR2 0xC6 // FR Control 2
#define ST7789_CABCCTRL 0xC7 // CABC control
#define ST7789_REGSEL1 0xC8 // Register value section 1
#define ST7789_REGSEL2 0xCA // Register value section 2
#define ST7789_PWMFRSEL 0xCC // PWM frequency selection
#define ST7789_PWCTRL1 0xD0 // Power control 1
#define ST7789_VAPVANEN 0xD2 // Enable VAP/VAN signal output
#define ST7789_CMD2EN 0xDF // Command 2 enable
#define ST7789_PVGAMCTRL 0xE0 // Positive voltage gamma control
#define ST7789_NVGAMCTRL 0xE1 // Negative voltage gamma control
#define ST7789_DGMLUTR 0xE2 // Digital gamma look-up table for red
#define ST7789_DGMLUTB 0xE3 // Digital gamma look-up table for blue
#define ST7789_GATECTRL 0xE4 // Gate control
#define ST7789_SPI2EN 0xE7 // SPI2 enable
#define ST7789_PWCTRL2 0xE8 // Power control 2
#define ST7789_EQCTRL 0xE9 // Equalize time control
#define ST7789_PROMCTRL 0xEC // Program control
#define ST7789_PROMEN 0xFA // Program mode enable
#define ST7789_NVMSET 0xFC // NVM setting
#define ST7789_PROMACT 0xFE // Program action
void st7789_init(void);
void st7789_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
void st7789_send_cmd(uint8_t cmd);
void st7789_send_data(void *data, uint16_t length);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* ST7789_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7789.h | C | apache-2.0 | 4,551 |
/**
* @file st7796s.c
*
*/
/*********************
* INCLUDES
*********************/
#include "st7796s.h"
#include "disp_spi.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
/*********************
* DEFINES
*********************/
#define TAG "ST7796S"
/**********************
* TYPEDEFS
**********************/
/*The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct. */
typedef struct
{
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void st7796s_set_orientation(uint8_t orientation);
static void st7796s_send_cmd(uint8_t cmd);
static void st7796s_send_data(void *data, uint16_t length);
static void st7796s_send_color(void *data, uint16_t length);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void st7796s_init(void)
{
lcd_init_cmd_t init_cmds[] = {
{0xCF, {0x00, 0x83, 0X30}, 3},
{0xED, {0x64, 0x03, 0X12, 0X81}, 4},
{0xE8, {0x85, 0x01, 0x79}, 3},
{0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02}, 5},
{0xF7, {0x20}, 1},
{0xEA, {0x00, 0x00}, 2},
{0xC0, {0x26}, 1}, /*Power control*/
{0xC1, {0x11}, 1}, /*Power control */
{0xC5, {0x35, 0x3E}, 2}, /*VCOM control*/
{0xC7, {0xBE}, 1}, /*VCOM control*/
{0x36, {0x28}, 1}, /*Memory Access Control*/
{0x3A, {0x55}, 1}, /*Pixel Format Set*/
{0xB1, {0x00, 0x1B}, 2},
{0xF2, {0x08}, 1},
{0x26, {0x01}, 1},
{0xE0, {0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00}, 15},
{0XE1, {0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F}, 15},
{0x2A, {0x00, 0x00, 0x00, 0xEF}, 4},
{0x2B, {0x00, 0x00, 0x01, 0x3f}, 4},
{0x2C, {0}, 0},
{0xB7, {0x07}, 1},
{0xB6, {0x0A, 0x82, 0x27, 0x00}, 4},
{0x11, {0}, 0x80},
{0x29, {0}, 0x80},
{0, {0}, 0xff},
};
//Initialize non-SPI GPIOs
gpio_pad_select_gpio(ST7796S_DC);
gpio_set_direction(ST7796S_DC, GPIO_MODE_OUTPUT);
#if ST7796S_USE_RST
gpio_pad_select_gpio(ST7796S_RST);
gpio_set_direction(ST7796S_RST, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(ST7796S_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(ST7796S_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
#endif
ESP_LOGI(TAG, "Initialization.");
//Send all the commands
uint16_t cmd = 0;
while (init_cmds[cmd].databytes != 0xff)
{
st7796s_send_cmd(init_cmds[cmd].cmd);
st7796s_send_data(init_cmds[cmd].data, init_cmds[cmd].databytes & 0x1F);
if (init_cmds[cmd].databytes & 0x80)
{
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
st7796s_set_orientation(CONFIG_LV_DISPLAY_ORIENTATION);
#if ST7796S_INVERT_COLORS == 1
st7796s_send_cmd(0x21);
#else
st7796s_send_cmd(0x20);
#endif
}
void st7796s_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
uint8_t data[4];
/*Column addresses*/
st7796s_send_cmd(0x2A);
data[0] = (area->x1 >> 8) & 0xFF;
data[1] = area->x1 & 0xFF;
data[2] = (area->x2 >> 8) & 0xFF;
data[3] = area->x2 & 0xFF;
st7796s_send_data(data, 4);
/*Page addresses*/
st7796s_send_cmd(0x2B);
data[0] = (area->y1 >> 8) & 0xFF;
data[1] = area->y1 & 0xFF;
data[2] = (area->y2 >> 8) & 0xFF;
data[3] = area->y2 & 0xFF;
st7796s_send_data(data, 4);
/*Memory write*/
st7796s_send_cmd(0x2C);
uint32_t size = lv_area_get_width(area) * lv_area_get_height(area);
st7796s_send_color((void *)color_map, size * 2);
}
void st7796s_sleep_in()
{
uint8_t data[] = {0x08};
st7796s_send_cmd(0x10);
st7796s_send_data(&data, 1);
}
void st7796s_sleep_out()
{
uint8_t data[] = {0x08};
st7796s_send_cmd(0x11);
st7796s_send_data(&data, 1);
}
/**********************
* STATIC FUNCTIONS
**********************/
static void st7796s_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7796S_DC, 0); /*Command mode*/
disp_spi_send_data(&cmd, 1);
}
static void st7796s_send_data(void *data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7796S_DC, 1); /*Data mode*/
disp_spi_send_data(data, length);
}
static void st7796s_send_color(void *data, uint16_t length)
{
disp_wait_for_pending_transactions();
gpio_set_level(ST7796S_DC, 1); /*Data mode*/
disp_spi_send_colors(data, length);
}
static void st7796s_set_orientation(uint8_t orientation)
{
// ESP_ASSERT(orientation < 4);
const char *orientation_str[] = {
"PORTRAIT", "PORTRAIT_INVERTED", "LANDSCAPE", "LANDSCAPE_INVERTED"};
ESP_LOGI(TAG, "Display orientation: %s", orientation_str[orientation]);
#if defined CONFIG_LV_PREDEFINED_DISPLAY_M5STACK
uint8_t data[] = {0x68, 0x68, 0x08, 0x08};
#elif defined(CONFIG_LV_PREDEFINED_DISPLAY_WROVER4)
uint8_t data[] = {0x4C, 0x88, 0x28, 0xE8};
#elif defined(CONFIG_LV_PREDEFINED_DISPLAY_WT32_SC01)
uint8_t data[] = {0x48, 0x88, 0x28, 0xE8};
#elif defined(CONFIG_LV_PREDEFINED_DISPLAY_NONE)
uint8_t data[] = {0x48, 0x88, 0x28, 0xE8};
#endif
ESP_LOGI(TAG, "0x36 command value: 0x%02X", data[orientation]);
st7796s_send_cmd(0x36);
st7796s_send_data((void *)&data[orientation], 1);
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7796s.c | C | apache-2.0 | 5,377 |
/**
* @file st7796s.h
*/
#ifndef ST7796S_H
#define ST7796S_H
#ifdef __cplusplus
extern "C"
{
#endif
/*********************
* INCLUDES
*********************/
#include <stdbool.h>
#include <stdint.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#include "../lvgl_helpers.h"
/*********************
* DEFINES
*********************/
#define ST7796S_DC CONFIG_LV_DISP_PIN_DC
#define ST7796S_RST CONFIG_LV_DISP_PIN_RST
#define ST7796S_USE_RST CONFIG_LV_DISP_USE_RST
#define ST7796S_INVERT_COLORS CONFIG_LV_INVERT_COLORS
#define ST7796S_DISPLAY_ORIENTATION CONFIG_LV_DISPLAY_ORIENTATION
/*******************
* ST7796S REGS
*********************/
/* MIPI DCS Type1 */
#define ST7796S_CMD_NOP 0x00
#define ST7796S_CMD_SOFTWARE_RESET 0x01
#define ST7796S_CMD_READ_DISP_POWER_MODE 0x0A
#define ST7796S_CMD_READ_DISP_MADCTRL 0x0B // bits 7:3 only
#define ST7796S_CMD_READ_DISP_PIXEL_FORMAT 0x0C
#define ST7796S_CMD_READ_DISP_IMAGE_MODE 0x0D
#define ST7796S_CMD_READ_DISP_SIGNAL_MODE 0x0E
#define ST7796S_CMD_READ_DISP_SELF_DIAGNOSTIC 0x0F // bits 7:6 only
#define ST7796S_CMD_ENTER_SLEEP_MODE 0x10
#define ST7796S_CMD_SLEEP_OUT 0x11
#define ST7796S_CMD_PARTIAL_MODE_ON 0x12
#define ST7796S_CMD_NORMAL_DISP_MODE_ON 0x13
#define ST7796S_CMD_DISP_INVERSION_OFF 0x20
#define ST7796S_CMD_DISP_INVERSION_ON 0x21
#define ST7796S_CMD_DISPLAY_OFF 0x28
#define ST7796S_CMD_DISPLAY_ON 0x29
#define ST7796S_CMD_COLUMN_ADDRESS_SET 0x2A
#define ST7796S_CMD_PAGE_ADDRESS_SET 0x2B
#define ST7796S_CMD_MEMORY_WRITE 0x2C
#define ST7796S_CMD_MEMORY_READ 0x2E
#define ST7796S_CMD_PARTIAL_AREA 0x30
#define ST7796S_CMD_VERT_SCROLL_DEFINITION 0x33
#define ST7796S_CMD_TEARING_EFFECT_LINE_OFF 0x34
#define ST7796S_CMD_TEARING_EFFECT_LINE_ON 0x35
#define ST7796S_CMD_MEMORY_ACCESS_CONTROL 0x36 // bits 7:3,1:0 only
#define ST7796S_CMD_VERT_SCROLL_START_ADDRESS 0x37
#define ST7796S_CMD_IDLE_MODE_OFF 0x38
#define ST7796S_CMD_IDLE_MODE_ON 0x39
#define ST7796S_CMD_COLMOD_PIXEL_FORMAT_SET 0x3A
#define ST7796S_CMD_WRITE_MEMORY_CONTINUE 0x3C
#define ST7796S_CMD_READ_MEMORY_CONTINUE 0x3E
#define ST7796S_CMD_SET_TEAR_SCANLINE 0x44
#define ST7796S_CMD_GET_SCANLINE 0x45
#define ST7796S_DDB_START 0xA1
#define ST7796S_DDB_CONTINUE 0xA8
/* other */
#define ST7796S_CMD_ACCESS_PROTECT 0xB0
#define ST7796S_CMD_LOW_POWER_CONTROL 0xB1
#define ST7796S_CMD_FRAME_MEMORY_ACCESS 0xB3
#define ST7796S_CMD_DISPLAY_MODE 0xB4
#define ST7796S_CMD_DEVICE_CODE 0xBF
#define ST7796S_CMD_PANEL_DRIVE 0xC0
#define ST7796S_CMD_DISP_TIMING_NORMAL 0xC1
#define ST7796S_CMD_DISP_TIMING_PARTIAL 0xC2
#define ST7796S_CMD_DISP_TIMING_IDLE 0xC3
#define ST7796S_CMD_FRAME_RATE 0xC5
#define ST7796S_CMD_INTERFACE_CONTROL 0xC6
#define ST7796S_CMD_GAMMA_SETTING 0xC8
#define ST7796S_CMD_POWER_SETTING 0xD0
#define ST7796S_CMD_VCOM_CONTROL 0xD1
#define ST7796S_CMD_POWER_CONTROL_NORMAL 0xD2
#define ST7796S_CMD_POWER_CONTROL_IDEL 0xD3
#define ST7796S_CMD_POWER_CONTROL_PARTIAL 0xD4
#define ST7796S_CMD_NVMEM_WRITE 0xE0
#define ST7796S_CMD_NVMEM_PROTECTION_KEY 0xE1
#define ST7796S_CMD_NVMEM_STATUS_READ 0xE2
#define ST7796S_CMD_NVMEM_PROTECTION 0xE3
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void st7796s_init(void);
void st7796s_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*ST7796S_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/st7796s.h | C | apache-2.0 | 3,593 |
/**
@file uc8151d.c
@brief GoodDisplay GDEW0154M10 DES e-paper display w/ UltraChip UC8151D
@version 1.0
@date 2020-08-28
@author Jackson Ming Hu <huming2207@gmail.com>
@section LICENSE
MIT License
Copyright (c) 2020 Jackson Ming Hu
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/event_groups.h>
#include <driver/gpio.h>
#include <esp_log.h>
#include "disp_spi.h"
#include "disp_driver.h"
#include "uc8151d.h"
#define TAG "lv_uc8151d"
#define PIN_DC CONFIG_LV_DISP_PIN_DC
#define PIN_DC_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_DC)))
#define PIN_RST CONFIG_LV_DISP_PIN_RST
#define PIN_RST_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_RST)))
#define PIN_BUSY CONFIG_LV_DISP_PIN_BUSY
#define PIN_BUSY_BIT ((1ULL << (uint8_t)(CONFIG_LV_DISP_PIN_BUSY)))
#define EVT_BUSY (1UL << 0UL)
#define EPD_WIDTH LV_HOR_RES_MAX
#define EPD_HEIGHT LV_VER_RES_MAX
#define EPD_ROW_LEN (EPD_HEIGHT / 8u)
#define BIT_SET(a, b) ((a) |= (1U << (b)))
#define BIT_CLEAR(a, b) ((a) &= ~(1U << (b)))
typedef struct
{
uint8_t cmd;
uint8_t data[3];
size_t len;
} uc8151d_seq_t;
#define EPD_SEQ_LEN(x) ((sizeof(x) / sizeof(uc8151d_seq_t)))
static EventGroupHandle_t uc8151d_evts = NULL;
static void IRAM_ATTR uc8151d_busy_intr(void *arg)
{
BaseType_t xResult;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xResult = xEventGroupSetBitsFromISR(uc8151d_evts, EVT_BUSY, &xHigherPriorityTaskWoken);
if (xResult == pdPASS) {
portYIELD_FROM_ISR();
}
}
static void uc8151d_spi_send_cmd(uint8_t cmd)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 0); // DC = 0 for command
disp_spi_send_data(&cmd, 1);
}
static void uc8151d_spi_send_data(uint8_t *data, size_t len)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 1); // DC = 1 for data
disp_spi_send_data(data, len);
}
static void uc8151d_spi_send_data_byte(uint8_t data)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 1); // DC = 1 for data
disp_spi_send_data(&data, 1);
}
static void uc8151d_spi_send_fb(uint8_t *data, size_t len)
{
disp_wait_for_pending_transactions();
gpio_set_level(PIN_DC, 1); // DC = 1 for data
disp_spi_send_colors(data, len);
}
static void uc8151d_spi_send_seq(const uc8151d_seq_t *seq, size_t len)
{
ESP_LOGD(TAG, "Writing cmd/data sequence, count %u", len);
if (!seq || len < 1) return;
for (size_t cmd_idx = 0; cmd_idx < len; cmd_idx++) {
uc8151d_spi_send_cmd(seq[cmd_idx].cmd);
if (seq[cmd_idx].len > 0) {
uc8151d_spi_send_data((uint8_t *) seq[cmd_idx].data, seq[cmd_idx].len);
}
}
}
static esp_err_t uc8151d_wait_busy(uint32_t timeout_ms)
{
uint32_t wait_ticks = (timeout_ms == 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeout_ms));
EventBits_t bits = xEventGroupWaitBits(uc8151d_evts,
EVT_BUSY, // Wait for busy bit
pdTRUE, pdTRUE, // Clear on exit, wait for all
wait_ticks); // Timeout
return ((bits & EVT_BUSY) != 0) ? ESP_OK : ESP_ERR_TIMEOUT;
}
static void uc8151d_sleep()
{
// Set VCOM to 0xf7
uc8151d_spi_send_cmd(0x50);
uc8151d_spi_send_data_byte(0xf7);
// Power off
uc8151d_spi_send_cmd(0x02);
uc8151d_wait_busy(0);
// Go to sleep
uc8151d_spi_send_cmd(0x07);
uc8151d_spi_send_data_byte(0xa5);
}
static void uc8151d_panel_init()
{
// Hardware reset for 3 times - not sure why but it's from official demo code
for (uint8_t cnt = 0; cnt < 3; cnt++) {
gpio_set_level(PIN_RST, 0);
vTaskDelay(pdMS_TO_TICKS(10)); // At least 10ms, leave 20ms for now just in case...
gpio_set_level(PIN_RST, 1);
vTaskDelay(pdMS_TO_TICKS(10));
}
// Power up
uc8151d_spi_send_cmd(0x04);
uc8151d_wait_busy(0);
// Panel settings
uc8151d_spi_send_cmd(0x00);
#if defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT_INVERTED)
uc8151d_spi_send_data_byte(0x13);
#elif defined (CONFIG_LV_DISPLAY_ORIENTATION_PORTRAIT)
uc8151d_spi_send_data_byte(0x1f);
#endif
// VCOM & Data intervals
uc8151d_spi_send_cmd(0x50);
uc8151d_spi_send_data_byte(0x97);
}
static void uc8151d_full_update(uint8_t *buf)
{
uc8151d_panel_init();
uint8_t *buf_ptr = buf;
uint8_t old_data[EPD_ROW_LEN] = { 0 };
// Fill old data
uc8151d_spi_send_cmd(0x10);
for (size_t h_idx = 0; h_idx < EPD_HEIGHT; h_idx++) {
uc8151d_spi_send_data(old_data, EPD_ROW_LEN);
}
// Fill new data
uc8151d_spi_send_cmd(0x13);
for (size_t h_idx = 0; h_idx < EPD_HEIGHT; h_idx++) {
uc8151d_spi_send_data(buf_ptr, EPD_ROW_LEN);
buf_ptr += EPD_ROW_LEN;
}
// Issue refresh
uc8151d_spi_send_cmd(0x12);
vTaskDelay(pdMS_TO_TICKS(10));
uc8151d_wait_busy(0);
uc8151d_sleep();
}
void uc8151d_lv_fb_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
size_t len = ((area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1)) / 8;
ESP_LOGD(TAG, "x1: 0x%x, x2: 0x%x, y1: 0x%x, y2: 0x%x", area->x1, area->x2, area->y1, area->y2);
ESP_LOGD(TAG, "Writing LVGL fb with len: %u", len);
uint8_t *buf = (uint8_t *) color_map;
uc8151d_full_update(buf);
lv_disp_flush_ready(drv);
ESP_LOGD(TAG, "Ready");
}
void uc8151d_lv_set_fb_cb(struct _disp_drv_t *disp_drv, uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa)
{
uint16_t byte_index = (x >> 3u) + (y * EPD_ROW_LEN);
uint8_t bit_index = x & 0x07u;
if (color.full) {
BIT_SET(buf[byte_index], 7 - bit_index);
} else {
ESP_LOGD(TAG, "Clear at x: %u, y: %u", x, y);
BIT_CLEAR(buf[byte_index], 7 - bit_index);
}
}
void uc8151d_lv_rounder_cb(struct _disp_drv_t *disp_drv, lv_area_t *area)
{
// Always send full framebuffer if it's not in partial mode
area->x1 = 0;
area->y1 = 0;
area->x2 = EPD_WIDTH - 1;
area->y2 = EPD_HEIGHT - 1;
}
void uc8151d_init()
{
// Initialise event group
uc8151d_evts = xEventGroupCreate();
if (!uc8151d_evts) {
ESP_LOGE(TAG, "Failed when initialising event group!");
return;
}
// Setup output pins, output (PP)
gpio_config_t out_io_conf = {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = PIN_DC_BIT | PIN_RST_BIT,
.pull_down_en = 0,
.pull_up_en = 0,
};
ESP_ERROR_CHECK(gpio_config(&out_io_conf));
// Setup input pin, pull-up, input
gpio_config_t in_io_conf = {
.intr_type = GPIO_INTR_POSEDGE,
.mode = GPIO_MODE_INPUT,
.pin_bit_mask = PIN_BUSY_BIT,
.pull_down_en = 0,
.pull_up_en = 1,
};
ESP_ERROR_CHECK(gpio_config(&in_io_conf));
gpio_install_isr_service(0);
gpio_isr_handler_add(PIN_BUSY, uc8151d_busy_intr, (void *) PIN_BUSY);
ESP_LOGI(TAG, "IO init finished");
uc8151d_panel_init();
ESP_LOGI(TAG, "Panel initialised");
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/uc8151d.c | C | apache-2.0 | 8,377 |
/**
@file uc8151d.h
@brief GoodDisplay GDEW0154M09 e-paper display w/ FitiPower JD79653A
@version 1.0
@date 2020-08-28
@author Jackson Ming Hu <huming2207@gmail.com>
@section LICENSE
MIT License
Copyright (c) 2020 Jackson Ming Hu
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef LVGL_DEMO_UC8151D_H
#define LVGL_DEMO_UC8151D_H
#include <lvgl.h>
void uc8151d_init();
void uc8151d_lv_set_fb_cb(struct _disp_drv_t *disp_drv, uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
lv_color_t color, lv_opa_t opa);
void uc8151d_lv_rounder_cb(struct _disp_drv_t *disp_drv, lv_area_t *area);
void uc8151d_lv_fb_flush(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map);
#endif //LVGL_DEMO_UC8151D_H
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_tft/uc8151d.h | C | apache-2.0 | 1,803 |
/**
* @file FT81x.c
*/
/*********************
* INCLUDES
*********************/
#include "esp_system.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include <stddef.h>
#include "FT81x.h"
#include "../lvgl_tft/EVE.h"
#include "../lvgl_tft/EVE_commands.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Get the current position and state of the touchpad
* @param data store the read data here
* @return false: because no more data to be read
*/
bool FT81x_read(lv_indev_drv_t * drv, lv_indev_data_t * data)
{
static int16_t last_x = 0;
static int16_t last_y = 0;
bool touched = true;
uint32_t XY = EVE_memRead32(REG_TOUCH_SCREEN_XY);
uint16_t Y = XY & 0xffff;
uint16_t X = XY >> 16;
// is it not touched (or invalid because of calibration range)
if(X == 0x8000 || Y == 0x8000 || X > LV_HOR_RES_MAX || Y > LV_VER_RES_MAX)
{
touched = false;
X = last_x;
Y = last_y;
}
else
{
last_x = X;
last_y = Y;
}
data->point.x = X;
data->point.y = Y;
data->state = (touched == false ? LV_INDEV_STATE_REL : LV_INDEV_STATE_PR);
return false;
}
/**********************
* STATIC FUNCTIONS
**********************/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/FT81x.c | C | apache-2.0 | 1,601 |
/**
* @file STMPE610.h
*/
#ifndef FT81X_TOUCH__H
#define FT81X_TOUCH__H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
;
bool FT81x_read(lv_indev_drv_t * drv, lv_indev_data_t * data);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* FT81X_TOUCH__H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/FT81x.h | C | apache-2.0 | 715 |
/**
* @file ADCRAW.c
*/
#include "adcraw.h"
#include "esp_system.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include <stddef.h>
#if CONFIG_LV_TOUCH_CONTROLLER_ADCRAW
#define TAG "ADCRAW"
#define CALIBRATIONINSET 1 // range 0 <= CALIBRATIONINSET <= 40
#define SAMPLE_CALIBRATION_POINTS 4
// use this scale factor to avoid working in floating point numbers
#define TOUCHSCREEN_RESISTIVE_CALIBRATION_SCALE_FACTOR 8
#define SCALE_FACTOR (1 << TOUCHSCREEN_RESISTIVE_CALIBRATION_SCALE_FACTOR)
#define CAL_X_INSET (((GetMaxX() + 1) * (CALIBRATIONINSET >> 1)) / 100)
#define CAL_Y_INSET (((GetMaxY() + 1) * (CALIBRATIONINSET >> 1)) / 100)
#define NUMSAMPLES 8
static void ad_touch_handler(void *arg);
static const esp_timer_create_args_t periodic_timer_args = {
.callback = &ad_touch_handler,
};
static esp_timer_handle_t periodic_timer;
// Current ADC values for X and Y channels
int16_t adcX, adcY = 0;
int16_t temp_x, temp_y, temp_z1, temp_z2;
// coefficient values
int _trA, _trB, _trC, _trD;
int16_t xRawTouch[SAMPLE_CALIBRATION_POINTS];
int16_t yRawTouch[SAMPLE_CALIBRATION_POINTS];
TOUCH_STATES state;
const gpio_num_t yu = TOUCHSCREEN_RESISTIVE_PIN_YU;
const gpio_num_t xl = TOUCHSCREEN_RESISTIVE_PIN_XL;
const gpio_num_t yd = TOUCHSCREEN_RESISTIVE_PIN_YD;
const gpio_num_t xr = TOUCHSCREEN_RESISTIVE_PIN_XR;
static const int gpio_to_adc[] = {
GPIO_TO_ADC_ELEMENT(TOUCHSCREEN_RESISTIVE_PIN_YD),
GPIO_TO_ADC_ELEMENT(TOUCHSCREEN_RESISTIVE_PIN_XR)
};
static void TouchCalculateCalPoints(void)
{
int32_t trA, trB, trC, trD; // variables for the coefficients
int32_t trAhold, trBhold, trChold, trDhold;
int32_t test1, test2; // temp variables (must be signed type)
int16_t xPoint[SAMPLE_CALIBRATION_POINTS], yPoint[SAMPLE_CALIBRATION_POINTS];
yPoint[0] = yPoint[1] = CAL_Y_INSET;
yPoint[2] = yPoint[3] = (GetMaxY() - CAL_Y_INSET);
xPoint[0] = xPoint[3] = CAL_X_INSET;
xPoint[1] = xPoint[2] = (GetMaxX() - CAL_X_INSET);
// calculate points transfer function
// based on two simultaneous equations solve for the constants
// use sample points 1 and 4
// Dy1 = aTy1 + b; Dy4 = aTy4 + b
// Dx1 = cTx1 + d; Dy4 = aTy4 + b
test1 = (int32_t)yPoint[0] - (int32_t)yPoint[3];
test2 = (int32_t)yRawTouch[0] - (int32_t)yRawTouch[3];
trA = ((int32_t)((int32_t)test1 * SCALE_FACTOR) / test2);
trB = ((int32_t)((int32_t)yPoint[0] * SCALE_FACTOR) - (trA * (int32_t)yRawTouch[0]));
test1 = (int32_t)xPoint[0] - (int32_t)xPoint[2];
test2 = (int32_t)xRawTouch[0] - (int32_t)xRawTouch[2];
trC = ((int32_t)((int32_t)test1 * SCALE_FACTOR) / test2);
trD = ((int32_t)((int32_t)xPoint[0] * SCALE_FACTOR) - (trC * (int32_t)xRawTouch[0]));
trAhold = trA;
trBhold = trB;
trChold = trC;
trDhold = trD;
// use sample points 2 and 3
// Dy2 = aTy2 + b; Dy3 = aTy3 + b
// Dx2 = cTx2 + d; Dy3 = aTy3 + b
test1 = (int32_t)yPoint[1] - (int32_t)yPoint[2];
test2 = (int32_t)yRawTouch[1] - (int32_t)yRawTouch[2];
trA = ((int32_t)(test1 * SCALE_FACTOR) / test2);
trB = ((int32_t)((int32_t)yPoint[1] * SCALE_FACTOR) - (trA * (int32_t)yRawTouch[1]));
test1 = (int32_t)xPoint[1] - (int32_t)xPoint[3];
test2 = (int32_t)xRawTouch[1] - (int32_t)xRawTouch[3];
trC = ((int32_t)((int32_t)test1 * SCALE_FACTOR) / test2);
trD = ((int32_t)((int32_t)xPoint[1] * SCALE_FACTOR) - (trC * (int32_t)xRawTouch[1]));
// get the average and use it
_trA = (trA + trAhold) >> 1;
_trB = (trB + trBhold) >> 1;
_trC = (trC + trChold) >> 1;
_trD = (trD + trDhold) >> 1;
}
void adcraw_init(void)
{
state = IDLE; // set the state of the state machine to start the sampling
gpio_set_drive_capability(yu, GPIO_DRIVE_CAP_3);
gpio_set_drive_capability(yd, GPIO_DRIVE_CAP_3);
gpio_set_drive_capability(xl, GPIO_DRIVE_CAP_3);
gpio_set_drive_capability(xr, GPIO_DRIVE_CAP_3);
ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, 5 * 1000)); //5ms (expressed as microseconds)
/*Load calibration data*/
xRawTouch[0] = TOUCHCAL_ULX;
yRawTouch[0] = TOUCHCAL_ULY;
xRawTouch[1] = TOUCHCAL_URX;
yRawTouch[1] = TOUCHCAL_URY;
xRawTouch[3] = TOUCHCAL_LLX;
yRawTouch[3] = TOUCHCAL_LLY;
xRawTouch[2] = TOUCHCAL_LRX;
yRawTouch[2] = TOUCHCAL_LRY;
TouchCalculateCalPoints();
}
static void setup_axis(gpio_num_t plus, gpio_num_t minus, gpio_num_t measure, gpio_num_t ignore)
{
// Set GPIOs:
// - Float "ignore" and "measure"
gpio_pad_select_gpio(ignore);
gpio_set_direction(ignore, GPIO_MODE_DISABLE);
gpio_set_pull_mode(ignore, GPIO_FLOATING);
gpio_pad_select_gpio(measure);
gpio_set_direction(measure, GPIO_MODE_DISABLE);
gpio_set_pull_mode(measure, GPIO_FLOATING);
// - Set "plus" to 1, "minus" to 0
gpio_config(&(gpio_config_t) {
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = (1ULL << plus) | (1ULL << minus)
});
gpio_set_level(plus, 1);
gpio_set_level(minus, 0);
}
static void setup_adc(gpio_num_t measure)
{
// Init ADC
adc1_channel_t channel = gpio_to_adc[measure];
adc_gpio_init(ADC_UNIT_1, channel);
adc1_config_width(ADC_WIDTH_BIT_10);
adc1_config_channel_atten(channel, ADC_ATTEN_DB_11);
}
static void insert_sort(int16_t array[], uint8_t size) {
uint8_t j;
int16_t save;
for (int i = 1; i < size; i++) {
save = array[i];
for (j = i; j >= 1 && save < array[j - 1]; j--)
array[j] = array[j - 1];
array[j] = save;
}
}
static void ad_touch_handler(void *arg)
{
(void) arg;
uint8_t i;
int16_t samples[NUMSAMPLES];
switch (state) {
case IDLE:
adcX = 0;
adcY = 0;
case SET_X :
setup_axis(yd, yu, xr, xl);
setup_adc(xr);
state = READ_X;
break;
case READ_X:
for (i = 0; i < NUMSAMPLES; i++)
samples[i] = adc1_get_raw(gpio_to_adc[xr]);
insert_sort(samples, NUMSAMPLES);
temp_x = samples[NUMSAMPLES / 2];
case SET_Y :
setup_axis(xl, xr, yd, yu);
setup_adc(yd);
state = READ_Y;
break;
case READ_Y:
for (i = 0; i < NUMSAMPLES; i++)
samples[i] = adc1_get_raw(gpio_to_adc[yd]);
insert_sort(samples, NUMSAMPLES);
temp_y = samples[NUMSAMPLES / 2];
case SET_Z1 :
setup_axis(yu, xl, yd, xr);
setup_adc(yd);
state = READ_Z1;
break;
case READ_Z1:
temp_z1 = adc1_get_raw(gpio_to_adc[yd]);
case SET_Z2 :
setup_axis(yu, xl, xr, yd);
setup_adc(yd);
state = READ_Z2;
break;
case READ_Z2:
temp_z2 = adc1_get_raw(gpio_to_adc[xr]);
if (temp_z1 < TOUCHSCREEN_RESISTIVE_PRESS_THRESHOLD) {
#if CONFIG_LV_TOUCH_XY_SWAP
adcX = temp_y;
adcY = temp_x;
#else
adcX = temp_x;
adcY = temp_y;
#endif
}
else {
adcX = -1;
adcY = -1;
}
state = SET_X;
//printf("x: %d y: %d z: %d\n", adcX, adcY, temp_z1 - temp_z2);
break;
}
return;
}
static int16_t TouchGetRawX(void)
{
int16_t x = adcX;
#if CONFIG_LV_TOUCH_INVERT_X
x = 1023 - x;
#endif
return x;
}
static int16_t TouchGetX(void)
{
int16_t result = TouchGetRawX();
if (result > 0) {
result = (int16_t)((((int32_t)_trC * result) + _trD) >> TOUCHSCREEN_RESISTIVE_CALIBRATION_SCALE_FACTOR);
}
printf("x: %d\n", result);
return (result);
}
static int16_t TouchGetRawY(void)
{
int16_t y = adcY;
#if CONFIG_LV_TOUCH_INVERT_Y
y = 1023 - y;
#endif
return y;
}
static int16_t TouchGetY(void)
{
int16_t result = TouchGetRawY();
if (result > 0) {
result = (int16_t)((((int32_t)_trA * result) + (int32_t)_trB) >> TOUCHSCREEN_RESISTIVE_CALIBRATION_SCALE_FACTOR);
}
printf("y: %d\n", result);
return (result);
}
/**
* Get the current position and state of the touchpad
* @param data store the read data here
* @return false: because no more data to be read
*/
bool adcraw_read(lv_indev_drv_t * drv, lv_indev_data_t * data)
{
static int16_t last_x = 0;
static int16_t last_y = 0;
int16_t x, y;
x = TouchGetX();
y = TouchGetY();
if ((x > 0) && (y > 0)) {
data->point.x = x;
data->point.y = y;
last_x = data->point.x;
last_y = data->point.y;
data->state = LV_INDEV_STATE_PR;
}
else {
data->point.x = last_x;
data->point.y = last_y;
data->state = LV_INDEV_STATE_REL;
}
return false;
}
#endif //CONFIG_LV_TOUCH_CONTROLLER_ADCRAW
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/adcraw.c | C | apache-2.0 | 8,130 |
/**
* @file ADCRAW.h
*/
#ifndef ADCRAW_H
#define ADCRAW_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
#include "driver/gpio.h"
#include "driver/adc.h"
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#define TOUCHSCREEN_RESISTIVE_PIN_YU CONFIG_LV_TOUCHSCREEN_RESSITIVE_PIN_YU // Y+ any gpio
#define TOUCHSCREEN_RESISTIVE_PIN_YD CONFIG_LV_TOUCHSCREEN_RESISTIVE_PIN_YD // Y- also ADC
#define TOUCHSCREEN_RESISTIVE_PIN_XL CONFIG_LV_TOUCHSCREEN_RESISTIVE_PIN_XL // X- any gpio
#define TOUCHSCREEN_RESISTIVE_PIN_XR CONFIG_LV_TOUCHSCREEN_RESISTIVE_PIN_XR // X+ also ADC
// Default calibration points
#define TOUCHCAL_ULX 29 // Upper Left X
#define TOUCHCAL_ULY 84 // Upper Left Y
#define TOUCHCAL_URX 828 // Upper Right X
#define TOUCHCAL_URY 60 // Upper Right Y
#define TOUCHCAL_LLX 29 // Lower Left X
#define TOUCHCAL_LLY 928 // Lower Left Y
#define TOUCHCAL_LRX 828 // Lower Right X
#define TOUCHCAL_LRY 928 // Lower Right Y
#define TOUCHSCREEN_RESISTIVE_PRESS_THRESHOLD 1023
/*GetMaxX Macro*/
#if CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
#define GetMaxX() (LV_HOR_RES_MAX - 1)
#else
#define GetMaxX() (LV_VER_RES_MAX - 1)
#endif
/*GetMaxY Macro*/
#if CONFIG_LV_DISPLAY_ORIENTATION_LANDSCAPE
#define GetMaxY() (LV_VER_RES_MAX - 1)
#else
#define GetMaxY() (LV_HOR_RES_MAX - 1)
#endif
#ifndef CONCAT3
#define _CONCAT3(a,b,c) a ## b ## c
#define CONCAT3(a,b,c) _CONCAT3(a,b,c)
#endif
#define GPIO_TO_ADC_ELEMENT(x) [x] = CONCAT3(ADC1_GPIO, x, _CHANNEL)
typedef enum {
IDLE,
SET_X,
SET_Y,
SET_Z1,
SET_Z2,
READ_X,
READ_Y,
READ_Z1,
READ_Z2
} TOUCH_STATES;
void adcraw_init(void);
bool adcraw_read(lv_indev_drv_t * drv, lv_indev_data_t * data);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* ADCRAW_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/adcraw.h | C | apache-2.0 | 1,826 |
/*
* Copyright © 2020 Wolfgang Christl
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the “Software”), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
* FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <esp_log.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include <lvgl.h>
#else
#include <lvgl/lvgl.h>
#endif
#include "ft6x36.h"
#include "lvgl_i2c/i2c_manager.h"
#define TAG "FT6X36"
ft6x36_status_t ft6x36_status;
uint8_t current_dev_addr; // set during init
esp_err_t ft6x06_i2c_read8(uint8_t slave_addr, uint8_t register_addr, uint8_t *data_buf) {
return lvgl_i2c_read(CONFIG_LV_I2C_TOUCH_PORT, slave_addr, register_addr, data_buf, 1);
}
/**
* @brief Read the FT6x36 gesture ID. Initialize first!
* @param dev_addr: I2C FT6x36 Slave address.
* @retval The gesture ID or 0x00 in case of failure
*/
uint8_t ft6x36_get_gesture_id() {
if (!ft6x36_status.inited) {
ESP_LOGE(TAG, "Init first!");
return 0x00;
}
uint8_t data_buf;
esp_err_t ret;
if ((ret = ft6x06_i2c_read8(current_dev_addr, FT6X36_GEST_ID_REG, &data_buf) != ESP_OK))
ESP_LOGE(TAG, "Error reading from device: %s", esp_err_to_name(ret));
return data_buf;
}
/**
* @brief Initialize for FT6x36 communication via I2C
* @param dev_addr: Device address on communication Bus (I2C slave address of FT6X36).
* @retval None
*/
void ft6x06_init(uint16_t dev_addr) {
ft6x36_status.inited = true;
current_dev_addr = dev_addr;
uint8_t data_buf;
esp_err_t ret;
ESP_LOGI(TAG, "Found touch panel controller");
if ((ret = ft6x06_i2c_read8(dev_addr, FT6X36_PANEL_ID_REG, &data_buf) != ESP_OK))
ESP_LOGE(TAG, "Error reading from device: %s",
esp_err_to_name(ret)); // Only show error the first time
ESP_LOGI(TAG, "\tDevice ID: 0x%02x", data_buf);
ft6x06_i2c_read8(dev_addr, FT6X36_CHIPSELECT_REG, &data_buf);
ESP_LOGI(TAG, "\tChip ID: 0x%02x", data_buf);
ft6x06_i2c_read8(dev_addr, FT6X36_DEV_MODE_REG, &data_buf);
ESP_LOGI(TAG, "\tDevice mode: 0x%02x", data_buf);
ft6x06_i2c_read8(dev_addr, FT6X36_FIRMWARE_ID_REG, &data_buf);
ESP_LOGI(TAG, "\tFirmware ID: 0x%02x", data_buf);
ft6x06_i2c_read8(dev_addr, FT6X36_RELEASECODE_REG, &data_buf);
ESP_LOGI(TAG, "\tRelease code: 0x%02x", data_buf);
}
/**
* @brief Get the touch screen X and Y positions values. Ignores multi touch
* @param drv:
* @param data: Store data here
* @retval Always false
*/
bool ft6x36_read(lv_indev_drv_t *drv, lv_indev_data_t *data) {
if (!ft6x36_status.inited) {
ESP_LOGE(TAG, "Init first!");
return 0x00;
}
uint8_t data_buf[5]; // 1 byte status, 2 bytes X, 2 bytes Y
static int16_t last_x = 0; // 12bit pixel value
static int16_t last_y = 0; // 12bit pixel value
esp_err_t ret = lvgl_i2c_read(CONFIG_LV_I2C_TOUCH_PORT, current_dev_addr, FT6X36_TD_STAT_REG, &data_buf[0], 5);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Error talking to touch IC: %s", esp_err_to_name(ret));
}
uint8_t touch_pnt_cnt = data_buf[0]; // Number of detected touch points
if (ret != ESP_OK || touch_pnt_cnt != 1) { // ignore no touch & multi touch
data->point.x = last_x;
data->point.y = last_y;
data->state = LV_INDEV_STATE_REL;
return false;
}
last_x = ((data_buf[1] & FT6X36_MSB_MASK) << 8) | (data_buf[2] & FT6X36_LSB_MASK);
last_y = ((data_buf[3] & FT6X36_MSB_MASK) << 8) | (data_buf[4] & FT6X36_LSB_MASK);
#if CONFIG_LV_FT6X36_INVERT_X
last_x = LV_HOR_RES - last_x;
#endif
#if CONFIG_LV_FT6X36_INVERT_Y
last_y = LV_VER_RES - last_y;
#endif
#if CONFIG_LV_FT6X36_SWAPXY
int16_t swap_buf = last_x;
last_x = last_y;
last_y = swap_buf;
#endif
data->point.x = last_x;
data->point.y = last_y;
data->state = LV_INDEV_STATE_PR;
ESP_LOGE(TAG, "X=%u Y=%u", data->point.x, data->point.y);
return false;
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/ft6x36.c | C | apache-2.0 | 4,984 |
#ifndef __FT6X06_H
/*
* Copyright © 2020 Wolfgang Christl
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the “Software”), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
* FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define __FT6X06_H
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define FT6236_I2C_SLAVE_ADDR 0x38
/* Maximum border values of the touchscreen pad that the chip can handle */
#define FT6X36_MAX_WIDTH ((uint16_t)800)
#define FT6X36_MAX_HEIGHT ((uint16_t)480)
/* Max detectable simultaneous touch points */
#define FT6X36_MAX_TOUCH_PNTS 2
/* Register of the current mode */
#define FT6X36_DEV_MODE_REG 0x00
/* Possible modes as of FT6X36_DEV_MODE_REG */
#define FT6X36_DEV_MODE_WORKING 0x00
#define FT6X36_DEV_MODE_FACTORY 0x04
#define FT6X36_DEV_MODE_MASK 0x70
#define FT6X36_DEV_MODE_SHIFT 4
/* Gesture ID register */
#define FT6X36_GEST_ID_REG 0x01
/* Possible values returned by FT6X36_GEST_ID_REG */
#define FT6X36_GEST_ID_NO_GESTURE 0x00
#define FT6X36_GEST_ID_MOVE_UP 0x10
#define FT6X36_GEST_ID_MOVE_RIGHT 0x14
#define FT6X36_GEST_ID_MOVE_DOWN 0x18
#define FT6X36_GEST_ID_MOVE_LEFT 0x1C
#define FT6X36_GEST_ID_ZOOM_IN 0x48
#define FT6X36_GEST_ID_ZOOM_OUT 0x49
/* Status register: stores number of active touch points (0, 1, 2) */
#define FT6X36_TD_STAT_REG 0x02
#define FT6X36_TD_STAT_MASK 0x0F
#define FT6X36_TD_STAT_SHIFT 0x00
/* Touch events */
#define FT6X36_TOUCH_EVT_FLAG_PRESS_DOWN 0x00
#define FT6X36_TOUCH_EVT_FLAG_LIFT_UP 0x01
#define FT6X36_TOUCH_EVT_FLAG_CONTACT 0x02
#define FT6X36_TOUCH_EVT_FLAG_NO_EVENT 0x03
#define FT6X36_TOUCH_EVT_FLAG_SHIFT 6
#define FT6X36_TOUCH_EVT_FLAG_MASK (3 << FT6X36_TOUCH_EVT_FLAG_SHIFT)
#define FT6X36_MSB_MASK 0x0F
#define FT6X36_MSB_SHIFT 0
#define FT6X36_LSB_MASK 0xFF
#define FT6X36_LSB_SHIFT 0
#define FT6X36_P1_XH_REG 0x03
#define FT6X36_P1_XL_REG 0x04
#define FT6X36_P1_YH_REG 0x05
#define FT6X36_P1_YL_REG 0x06
#define FT6X36_P1_WEIGHT_REG 0x07 /* Register reporting touch pressure - read only */
#define FT6X36_TOUCH_WEIGHT_MASK 0xFF
#define FT6X36_TOUCH_WEIGHT_SHIFT 0
#define FT6X36_P1_MISC_REG 0x08 /* Touch area register */
#define FT6X36_TOUCH_AREA_MASK (0x04 << 4) /* Values related to FT6X36_Pn_MISC_REG */
#define FT6X36_TOUCH_AREA_SHIFT 0x04
#define FT6X36_P2_XH_REG 0x09
#define FT6X36_P2_XL_REG 0x0A
#define FT6X36_P2_YH_REG 0x0B
#define FT6X36_P2_YL_REG 0x0C
#define FT6X36_P2_WEIGHT_REG 0x0D
#define FT6X36_P2_MISC_REG 0x0E
/* Threshold for touch detection */
#define FT6X36_TH_GROUP_REG 0x80
#define FT6X36_THRESHOLD_MASK 0xFF /* Values FT6X36_TH_GROUP_REG : threshold related */
#define FT6X36_THRESHOLD_SHIFT 0
#define FT6X36_TH_DIFF_REG 0x85 /* Filter function coefficients */
#define FT6X36_CTRL_REG 0x86 /* Control register */
#define FT6X36_CTRL_KEEP_ACTIVE_MODE 0x00 /* Will keep the Active mode when there is no touching */
#define FT6X36_CTRL_KEEP_AUTO_SWITCH_MONITOR_MODE 0x01 /* Switching from Active mode to Monitor mode automatically when there is no touching */
#define FT6X36_TIME_ENTER_MONITOR_REG 0x87 /* The time period of switching from Active mode to Monitor mode when there is no touching */
#define FT6X36_PERIOD_ACTIVE_REG 0x88 /* Report rate in Active mode */
#define FT6X36_PERIOD_MONITOR_REG 0x89 /* Report rate in Monitor mode */
#define FT6X36_RADIAN_VALUE_REG 0x91 /* The value of the minimum allowed angle while Rotating gesture mode */
#define FT6X36_OFFSET_LEFT_RIGHT_REG 0x92 /* Maximum offset while Moving Left and Moving Right gesture */
#define FT6X36_OFFSET_UP_DOWN_REG 0x93 /* Maximum offset while Moving Up and Moving Down gesture */
#define FT6X36_DISTANCE_LEFT_RIGHT_REG 0x94 /* Minimum distance while Moving Left and Moving Right gesture */
#define FT6X36_DISTANCE_UP_DOWN_REG 0x95 /* Minimum distance while Moving Up and Moving Down gesture */
#define FT6X36_LIB_VER_H_REG 0xA1 /* High 8-bit of LIB Version info */
#define FT6X36_LIB_VER_L_REG 0xA2 /* Low 8-bit of LIB Version info */
#define FT6X36_CHIPSELECT_REG 0xA3 /* 0x36 for ft6236; 0x06 for ft6206 */
#define FT6X36_POWER_MODE_REG 0xA5
#define FT6X36_FIRMWARE_ID_REG 0xA6
#define FT6X36_RELEASECODE_REG 0xAF
#define FT6X36_PANEL_ID_REG 0xA8
#define FT6X36_OPMODE_REG 0xBC
typedef struct {
bool inited;
} ft6x36_status_t;
/**
* @brief Initialize for FT6x36 communication via I2C
* @param dev_addr: Device address on communication Bus (I2C slave address of FT6X36).
* @retval None
*/
void ft6x06_init(uint16_t dev_addr);
uint8_t ft6x36_get_gesture_id();
/**
* @brief Get the touch screen X and Y positions values. Ignores multi touch
* @param drv:
* @param data: Store data here
* @retval Always false
*/
bool ft6x36_read(lv_indev_drv_t *drv, lv_indev_data_t *data);
#ifdef __cplusplus
}
#endif
#endif /* __FT6X06_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/ft6x36.h | C | apache-2.0 | 6,731 |
/*
* Copyright © 2021 Sturnus Inc.
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the “Software”), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
* FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <esp_log.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include <lvgl.h>
#else
#include <lvgl/lvgl.h>
#endif
#include "gt911.h"
#include "lvgl_i2c/i2c_manager.h"
#define TAG "GT911"
gt911_status_t gt911_status;
//TODO: handle multibyte read and refactor to just one read transaction
esp_err_t gt911_i2c_read(uint8_t slave_addr, uint16_t register_addr, uint8_t *data_buf, uint8_t len) {
return lvgl_i2c_read(CONFIG_LV_I2C_TOUCH_PORT, slave_addr, register_addr | I2C_REG_16, data_buf, len);
}
esp_err_t gt911_i2c_write8(uint8_t slave_addr, uint16_t register_addr, uint8_t data) {
uint8_t buffer = data;
return lvgl_i2c_write(CONFIG_LV_I2C_TOUCH_PORT, slave_addr, register_addr | I2C_REG_16, &buffer, 1);
}
/**
* @brief Initialize for GT911 communication via I2C
* @param dev_addr: Device address on communication Bus (I2C slave address of GT911).
* @retval None
*/
void gt911_init(uint8_t dev_addr) {
if (!gt911_status.inited) {
gt911_status.i2c_dev_addr = dev_addr;
uint8_t data_buf;
esp_err_t ret;
ESP_LOGI(TAG, "Checking for GT911 Touch Controller");
if ((ret = gt911_i2c_read(dev_addr, GT911_PRODUCT_ID1, &data_buf, 1) != ESP_OK)) {
ESP_LOGE(TAG, "Error reading from device: %s",
esp_err_to_name(ret)); // Only show error the first time
return;
}
// Read 4 bytes for Product ID in ASCII
for (int i = 0; i < GT911_PRODUCT_ID_LEN; i++) {
gt911_i2c_read(dev_addr, (GT911_PRODUCT_ID1 + i), (uint8_t *)&(gt911_status.product_id[i]), 1);
}
ESP_LOGI(TAG, "\tProduct ID: %s", gt911_status.product_id);
gt911_i2c_read(dev_addr, GT911_VENDOR_ID, &data_buf, 1);
ESP_LOGI(TAG, "\tVendor ID: 0x%02x", data_buf);
gt911_i2c_read(dev_addr, GT911_X_COORD_RES_L, &data_buf, 1);
gt911_status.max_x_coord = data_buf;
gt911_i2c_read(dev_addr, GT911_X_COORD_RES_H, &data_buf, 1);
gt911_status.max_x_coord |= ((uint16_t)data_buf << 8);
ESP_LOGI(TAG, "\tX Resolution: %d", gt911_status.max_x_coord);
gt911_i2c_read(dev_addr, GT911_Y_COORD_RES_L, &data_buf, 1);
gt911_status.max_y_coord = data_buf;
gt911_i2c_read(dev_addr, GT911_Y_COORD_RES_H, &data_buf, 1);
gt911_status.max_y_coord |= ((uint16_t)data_buf << 8);
ESP_LOGI(TAG, "\tY Resolution: %d", gt911_status.max_y_coord);
gt911_status.inited = true;
}
}
/**
* @brief Get the touch screen X and Y positions values. Ignores multi touch
* @param drv:
* @param data: Store data here
* @retval Always false
*/
bool gt911_read(lv_indev_drv_t *drv, lv_indev_data_t *data) {
uint8_t touch_pnt_cnt; // Number of detected touch points
static int16_t last_x = 0; // 12bit pixel value
static int16_t last_y = 0; // 12bit pixel value
uint8_t data_buf;
uint8_t status_reg;
gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_STATUS_REG, &status_reg, 1);
// ESP_LOGI(TAG, "\tstatus: 0x%02x", status_reg);
touch_pnt_cnt = status_reg & 0x0F;
if ((status_reg & 0x80) || (touch_pnt_cnt < 6)) {
//Reset Status Reg Value
gt911_i2c_write8(gt911_status.i2c_dev_addr, GT911_STATUS_REG, 0x00);
}
if (touch_pnt_cnt != 1) { // ignore no touch & multi touch
data->point.x = last_x;
data->point.y = last_y;
data->state = LV_INDEV_STATE_REL;
return false;
}
// gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_TRACK_ID1, &data_buf, 1);
// ESP_LOGI(TAG, "\ttrack_id: %d", data_buf);
gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_PT1_X_COORD_L, &data_buf, 1);
last_x = data_buf;
gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_PT1_X_COORD_H, &data_buf, 1);
last_x |= ((uint16_t)data_buf << 8);
gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_PT1_Y_COORD_L, &data_buf, 1);
last_y = data_buf;
gt911_i2c_read(gt911_status.i2c_dev_addr, GT911_PT1_Y_COORD_H, &data_buf, 1);
last_y |= ((uint16_t)data_buf << 8);
#if CONFIG_LV_GT911_INVERT_X
last_x = gt911_status.max_x_coord - last_x;
#endif
#if CONFIG_LV_GT911_INVERT_Y
last_y = gt911_status.max_y_coord - last_y;
#endif
#if CONFIG_LV_GT911_SWAPXY
int16_t swap_buf = last_x;
last_x = last_y;
last_y = swap_buf;
#endif
data->point.x = last_x;
data->point.y = last_y;
data->state = LV_INDEV_STATE_PR;
ESP_LOGI(TAG, "X=%u Y=%u", data->point.x, data->point.y);
ESP_LOGV(TAG, "X=%u Y=%u", data->point.x, data->point.y);
return false;
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/gt911.c | C | apache-2.0 | 5,823 |
#ifndef __GT911_H
/*
* Copyright © 2021 Sturnus Inc.
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the “Software”), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
* to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
* FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define __GT911_H
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#define GT911_I2C_SLAVE_ADDR 0x5D
#define GT911_PRODUCT_ID_LEN 4
/* Register Map of GT911 */
#define GT911_PRODUCT_ID1 0x8140
#define GT911_PRODUCT_ID2 0x8141
#define GT911_PRODUCT_ID3 0x8142
#define GT911_PRODUCT_ID4 0x8143
#define GT911_FIRMWARE_VER_L 0x8144
#define GT911_FIRMWARE_VER_H 0x8145
#define GT911_X_COORD_RES_L 0x8146
#define GT911_X_COORD_RES_H 0x8147
#define GT911_Y_COORD_RES_L 0x8148
#define GT911_Y_COORD_RES_H 0x8149
#define GT911_VENDOR_ID 0x814A
#define GT911_STATUS_REG 0x814E
#define GT911_STATUS_REG_BUF 0x80
#define GT911_STATUS_REG_LARGE 0x40
#define GT911_STATUS_REG_PROX_VALID 0x20
#define GT911_STATUS_REG_HAVEKEY 0x10
#define GT911_STATUS_REG_PT_MASK 0x0F
#define GT911_TRACK_ID1 0x814F
#define GT911_PT1_X_COORD_L 0x8150
#define GT911_PT1_X_COORD_H 0x8151
#define GT911_PT1_Y_COORD_L 0x8152
#define GT911_PT1_Y_COORD_H 0x8153
#define GT911_PT1_X_SIZE_L 0x8154
#define GT911_PT1_X_SIZE_H 0x8155
typedef struct {
bool inited;
char product_id[GT911_PRODUCT_ID_LEN];
uint16_t max_x_coord;
uint16_t max_y_coord;
uint8_t i2c_dev_addr;
} gt911_status_t;
/**
* @brief Initialize for GT911 communication via I2C
* @param dev_addr: Device address on communication Bus (I2C slave address of GT911).
* @retval None
*/
void gt911_init(uint8_t dev_addr);
/**
* @brief Get the touch screen X and Y positions values. Ignores multi touch
* @param drv:
* @param data: Store data here
* @retval Always false
*/
bool gt911_read(lv_indev_drv_t *drv, lv_indev_data_t *data);
#ifdef __cplusplus
}
#endif
#endif /* __GT911_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/gt911.h | C | apache-2.0 | 3,238 |
/**
* @file RA8875_TOUCH.c
*/
/*********************
* INCLUDES
*********************/
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <stddef.h>
#include "ra8875_touch.h"
#include "../lvgl_tft/ra8875.h"
#ifndef CONFIG_LV_TFT_DISPLAY_CONTROLLER_RA8875
#error "Display controller must be RA8875"
#endif
/*********************
* DEFINES
*********************/
#define DEBUG false
#define TAG "RA8875-Touch"
#define DIV_ROUND_UP(n, d) (((n)+(d)-1)/(d))
#define INTC2_TP_INT (0x04)
#define TPCR0_ADC_TIMING ((CONFIG_LV_TOUCH_RA8875_SAMPLE_TIME << 4) | CONFIG_LV_TOUCH_RA8875_ADC_CLOCK)
#if LVGL_TOUCH_RA8875_WAKEUP_ENABLE
#define TPCR0_VAL (0x08 | TPCR0_ADC_TIMING)
#else
#define TPCR0_VAL (TPCR0_ADC_TIMING)
#endif
#if LVGL_TOUCH_RA8875_EXTERNAL_VREF
#if LVGL_TOUCH_RA8875_DEBOUNCE_ENABLE
#define TPCR1_VAL (0x24)
#else
#define TPCR1_VAL (0x20)
#endif
#else
#if LVGL_TOUCH_RA8875_DEBOUNCE_ENABLE
#define TPCR1_VAL (0x04)
#else
#define TPCR1_VAL (0x00)
#endif
#endif
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void ra8875_corr(int * x, int * y);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void ra8875_touch_init(void)
{
struct {
uint8_t cmd; // Register address of command
uint8_t data; // Value to write to register
} init_cmds[] = {
{RA8875_REG_TPCR0, TPCR0_VAL}, // Touch Panel Control Register 0 (TPCR0)
{RA8875_REG_TPCR1, TPCR1_VAL}, // Touch Panel Control Register 1 (TPCR1)
};
#define INIT_CMDS_SIZE (sizeof(init_cmds)/sizeof(init_cmds[0]))
ESP_LOGI(TAG, "Initializing RA8875 Touch...");
// Send all the commands
for (unsigned int i = 0; i < INIT_CMDS_SIZE; i++) {
ra8875_write_cmd(init_cmds[i].cmd, init_cmds[i].data);
}
ra8875_touch_enable(true);
}
void ra8875_touch_enable(bool enable)
{
ESP_LOGI(TAG, "%s touch.", enable ? "Enabling" : "Disabling");
uint8_t val = enable ? (0x80 | TPCR0_VAL) : (TPCR0_VAL);
ra8875_write_cmd(RA8875_REG_TPCR0, val);
}
/**
* Get the current position and state of the touchscreen
* @param data store the read data here
* @return false: because no more data to be read
*/
bool ra8875_touch_read(lv_indev_drv_t * drv, lv_indev_data_t * data)
{
static int x = 0;
static int y = 0;
int intr = ra8875_read_cmd(RA8875_REG_INTC2); // Interrupt Control Register2 (INTC2)
data->state = (intr & INTC2_TP_INT) ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL;
if (data->state == LV_INDEV_STATE_PR) {
x = ra8875_read_cmd(RA8875_REG_TPXH); // Touch Panel X High Byte Data Register (TPXH)
y = ra8875_read_cmd(RA8875_REG_TPYH); // Touch Panel Y High Byte Data Register (TPYH)
int xy = ra8875_read_cmd(RA8875_REG_TPXYL); // Touch Panel X/Y Low Byte Data Register (TPXYL)
x = (x << 2) | (xy & 0x03);
y = (y << 2) | ((xy >> 2) & 0x03);
#if DEBUG
ESP_LOGI(TAG, "Touch Poll Raw: %d,%d", x, y);
#endif
// Convert to display coordinates
ra8875_corr(&x, &y);
// Clear interrupt
ra8875_write_cmd(RA8875_REG_INTC2, INTC2_TP_INT); // Interrupt Control Register2 (INTC2)
}
data->point.x = x;
data->point.y = y;
#if DEBUG
ESP_LOGI(TAG, "Touch Poll - Event: %d; %d,%d", data->state, data->point.x, data->point.y);
#endif
return false;
}
/**********************
* STATIC FUNCTIONS
**********************/
static void ra8875_corr(int * x, int * y)
{
#if RA8875_XY_SWAP != 0
int tmp = *x;
*x = *y;
*y = tmp;
#endif
if ((*x) <= RA8875_X_MIN) {
(*x) = 0;
} else if ((*x) >= RA8875_X_MAX) {
(*x) = LV_HOR_RES-1;
} else {
(*x) = (((*x) - RA8875_X_MIN) * (LV_HOR_RES-1)) / (RA8875_X_MAX - RA8875_X_MIN);
}
if ((*y) <= RA8875_Y_MIN) {
(*y) = 0;
} else if ((*y) >= RA8875_Y_MAX) {
(*y) = LV_VER_RES-1;
} else {
(*y) = (((*y) - RA8875_Y_MIN) * (LV_VER_RES-1)) / (RA8875_Y_MAX - RA8875_Y_MIN);
}
#if RA8875_X_INV != 0
(*x) = (LV_HOR_RES-1) - (*x);
#endif
#if RA8875_Y_INV != 0
(*y) = (LV_VER_RES-1) - (*y);
#endif
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/ra8875_touch.c | C | apache-2.0 | 4,607 |
/**
* @file RA8875_TOUCH.h
*/
#ifndef RA8875X_TOUCH__H
#define RA8875X_TOUCH__H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
#define RA8875_X_MIN CONFIG_LV_TOUCH_X_MIN
#define RA8875_Y_MIN CONFIG_LV_TOUCH_Y_MIN
#define RA8875_X_MAX CONFIG_LV_TOUCH_X_MAX
#define RA8875_Y_MAX CONFIG_LV_TOUCH_Y_MAX
#define RA8875_X_INV CONFIG_LV_TOUCH_INVERT_X
#define RA8875_Y_INV CONFIG_LV_TOUCH_INVERT_Y
#define RA8875_XY_SWAP CONFIG_LV_TOUCH_XY_SWAP
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void ra8875_touch_init(void);
void ra8875_touch_enable(bool enable);
bool ra8875_touch_read(lv_indev_drv_t * drv, lv_indev_data_t * data);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* RA8875_TOUCH__H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/ra8875_touch.h | C | apache-2.0 | 1,151 |
/**
* @file STMPE610.c
*/
/*********************
* INCLUDES
*********************/
#include "stmpe610.h"
#include "esp_system.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "tp_spi.h"
#include <stddef.h>
/*********************
* DEFINES
*********************/
#define TAG "STMPE610"
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static void write_8bit_reg(uint8_t reg, uint8_t val);
static uint16_t read_16bit_reg(uint8_t reg);
static uint8_t read_8bit_reg(uint8_t reg);
static void read_data(int16_t *x, int16_t *y, uint8_t *z);
static bool buffer_empty();
static void adjust_data(int16_t * x, int16_t * y);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Initialize the STMPE610
*/
void stmpe610_init(void)
{
uint8_t u8;
uint16_t u16;
ESP_LOGI(TAG, "Initialization.");
// Get the initial SPI configuration
//u8 = read_8bit_reg(STMPE_SPI_CFG);
//ESP_LOGI(TAG, "SPI_CFG = 0x%x", u8);
// Attempt a software reset
write_8bit_reg(STMPE_SYS_CTRL1, STMPE_SYS_CTRL1_RESET);
vTaskDelay(10 / portTICK_RATE_MS);
// Reset the SPI configuration, making sure auto-increment is set
u8 = read_8bit_reg(STMPE_SPI_CFG);
write_8bit_reg(STMPE_SPI_CFG, u8 | STMPE_SPI_CFG_AA);
u8 = read_8bit_reg(STMPE_SPI_CFG);
ESP_LOGI(TAG, "SPI_CFG = 0x%x", u8);
// Verify SPI communication
u16 = read_16bit_reg(STMPE_CHIP_ID);
if (u16 != 0x811) {
ESP_LOGE(TAG, "Incorrect version: 0x%x", u16);
}
write_8bit_reg(STMPE_SYS_CTRL2, 0x00); // Disable clocks
write_8bit_reg(STMPE_TSC_CTRL, 0); // Disable to allow writing
write_8bit_reg(STMPE_TSC_CTRL,
STEMP_TSC_CTRL_TRACK_0 |
STMPE_TSC_CTRL_XYZ |
STMPE_TSC_CTRL_EN);
write_8bit_reg(STMPE_TSC_CFG, STMPE_TSC_CFG_4SAMPLE |
STMPE_TSC_CFG_DELAY_1MS |
STMPE_TSC_CFG_SETTLE_1MS);
write_8bit_reg(STMPE_TSC_FRACTION_Z, 0x7);
write_8bit_reg(STMPE_TSC_I_DRIVE, STMPE_TSC_I_DRIVE_50MA);
write_8bit_reg(STMPE_SYS_CTRL2, 0x04); // GPIO clock off, TSC clock on, ADC clock on
write_8bit_reg(STMPE_ADC_CTRL1, STMPE_ADC_CTRL1_12BIT | STMPE_ADC_CTRL1_80CLK);
write_8bit_reg(STMPE_ADC_CTRL2, STMPE_ADC_CTRL2_3_25MHZ);
write_8bit_reg(STMPE_GPIO_ALT_FUNCT, 0x00); // Disable GPIO
write_8bit_reg(STMPE_FIFO_TH, 1); // Set FIFO threshold
write_8bit_reg(STMPE_FIFO_STA, STMPE_FIFO_STA_RESET); // Assert FIFO reset
write_8bit_reg(STMPE_FIFO_STA, 0); // Deassert FIFO reset
write_8bit_reg(STMPE_INT_EN, 0x00); // No interrupts
write_8bit_reg(STMPE_INT_STA, 0xFF); // reset all ints
}
/**
* Get the current position and state of the touchpad
* @param data store the read data here
* @return false: because no more data to be read
*/
bool stmpe610_read(lv_indev_drv_t * drv, lv_indev_data_t * data)
{
static int16_t last_x = 0;
static int16_t last_y = 0;
bool valid = true;
int c = 0;
int16_t x = 0;
int16_t y = 0;
uint8_t z;
if ((read_8bit_reg(STMPE_TSC_CTRL) & STMPE_TSC_TOUCHED) == STMPE_TSC_TOUCHED) {
// Making sure that we read all data and return the latest point
while (!buffer_empty()) {
read_data(&x, &y, &z);
c++;
}
if (c > 0) {
//ESP_LOGI(TAG, "%d: %d %d %d", c, x, y, z);
adjust_data(&x, &y);
last_x = x;
last_y = y;
//ESP_LOGI(TAG, " ==> %d %d", x, y);
}
z = read_8bit_reg(STMPE_INT_STA); // Clear interrupts
z = read_8bit_reg(STMPE_FIFO_STA);
if ((z & STMPE_FIFO_STA_OFLOW) == STMPE_FIFO_STA_OFLOW) {
// Clear the FIFO if we discover an overflow
write_8bit_reg(STMPE_FIFO_STA, STMPE_FIFO_STA_RESET);
write_8bit_reg(STMPE_FIFO_STA, 0); // unreset
ESP_LOGE(TAG, "Fifo overflow");
}
}
if (c == 0) {
x = last_x;
y = last_y;
valid = false;
}
data->point.x = (int16_t) x;
data->point.y = (int16_t) y;
data->state = valid == false ? LV_INDEV_STATE_REL : LV_INDEV_STATE_PR;
return false;
}
/**********************
* STATIC FUNCTIONS
**********************/
static void write_8bit_reg(uint8_t reg, uint8_t val)
{
uint8_t data_send[2];
data_send[0] = reg;
data_send[1] = val;
tp_spi_write_reg(data_send, 2);
}
static uint16_t read_16bit_reg(uint8_t reg)
{
uint8_t data_recv[2];
tp_spi_read_reg(0x80 | reg, data_recv, 2);
return data_recv[0] << 8 | data_recv[1];
}
static uint8_t read_8bit_reg(uint8_t reg)
{
uint8_t data_recv;
tp_spi_read_reg(0x80 | reg, &data_recv, 1);
return data_recv;
}
static void read_data(int16_t *x, int16_t *y, uint8_t *z)
{
*x = read_16bit_reg(STMPE_TSC_DATA_X);
*y = read_16bit_reg(STMPE_TSC_DATA_Y);
*z = read_8bit_reg(STMPE_TSC_DATA_Z);
}
static bool buffer_empty()
{
return ((read_8bit_reg(STMPE_FIFO_STA) & STMPE_FIFO_STA_EMPTY) == STMPE_FIFO_STA_EMPTY);
}
static void adjust_data(int16_t * x, int16_t * y)
{
#if STMPE610_XY_SWAP != 0
int16_t swap_tmp;
swap_tmp = *x;
*x = *y;
*y = swap_tmp;
#endif
if((*x) > STMPE610_X_MIN)(*x) -= STMPE610_X_MIN;
else(*x) = 0;
if((*y) > STMPE610_Y_MIN)(*y) -= STMPE610_Y_MIN;
else(*y) = 0;
(*x) = (uint32_t)((uint32_t)(*x) * LV_HOR_RES) /
(STMPE610_X_MAX - STMPE610_X_MIN);
(*y) = (uint32_t)((uint32_t)(*y) * LV_VER_RES) /
(STMPE610_Y_MAX - STMPE610_Y_MIN);
#if STMPE610_X_INV != 0
(*x) = LV_HOR_RES - (*x);
#endif
#if STMPE610_Y_INV != 0
(*y) = LV_VER_RES - (*y);
#endif
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/stmpe610.c | C | apache-2.0 | 5,798 |
/**
* @file STMPE610.h
*/
#ifndef STMPE610_H
#define STMPE610_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
/** 16-bit Chip Version **/
#define STMPE_CHIP_ID 0x00
/** Reset Control **/
#define STMPE_SYS_CTRL1 0x03
#define STMPE_SYS_CTRL1_RESET 0x02
/** Clock Contrl **/
#define STMPE_SYS_CTRL2 0x04
/** SPI Config **/
#define STMPE_SPI_CFG 0x08
#define STMPE_SPI_CFG_MODE0 0x00
#define STMPE_SPI_CFG_MODE1 0x01
#define STMPE_SPI_CFG_MODE2 0x02
#define STMPE_SPI_CFG_MODE3 0x03
#define STMPE_SPI_CFG_AA 0x04
/** Touchscreen controller setup **/
#define STMPE_TSC_CTRL 0x40
#define STMPE_TSC_CTRL_EN 0x01
#define STMPE_TSC_CTRL_XYZ 0x00
#define STMPE_TSC_CTRL_XY 0x02
#define STEMP_TSC_CTRL_TRACK_0 0x00
#define STEMP_TSC_CTRL_TRACK_4 0x10
#define STEMP_TSC_CTRL_TRACK_8 0x20
#define STEMP_TSC_CTRL_TRACK_16 0x30
#define STEMP_TSC_CTRL_TRACK_32 0x40
#define STEMP_TSC_CTRL_TRACK_64 0x50
#define STEMP_TSC_CTRL_TRACK_92 0x60
#define STEMP_TSC_CTRL_TRACK_127 0x70
#define STMPE_TSC_TOUCHED 0x80
/** Interrupt control **/
#define STMPE_INT_CTRL 0x09
#define STMPE_INT_CTRL_POL_HIGH 0x04
#define STMPE_INT_CTRL_POL_LOW 0x00
#define STMPE_INT_CTRL_EDGE 0x02
#define STMPE_INT_CTRL_LEVEL 0x00
#define STMPE_INT_CTRL_ENABLE 0x01
#define STMPE_INT_CTRL_DISABLE 0x00
/** Interrupt enable **/
#define STMPE_INT_EN 0x0A
#define STMPE_INT_EN_TOUCHDET 0x01
#define STMPE_INT_EN_FIFOTH 0x02
#define STMPE_INT_EN_FIFOOF 0x04
#define STMPE_INT_EN_FIFOFULL 0x08
#define STMPE_INT_EN_FIFOEMPTY 0x10
#define STMPE_INT_EN_ADC 0x40
#define STMPE_INT_EN_GPIO 0x80
/** Interrupt status **/
#define STMPE_INT_STA 0x0B
#define STMPE_INT_STA_TOUCHDET 0x01
/** ADC control **/
#define STMPE_ADC_CTRL1 0x20
#define STMPE_ADC_CTRL1_INT 0x00
#define STMPE_ADC_CTRL1_EXT 0x02
#define STMPE_ADC_CTRL1_12BIT 0x08
#define STMPE_ADC_CTRL1_10BIT 0x00
#define STMPE_ADC_CTRL1_36CLK 0x00
#define STMPE_ADC_CTRL1_44CLK 0x10
#define STMPE_ADC_CTRL1_56CLK 0x20
#define STMPE_ADC_CTRL1_64CLK 0x30
#define STMPE_ADC_CTRL1_80CLK 0x40
#define STMPE_ADC_CTRL1_96CLK 0x50
#define STMPE_ADC_CTRL1_124CLK 0x60
/** ADC control **/
#define STMPE_ADC_CTRL2 0x21
#define STMPE_ADC_CTRL2_1_625MHZ 0x00
#define STMPE_ADC_CTRL2_3_25MHZ 0x01
#define STMPE_ADC_CTRL2_6_5MHZ 0x02
/** Touchscreen controller configuration **/
#define STMPE_TSC_CFG 0x41
#define STMPE_TSC_CFG_1SAMPLE 0x00
#define STMPE_TSC_CFG_2SAMPLE 0x40
#define STMPE_TSC_CFG_4SAMPLE 0x80
#define STMPE_TSC_CFG_8SAMPLE 0xC0
#define STMPE_TSC_CFG_DELAY_10US 0x00
#define STMPE_TSC_CFG_DELAY_50US 0x08
#define STMPE_TSC_CFG_DELAY_100US 0x10
#define STMPE_TSC_CFG_DELAY_500US 0x18
#define STMPE_TSC_CFG_DELAY_1MS 0x20
#define STMPE_TSC_CFG_DELAY_5MS 0x28
#define STMPE_TSC_CFG_DELAY_10MS 0x30
#define STMPE_TSC_CFG_DELAY_50MS 0x38
#define STMPE_TSC_CFG_SETTLE_10US 0x00
#define STMPE_TSC_CFG_SETTLE_100US 0x01
#define STMPE_TSC_CFG_SETTLE_500US 0x02
#define STMPE_TSC_CFG_SETTLE_1MS 0x03
#define STMPE_TSC_CFG_SETTLE_5MS 0x04
#define STMPE_TSC_CFG_SETTLE_10MS 0x05
#define STMPE_TSC_CFG_SETTLE_50MS 0x06
#define STMPE_TSC_CFG_SETTLE_100MS 0x07
/** FIFO level to generate interrupt **/
#define STMPE_FIFO_TH 0x4A
/** Current filled level of FIFO **/
#define STMPE_FIFO_SIZE 0x4C
/** Current status of FIFO **/
#define STMPE_FIFO_STA 0x4B
#define STMPE_FIFO_STA_RESET 0x01
#define STMPE_FIFO_STA_OFLOW 0x80
#define STMPE_FIFO_STA_FULL 0x40
#define STMPE_FIFO_STA_EMPTY 0x20
#define STMPE_FIFO_STA_THTRIG 0x10
/** Touchscreen controller drive I **/
#define STMPE_TSC_I_DRIVE 0x58
#define STMPE_TSC_I_DRIVE_20MA 0x00
#define STMPE_TSC_I_DRIVE_50MA 0x01
/** Data port for TSC data address **/
#define STMPE_TSC_DATA_X 0x4D
#define STMPE_TSC_DATA_Y 0x4F
#define STMPE_TSC_DATA_Z 0x51
#define STMPE_TSC_FRACTION_Z 0x56
/** GPIO **/
#define STMPE_GPIO_SET_PIN 0x10
#define STMPE_GPIO_CLR_PIN 0x11
#define STMPE_GPIO_DIR 0x13
#define STMPE_GPIO_ALT_FUNCT 0x17
/** Calibration Constants **/
#define STMPE610_X_MIN CONFIG_LV_TOUCH_X_MIN
#define STMPE610_Y_MIN CONFIG_LV_TOUCH_Y_MIN
#define STMPE610_X_MAX CONFIG_LV_TOUCH_X_MAX
#define STMPE610_Y_MAX CONFIG_LV_TOUCH_Y_MAX
#define STMPE610_XY_SWAP CONFIG_LV_TOUCH_XY_SWAP
#define STMPE610_X_INV CONFIG_LV_TOUCH_INVERT_X
#define STMPE610_Y_INV CONFIG_LV_TOUCH_INVERT_Y
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void stmpe610_init(void);
bool stmpe610_read(lv_indev_drv_t * drv, lv_indev_data_t * data);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* STMPE610_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/stmpe610.h | C | apache-2.0 | 4,894 |
/**
* @file touch_driver.c
*/
#include "touch_driver.h"
#include "tp_spi.h"
#include "ft6x36.h"
void touch_driver_init(void)
{
#if defined (CONFIG_LV_TOUCH_CONTROLLER_XPT2046)
xpt2046_init();
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT6X06)
ft6x06_init(FT6236_I2C_SLAVE_ADDR);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_STMPE610)
stmpe610_init();
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_ADCRAW)
adcraw_init();
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
/* nothing to do */
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_RA8875)
ra8875_touch_init();
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_GT911)
gt911_init(GT911_I2C_SLAVE_ADDR);
#endif
}
#if LVGL_VERSION_MAJOR >= 8
void touch_driver_read(lv_indev_drv_t *drv, lv_indev_data_t *data)
#else
bool touch_driver_read(lv_indev_drv_t *drv, lv_indev_data_t *data)
#endif
{
bool res = false;
#if defined (CONFIG_LV_TOUCH_CONTROLLER_XPT2046)
res = xpt2046_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT6X06)
res = ft6x36_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_STMPE610)
res = stmpe610_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_ADCRAW)
res = adcraw_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
res = FT81x_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_RA8875)
res = ra8875_touch_read(drv, data);
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_GT911)
res = gt911_read(drv, data);
#endif
#if LVGL_VERSION_MAJOR >= 8
data->continue_reading = res;
#else
return res;
#endif
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/touch_driver.c | C | apache-2.0 | 1,574 |
/**
* @file touch_driver.h
*/
#ifndef TOUCH_DRIVER_H
#define TOUCH_DRIVER_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
#if defined (CONFIG_LV_TOUCH_CONTROLLER_XPT2046)
#include "xpt2046.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT6X06)
#include "ft6x36.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_STMPE610)
#include "stmpe610.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_ADCRAW)
#include "adcraw.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_FT81X)
#include "FT81x.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_RA8875)
#include "ra8875_touch.h"
#elif defined (CONFIG_LV_TOUCH_CONTROLLER_GT911)
#include "gt911.h"
#endif
/*********************
* DEFINES
*********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void touch_driver_init(void);
#if LVGL_VERSION_MAJOR >= 8
void touch_driver_read(lv_indev_drv_t *drv, lv_indev_data_t *data);
#else
bool touch_driver_read(lv_indev_drv_t *drv, lv_indev_data_t *data);
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* TOUCH_DRIVER_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/touch_driver.h | C | apache-2.0 | 1,232 |
/**
* @file tp_spi.c
*
*/
/*********************
* INCLUDES
*********************/
#include "tp_spi.h"
#include "touch_driver.h"
#include "esp_system.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include <string.h>
#include "../lvgl_helpers.h"
#include "../lvgl_spi_conf.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
static spi_device_handle_t spi;
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void tp_spi_add_device_config(spi_host_device_t host, spi_device_interface_config_t *devcfg)
{
esp_err_t ret=spi_bus_add_device(host, devcfg, &spi);
assert(ret==ESP_OK);
}
void tp_spi_add_device(spi_host_device_t host)
{
spi_device_interface_config_t devcfg={
.clock_speed_hz = SPI_TOUCH_CLOCK_SPEED_HZ,
.mode = SPI_TOUCH_SPI_MODE,
.spics_io_num=TP_SPI_CS, //CS pin
.queue_size=1,
.pre_cb=NULL,
.post_cb=NULL,
.command_bits = 8,
.address_bits = 0,
.dummy_bits = 0,
.flags = SPI_DEVICE_HALFDUPLEX | SPI_DEVICE_NO_DUMMY,
};
//Attach the Touch controller to the SPI bus
tp_spi_add_device_config(host, &devcfg);
}
void tp_spi_xchg(uint8_t* data_send, uint8_t* data_recv, uint8_t byte_count)
{
spi_transaction_t t = {
.length = byte_count * 8, // SPI transaction length is in bits
.tx_buffer = data_send,
.rx_buffer = data_recv};
esp_err_t ret = spi_device_transmit(spi, &t);
assert(ret == ESP_OK);
}
void tp_spi_write_reg(uint8_t* data, uint8_t byte_count)
{
spi_transaction_t t = {
.length = byte_count * 8,
.tx_buffer = data,
.flags = 0
};
esp_err_t ret = spi_device_transmit(spi, &t);
assert(ret == ESP_OK);
}
void tp_spi_read_reg(uint8_t reg, uint8_t* data, uint8_t byte_count)
{
spi_transaction_t t = {
.length = (byte_count + sizeof(reg)) * 8,
.rxlength = byte_count * 8,
.cmd = reg,
.rx_buffer = data,
.flags = 0
};
// Read - send first byte as command
esp_err_t ret = spi_device_transmit(spi, &t);
assert(ret == ESP_OK);
}
/**********************
* STATIC FUNCTIONS
**********************/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/tp_spi.c | C | apache-2.0 | 2,382 |
/**
* @file tp_spi.h
*
*/
#ifndef TP_SPI_H
#define TP_SPI_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <driver/spi_master.h>
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void tp_spi_add_device(spi_host_device_t host);
void tp_spi_add_device_config(spi_host_device_t host, spi_device_interface_config_t *config);
void tp_spi_xchg(uint8_t* data_send, uint8_t* data_recv, uint8_t byte_count);
void tp_spi_write_reg(uint8_t* data, uint8_t byte_count);
void tp_spi_read_reg(uint8_t reg, uint8_t* data, uint8_t byte_count);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*TP_SPI_H*/
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/tp_spi.h | C | apache-2.0 | 903 |
/**
* @file XPT2046.c
*
*/
/*********************
* INCLUDES
*********************/
#include "xpt2046.h"
#include "esp_system.h"
#include "esp_log.h"
#include "driver/gpio.h"
#include "tp_spi.h"
#include <stddef.h>
/*********************
* DEFINES
*********************/
#define TAG "XPT2046"
#define CMD_X_READ 0b10010000 // NOTE: XPT2046 data sheet says this is actually Y
#define CMD_Y_READ 0b11010000 // NOTE: XPT2046 data sheet says this is actually X
#define CMD_Z1_READ 0b10110000
#define CMD_Z2_READ 0b11000000
/**********************
* TYPEDEFS
**********************/
typedef enum {
TOUCH_NOT_DETECTED = 0,
TOUCH_DETECTED = 1,
} xpt2046_touch_detect_t;
/**********************
* STATIC PROTOTYPES
**********************/
static void xpt2046_corr(int16_t * x, int16_t * y);
static void xpt2046_avg(int16_t * x, int16_t * y);
static int16_t xpt2046_cmd(uint8_t cmd);
static xpt2046_touch_detect_t xpt2048_is_touch_detected();
/**********************
* STATIC VARIABLES
**********************/
int16_t avg_buf_x[XPT2046_AVG];
int16_t avg_buf_y[XPT2046_AVG];
uint8_t avg_last;
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Initialize the XPT2046
*/
void xpt2046_init(void)
{
ESP_LOGI(TAG, "XPT2046 Initialization");
#if XPT2046_TOUCH_IRQ || XPT2046_TOUCH_IRQ_PRESS
gpio_config_t irq_config = {
.pin_bit_mask = BIT64(XPT2046_IRQ),
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
esp_err_t ret = gpio_config(&irq_config);
assert(ret == ESP_OK);
#endif
}
/**
* Get the current position and state of the touchpad
* @param data store the read data here
* @return false: because no more data to be read
*/
bool xpt2046_read(lv_indev_drv_t * drv, lv_indev_data_t * data)
{
static int16_t last_x = 0;
static int16_t last_y = 0;
bool valid = false;
int16_t x = last_x;
int16_t y = last_y;
if (xpt2048_is_touch_detected() == TOUCH_DETECTED)
{
valid = true;
x = xpt2046_cmd(CMD_X_READ);
y = xpt2046_cmd(CMD_Y_READ);
ESP_LOGI(TAG, "P(%d,%d)", x, y);
/*Normalize Data back to 12-bits*/
x = x >> 4;
y = y >> 4;
ESP_LOGI(TAG, "P_norm(%d,%d)", x, y);
xpt2046_corr(&x, &y);
xpt2046_avg(&x, &y);
last_x = x;
last_y = y;
ESP_LOGI(TAG, "x = %d, y = %d", x, y);
}
else
{
avg_last = 0;
}
data->point.x = x;
data->point.y = y;
data->state = valid == false ? LV_INDEV_STATE_REL : LV_INDEV_STATE_PR;
return false;
}
/**********************
* STATIC FUNCTIONS
**********************/
static xpt2046_touch_detect_t xpt2048_is_touch_detected()
{
// check IRQ pin if we IRQ or IRQ and preessure
#if XPT2046_TOUCH_IRQ || XPT2046_TOUCH_IRQ_PRESS
uint8_t irq = gpio_get_level(XPT2046_IRQ);
if (irq != 0) {
return TOUCH_NOT_DETECTED;
}
#endif
// check pressure if we are pressure or IRQ and pressure
#if XPT2046_TOUCH_PRESS || XPT2046_TOUCH_IRQ_PRESS
int16_t z1 = xpt2046_cmd(CMD_Z1_READ) >> 3;
int16_t z2 = xpt2046_cmd(CMD_Z2_READ) >> 3;
// this is not what the confusing datasheet says but it seems to
// be enough to detect real touches on the panel
int16_t z = z1 + 4096 - z2;
if (z < XPT2046_TOUCH_THRESHOLD)
{
return TOUCH_NOT_DETECTED;
}
#endif
return TOUCH_DETECTED;
}
static int16_t xpt2046_cmd(uint8_t cmd)
{
uint8_t data[2];
tp_spi_read_reg(cmd, data, 2);
int16_t val = (data[0] << 8) | data[1];
return val;
}
static void xpt2046_corr(int16_t * x, int16_t * y)
{
#if XPT2046_XY_SWAP != 0
int16_t swap_tmp;
swap_tmp = *x;
*x = *y;
*y = swap_tmp;
#endif
if((*x) > XPT2046_X_MIN)(*x) -= XPT2046_X_MIN;
else(*x) = 0;
if((*y) > XPT2046_Y_MIN)(*y) -= XPT2046_Y_MIN;
else(*y) = 0;
(*x) = (uint32_t)((uint32_t)(*x) * LV_HOR_RES) /
(XPT2046_X_MAX - XPT2046_X_MIN);
(*y) = (uint32_t)((uint32_t)(*y) * LV_VER_RES) /
(XPT2046_Y_MAX - XPT2046_Y_MIN);
#if XPT2046_X_INV != 0
(*x) = LV_HOR_RES - (*x);
#endif
#if XPT2046_Y_INV != 0
(*y) = LV_VER_RES - (*y);
#endif
}
static void xpt2046_avg(int16_t * x, int16_t * y)
{
/*Shift out the oldest data*/
uint8_t i;
for(i = XPT2046_AVG - 1; i > 0 ; i--) {
avg_buf_x[i] = avg_buf_x[i - 1];
avg_buf_y[i] = avg_buf_y[i - 1];
}
/*Insert the new point*/
avg_buf_x[0] = *x;
avg_buf_y[0] = *y;
if(avg_last < XPT2046_AVG) avg_last++;
/*Sum the x and y coordinates*/
int32_t x_sum = 0;
int32_t y_sum = 0;
for(i = 0; i < avg_last ; i++) {
x_sum += avg_buf_x[i];
y_sum += avg_buf_y[i];
}
/*Normalize the sums*/
(*x) = (int32_t)x_sum / avg_last;
(*y) = (int32_t)y_sum / avg_last;
}
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/xpt2046.c | C | apache-2.0 | 5,054 |
/**
* @file XPT2046.h
*
*/
#ifndef XPT2046_H
#define XPT2046_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stdint.h>
#include <stdbool.h>
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif
/*********************
* DEFINES
*********************/
#define XPT2046_IRQ CONFIG_LV_TOUCH_PIN_IRQ
#define XPT2046_AVG 4
#define XPT2046_X_MIN CONFIG_LV_TOUCH_X_MIN
#define XPT2046_Y_MIN CONFIG_LV_TOUCH_Y_MIN
#define XPT2046_X_MAX CONFIG_LV_TOUCH_X_MAX
#define XPT2046_Y_MAX CONFIG_LV_TOUCH_Y_MAX
#define XPT2046_X_INV CONFIG_LV_TOUCH_INVERT_X
#define XPT2046_Y_INV CONFIG_LV_TOUCH_INVERT_Y
#define XPT2046_XY_SWAP CONFIG_LV_TOUCH_XY_SWAP
#define XPT2046_TOUCH_THRESHOLD 400 // Threshold for touch detection
#define XPT2046_TOUCH_IRQ CONFIG_LV_TOUCH_DETECT_IRQ
#define XPT2046_TOUCH_IRQ_PRESS CONFIG_LV_TOUCH_DETECT_IRQ_PRESSURE
#define XPT2046_TOUCH_PRESS CONFIG_LV_TOUCH_DETECT_PRESSURE
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
void xpt2046_init(void);
bool xpt2046_read(lv_indev_drv_t * drv, lv_indev_data_t * data);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* XPT2046_H */
| YifuLiu/AliOS-Things | components/drivers/external_device/m5driver/lvgl_esp32_drivers/lvgl_touch/xpt2046.h | C | apache-2.0 | 1,449 |
/*
* Copyright (C) 2015-2021 Alibaba Group Holding Limited
*/
#include <stdint.h>
/*#include "aos/i2c.h"*/
#include "pca9544.h"
#if AOS_COMP_CLI
#include "aos/cli.h"
#endif
static void pca9544_comp_example(int argc, char **argv)
{
(void)argc;
(void)argv;
int ret;
uint8_t data[7] = { 8, 25, 18, 7, 3, 1, 21 };
uint8_t data_rtn[7] = { 0 };
uint16_t size = 7;
PCA9544_CH_E test_chan = PCA9544_CH1;
PCA9544_CH_E read_chan = PCA9544_CH_NULL;
uint8_t reg_rtn;
uint8_t chan_mask = 0x05;
i2c_dev_t i2c;
PCA9544_DEV_CFG_T dev_cfg;
dev_cfg.dev_addr = PCA9544_BASE_ADDR;
dev_cfg.pca9544_ch = test_chan;
dev_cfg.subdev_addr = 0x32;
dev_cfg.reg_addr = 0x10;
i2c.port = 1;
i2c.config.address_width = 8;
i2c.config.freq = I2C_BUS_BIT_RATES_100K;
i2c.config.dev_addr = dev_cfg.dev_addr;
ret = pca9544_init(&i2c, &dev_cfg);
if (ret) {
printf("=====I2C Muxer PCA9544 test: init fail =====\r\n");
return -1;
}
/* chan select */
printf("=====I2C Muxer PCA9544 test: set chan 2[%d] of PCA9544=====\r\n", test_chan);
ret = pca9544_set_chan(test_chan);
/*aos_sleep(2);*/
read_chan = pca9544_read_chan();
printf("=====I2C Muxer PCA9544 test: read chan val of PCA9544 is %d=====\r\n", read_chan);
/*aos_sleep(2);*/
if (test_chan == read_chan) {
printf("=====I2C Muxer PCA9544 test: PCA9544 test: PASS=====\r\n");
} else {
printf("=====I2C Muxer PCA9544 test: PCA9544 test: FAIL=====\r\n");
pca9544_deinit();
ret = -1;
}
pca9544_deinit();
printf("pca9544 comp test success!\r\n");
return;
}
#if AOS_COMP_CLI
/* reg args: fun, cmd, description*/
ALIOS_CLI_CMD_REGISTER(pca9544_comp_example, pca9544_example, pca9544 component example)
#endif
| YifuLiu/AliOS-Things | components/drivers/external_device/pca9544/example/pca9544_example.c | C | apache-2.0 | 1,919 |