payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'Branch_S550_GUI' of 192.168.6.216:/linux-em-group/s530-ntk into branch_s550_gui_debug

Browse Source
This commit is contained in:
zyj 2023-10-17 21:16:34 +08:00
commit 07e0c59ab9
11 changed files with 1848 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/MenuQR.c
View File

@ -1,7 +1,7 @@
// #include "MenuQR.h"
#include "PrjInc.h"
#include "UIWnd/UIFlow.h"
#include "lvgl/src/lv_lib_qrcode/lv_qrcode.h"
TMDEF_BEGIN_OPTIONS(NETWORK_SELECTION)
TMDEF_OPTION_TEXT_S(END, TM_OPTION_ENABLE)
TMDEF_END_OPTIONS()
@ -79,3 +79,49 @@ int Qr_MenuCallback(UINT32 uiMessage, UINT32 uiParam)
}
return TMF_PROCESSED;
}
char *qr_code_str = "{\"imei\":\"%s\",\"verizonICCID\":\"%s\",\"attICCID\":\"%s\",\"isEsim\":%s}";
static lv_obj_t *qr = NULL;
static lv_obj_t *label = NULL;
void show_qr_picture_page(lv_obj_t* obj)
{
// lv_color_t colorDrak = {0};
// lv_color_t colorLight = {0};
UIMenuStoreInfo *puiPara = sf_ui_para_get();
// const char *data = "https://github.com/topics/littlevgl";
#define QR_DATA_LENGTH 1024
char qr_date[QR_DATA_LENGTH] = {0};
snprintf(qr_date, QR_DATA_LENGTH, qr_code_str, puiPara->ModuleImei, "89011703322284703435", "89011703322284703435", "true");
if(obj){
/*Create a 100x100 QR code*/
qr = lv_qrcode_create(obj, 120, (lv_color_t) { .full = 0x02}, (lv_color_t) { .full = 0x0A});
if(qr){
/*Set data*/
lv_qrcode_update(qr, qr_date, strlen(qr_date));
lv_obj_set_pos(qr, 32, 70);
}
}
lv_color_t color = {0};
static lv_style_t labelStyle;
lv_style_init(&labelStyle);
STYLE_COLOR_PROP(0xff, 0xff, 0xff, 0xff) ; lv_style_set_text_color(&labelStyle, LV_STATE_DEFAULT, color);
label = lv_label_create(obj, NULL);
lv_label_set_long_mode(label, LV_LABEL_LONG_BREAK);
lv_label_set_text(label, "Add Camera to Tactacam App");
lv_obj_set_pos(label, 180, 78);
lv_obj_set_size(label, 110, 63);
lv_obj_add_style(label, 0, &labelStyle);
}
void hidde_qr_picture_page(void)
{
if(NULL != qr)
{
lv_qrcode_delete(qr);
}
if(label)
{
lv_obj_del(label);
}
}

3
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/MenuQR.h
View File

@ -4,4 +4,7 @@
extern TM_MENU gQrMenu;
extern TM_ITEM gTM_ITEMS_QR[];
extern void show_qr_picture_page(lv_obj_t* obj);
extern void hidde_qr_picture_page(void);
#endif

61
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonOption/UIFlowMenuCommonOptionEventCallback.c
View File

@ -76,6 +76,47 @@ static void UIFlowMenuCommonOption_CloseScr(lv_obj_t* obj)
}
#endif
#define MESSAGE_ITEM_TRUE 1
#define MESSAGE_ITEM_FALSE 0
static int is_message_item(lv_obj_t* obj)
{
TM_MENU* pMenu = TM_GetMenu();
TM_PAGE* pPage;
TM_ITEM* pItem;
pPage = &pMenu->pPages[pMenu->SelPage];
pItem = &pPage->pItems[pPage->SelItem];
UINT16 itemID = pItem->ItemId;
switch (itemID) {
case IDM_QR_PICTURE:
{
printf("Show qr picture.\n");
show_qr_picture_page(obj);
return MESSAGE_ITEM_TRUE;
}
default:
break;
}
return MESSAGE_ITEM_FALSE;
}
static void message_item_close(void)
{
TM_MENU* pMenu = TM_GetMenu();
TM_PAGE* pPage;
TM_ITEM* pItem;
pPage = &pMenu->pPages[pMenu->SelPage];
pItem = &pPage->pItems[pPage->SelItem];
UINT16 itemID = pItem->ItemId;
switch (itemID) {
case IDM_QR_PICTURE:
{
printf("hide qr picture.\n");
hidde_qr_picture_page();
return ;
}
default:
break;
}
}
static void LV_MenuCommonOption_UpdateContent(TM_MENU *pMenu)
{
TM_PAGE *pPage;
@ -158,6 +199,15 @@ static void LV_MenuCommonOption_UpdateContent(TM_MENU *pMenu)
lv_plugin_label_set_text(label_menu_item_scr_uiflowmenucommonoption, pItem->TextId);
lv_plugin_label_update_font(label_menu_item_scr_uiflowmenucommonoption, LV_OBJ_PART_MAIN);
}
if(MESSAGE_ITEM_FALSE == is_message_item(lv_plugin_scr_act()))
{
lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, false);
// LV_MenuCommonOption_UpdateContent(pMenu);
}
else
{
lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, true);
}
#endif
//find startIndex
TM_FindStartIndex(pMenu, pItem->Count, &startIndex);
@ -298,7 +348,15 @@ static void LV_MenuOption_OnOpen(lv_obj_t* obj, TM_MENU *data)
/* allocate menu item */
lv_plugin_menu_init_items(menu_item, OPTION_PAGE_NUM);
}
// if(MESSAGE_ITEM_FALSE == is_message_item(obj))
// {
// lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, false);
// LV_MenuCommonOption_UpdateContent(pMenu);
// }
// else
// {
// lv_obj_set_hidden(container_main_menu_scr_uiflowmenucommonoption, true);
// }
LV_MenuCommonOption_UpdateContent(pMenu);
//lv_plugin_menu_select_item(menu_item, 0);
@ -424,6 +482,7 @@ static void LV_MenuOption_OnSelected(lv_obj_t* obj)
static void UIFlowMenuCommonOption_ScrClose(lv_obj_t* obj)
{
DBG_DUMP("%s\r\n", __func__);
message_item_close();
UIMenuStoreInfo *puiPara = sf_ui_para_get();
printf("camera mode = %d\n", puiPara->CamMode);
}

73
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovieEventCallback.c
View File

@ -9,6 +9,7 @@
#include "DCF.h"
#endif
#include "sf_wifi_svr.h"
#if HUNTING_CAMERA_MCU == ENABLE
#include <sf_inc.h>
#endif
@ -338,6 +339,56 @@ static void update_rec_time(void)
lv_label_set_text_fmt(label_rec_time_scr_uiflowmovie, "%02d:%02d:%02d", rec_sec / 3600, (rec_sec % 3600) / 60, (rec_sec % 3600) % 60);
}
static void update_wifi(void)
{
const int EMPTY_IMAGE = 0;
SF_WIFI_STATUS_E status = sf_get_wifi_status();
lv_plugin_res_id res[] = {
EMPTY_IMAGE,
LV_PLUGIN_IMG_ID_SF_WIFI_UNCONNECTED,
LV_PLUGIN_IMG_ID_SF_WIFI_CONNECTED,
LV_PLUGIN_IMG_ID_SF_WIFI_UNSUPPORT
};
const int WIFI_NOT_INIT = 0;
const int WIFI_UNCONNECTED = 1;
const int WIFI_UNSUPPORT = 3;
if (WIFI_NOT_INIT == status
|| status < WIFI_UNCONNECTED
|| status > WIFI_UNSUPPORT)
{
lv_obj_set_hidden(image_wifi_connected_scr_uiflowmovie, true);
return;
}
int index = status;
lv_obj_set_hidden(image_wifi_connected_scr_uiflowmovie, false);
lv_plugin_img_set_src(image_wifi_connected_scr_uiflowmovie, res[index]);
}
static void update_bluetooth(void)
{
const int EMPTY_IMAGE = 0;
SF_WIFI_STATUS_E status = sf_get_wifi_status();
lv_plugin_res_id res[] = {
EMPTY_IMAGE,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNCONNECTED,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_CONNECTED,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNSUPPORT
};
const int WIFI_NOT_INIT = 0;
const int WIFI_UNCONNECTED = 1;
const int WIFI_UNSUPPORT = 3;
if (WIFI_NOT_INIT == status
|| status < WIFI_UNCONNECTED
|| status > WIFI_UNSUPPORT)
{
lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowmovie, true);
return;
}
int index = status;
lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowmovie, false);
lv_plugin_img_set_src(image_bluetooth_connected_scr_uiflowmovie, res[index]);
}
static void update_size(void)
{
lv_label_set_text(label_size_scr_uiflowmovie, resolution_Buf[SysGetFlag(FL_MOVIE_SIZE)]);
@ -445,16 +496,16 @@ static void update_card(void)
}
}
static void update_wifi(void)
{
static lv_plugin_res_id res[] = {
LV_PLUGIN_IMG_ID_ICON_WIFI_OFF,
LV_PLUGIN_IMG_ID_ICON_WIFI_ON,
LV_PLUGIN_IMG_ID_ICON_CLOUD_ON,
};
// static void update_wifi(void)
// {
// static lv_plugin_res_id res[] = {
// LV_PLUGIN_IMG_ID_ICON_WIFI_OFF,
// LV_PLUGIN_IMG_ID_ICON_WIFI_ON,
// LV_PLUGIN_IMG_ID_ICON_CLOUD_ON,
// };
lv_plugin_img_set_src(image_wifi_scr_uiflowmovie, res[SysGetFlag(FL_WIFI)]);
}
// lv_plugin_img_set_src(image_wifi_scr_uiflowmovie, res[SysGetFlag(FL_WIFI)]);
// }
static void update_icons(void)
@ -465,7 +516,6 @@ static void update_icons(void)
update_size();
update_ev();
update_card();
update_wifi();
update_hdr();
update_motionDet();
update_cyclic_rec();
@ -473,7 +523,8 @@ static void update_icons(void)
update_max_rec_time();
update_4g_module_icon();
update_camera_message();
update_wifi();
update_bluetooth();
}
static void UIFlowMovie_MotionDetect(void)

79
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c
View File

@ -14,7 +14,7 @@
#include "exif/Exif.h"
#include <kwrap/util.h>
#include "SysMain.h"
#include "sf_wifi_svr.h"
#if (USE_DCF == ENABLE)
#include "DCF.h"
#endif
@ -374,6 +374,31 @@ static void update_4g_module_icon(void)
// Nothing changed.
// printf(" nothing changed.\n");
}
const int EMPTY_IMAGE = 0;
UIMenuStoreInfo *puiPara = sf_ui_para_get();
lv_plugin_res_id res[] = {
EMPTY_IMAGE,
EMPTY_IMAGE,
LV_PLUGIN_IMG_ID_SF_NET2G,
LV_PLUGIN_IMG_ID_SF_NET3G,
LV_PLUGIN_IMG_ID_SF_NET4G
};
// printf("NetGeneration:%d\n", puiPara->NetGeneration);
const int SIM_CARD_NOT_INIT = 0;
const int NET_GENERATION_2G = 2;
// const int NET_GENERATION_3G = 3;
const int NET_GENERATION_4G = 4;
// puiPara->NetGeneration = NET_GENERATION_4G; // Test
if (SIM_CARD_NOT_INIT == puiPara->NetGeneration
|| puiPara->NetGeneration < NET_GENERATION_2G
|| puiPara->NetGeneration > NET_GENERATION_4G)
{
lv_obj_set_hidden(image_4g_scr_uiflowphoto, true);
return;
}
int index = puiPara->NetGeneration;
lv_obj_set_hidden(image_4g_scr_uiflowphoto, false);
lv_plugin_img_set_src(image_4g_scr_uiflowphoto, res[index]);
}
static void update_camera_message(void)
@ -421,6 +446,56 @@ static void update_camera_message(void)
}
}
static void update_wifi(void)
{
const int EMPTY_IMAGE = 0;
SF_WIFI_STATUS_E status = sf_get_wifi_status();
lv_plugin_res_id res[] = {
EMPTY_IMAGE,
LV_PLUGIN_IMG_ID_SF_WIFI_UNCONNECTED,
LV_PLUGIN_IMG_ID_SF_WIFI_CONNECTED,
LV_PLUGIN_IMG_ID_SF_WIFI_UNSUPPORT
};
const int WIFI_NOT_INIT = 0;
const int WIFI_UNCONNECTED = 1;
const int WIFI_UNSUPPORT = 3;
if (WIFI_NOT_INIT == status
|| status < WIFI_UNCONNECTED
|| status > WIFI_UNSUPPORT)
{
lv_obj_set_hidden(image_wifi_connected_scr_uiflowphoto, true);
return;
}
int index = status;
lv_obj_set_hidden(image_wifi_connected_scr_uiflowphoto, false);
lv_plugin_img_set_src(image_wifi_connected_scr_uiflowphoto, res[index]);
}
static void update_bluetooth(void)
{
const int EMPTY_IMAGE = 0;
SF_WIFI_STATUS_E status = sf_get_wifi_status();
lv_plugin_res_id res[] = {
EMPTY_IMAGE,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNCONNECTED,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_CONNECTED,
LV_PLUGIN_IMG_ID_SF_BLUETOOTH_UNSUPPORT
};
const int WIFI_NOT_INIT = 0;
const int WIFI_UNCONNECTED = 1;
const int WIFI_UNSUPPORT = 3;
if (WIFI_NOT_INIT == status
|| status < WIFI_UNCONNECTED
|| status > WIFI_UNSUPPORT)
{
lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowphoto, true);
return;
}
int index = status;
lv_obj_set_hidden(image_bluetooth_connected_scr_uiflowphoto, false);
lv_plugin_img_set_src(image_bluetooth_connected_scr_uiflowphoto, res[index]);
}
static void update_fd_frame(void)
{
if (SysGetFlag(FL_FD) != FD_OFF){
@ -458,6 +533,8 @@ static void update_icons(void)
update_dzoom();
update_4g_module_icon();
update_camera_message();
update_wifi();
update_bluetooth();
}
static void FlowPhoto_InitStartupFuncs(void)

2
code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c
View File

@ -114,6 +114,7 @@ static void UIFlowPlay_IconImageSize(BOOL bShow)
}
//show icon
if (uiFileFmt & (PBFMT_MOVMJPG | PBFMT_AVI | PBFMT_MP4 | PBFMT_TS)) {
printf("This is video.\n");
PB_GetParam(PBPRMID_INFO_VDO, (UINT32 *)&MovieInfo);
switch (MovieInfo.uiVidWidth) {
case 3840:
@ -171,6 +172,7 @@ static void UIFlowPlay_IconImageSize(BOOL bShow)
snprintf(item1_Buf, 32, "%lux%lu", OriImgWidth, OriImgHeight);
}
} else {
printf("This is picture.\n");
snprintf(item1_Buf, 32, "%lux%lu", OriImgWidth, OriImgHeight);
}

4
code/lib/source/lvgl/Makefile
View File

@ -137,6 +137,8 @@ SRC = \
lvgl/src/lv_hal/lv_hal_indev.c \
lvgl/src/lv_hal/lv_hal_tick.c \
lvgl/src/lv_gpu/lv_gpu_nvt_dma2d.c \
lvgl/src/lv_lib_qrcode/lv_qrcode.c \
lvgl/src/lv_lib_qrcode/qrcodegen.c \
OBJ = $(SRC:.c=.o)
@ -289,6 +291,8 @@ SRC = \
lvgl/src/lv_hal/lv_hal_indev.c \
lvgl/src/lv_hal/lv_hal_tick.c \
lvgl/src/lv_gpu/lv_gpu_nvt_dma2d.c \
lvgl/src/lv_lib_qrcode/lv_qrcode.c \
lvgl/src/lv_lib_qrcode/qrcodegen.c \
copy = if [ ! -z "$(1)" -a "$(1)" != " " ]; then cp -avf $(1) $(2); fi

205
code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/lv_qrcode.c Executable file
View File

@ -0,0 +1,205 @@
/**
* @file lv_qrcode.c
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_qrcode.h"
#include "qrcodegen.h"
#include "stdio.h"
#include "kwrap/util.h"
/*********************
* DEFINES
*********************/
#define QR_SIZE 140
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Create an empty QR code (an `lv_canvas`) object.
* @param parent point to an object where to create the QR code
* @param size width and height of the QR code
* @param dark_color dark color of the QR code
* @param light_color light color of the QR code
* @return pointer to the created QR code object
*/
lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color)
{
uint32_t buf_size = LV_CANVAS_BUF_SIZE_INDEXED_1BIT(size, size);
uint8_t * buf = lv_mem_alloc(buf_size);
#if LV_VERSION_CHECK(6,0,0)
lv_mem_assert(buf);
#else
LV_ASSERT_MEM(buf);
#endif
if(buf == NULL) return NULL;
lv_obj_t * canvas = lv_canvas_create(parent, NULL);
if(canvas == NULL) return NULL;
if(LV_COLOR_DEPTH == 8){
lv_canvas_set_buffer(canvas, buf, size, size, LV_IMG_CF_INDEXED_1BIT);
lv_canvas_set_palette(canvas, 0, dark_color);
lv_canvas_set_palette(canvas, 1, light_color);
}
else{
lv_canvas_set_buffer(canvas, buf, size, size, LV_IMG_CF_INDEXED_1BIT);
lv_canvas_set_palette(canvas, 0, dark_color);
lv_canvas_set_palette(canvas, 1, light_color);
}
return canvas;
}
/**
* Set the data of a QR code object
* @param qrcode pointer to aQ code object
* @param data data to display
* @param data_len length of data in bytes
* @return LV_RES_OK: if no error; LV_RES_INV: on error
*/
lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len)
{
uint8_t* qr0 = NULL;
uint8_t* data_tmp = NULL;
lv_res_t ret = LV_RES_OK;
lv_color_t c;
c.full = 1;
#if LV_VERSION_CHECK(7,0,0)
lv_canvas_fill_bg(qrcode, c, LV_OPA_COVER);
#else
lv_canvas_fill_bg(qrcode, c);
#endif
if(data_len > qrcodegen_BUFFER_LEN_MAX) return LV_RES_INV;
qr0 = (uint8_t*)lv_mem_alloc(qrcodegen_BUFFER_LEN_MAX);
if(qr0 == NULL){
ret = LV_RES_INV;
goto EXIT;
}
data_tmp = (uint8_t*)lv_mem_alloc(qrcodegen_BUFFER_LEN_MAX);
if(data_tmp == NULL){
ret = LV_RES_INV;
goto EXIT;
}
memcpy(data_tmp, data, data_len);
bool ok = qrcodegen_encodeBinary(data_tmp, data_len,
qr0, qrcodegen_Ecc_MEDIUM,
qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX,
qrcodegen_Mask_AUTO, true);
if (!ok) {
ret = LV_RES_INV;
goto EXIT;
}
lv_coord_t obj_w = lv_obj_get_width(qrcode);
int qr_size = qrcodegen_getSize(qr0);
int scale = obj_w / qr_size;
int scaled = qr_size * scale;
int margin = (obj_w - scaled) / 2;
lv_img_dsc_t * img = lv_canvas_get_img(qrcode);
uint8_t * buf_u8 = (uint8_t *)img->data + 8; /*+8 skip the palette*/
/* Copy the qr code canvas:
* A simple `lv_canvas_set_px` would work but it's slow for so many pixels.
* So buffer 1 byte (8 px) from the qr code and set it in the canvas image */
uint32_t row_byte_cnt = (img->header.w + 7) >> 3;
int y;
for (y = margin; y < scaled + margin; y+=scale) {
uint8_t b = 0;
uint8_t p = 0;
bool aligned = false;
int x;
for (x = margin; x < scaled + margin; x++) {
bool a = qrcodegen_getModule(qr0, (x - margin) / scale, (y - margin) / scale);
if(aligned == false && (x & 0x7) == 0) aligned = true;
if(aligned == false) {
c.full = a ? 0 : 1;
lv_canvas_set_px(qrcode, x, y, c);
} else {
if(!a) b |= (1 << (7 - p));
p++;
if(p == 8) {
uint32_t px = row_byte_cnt * y + (x >> 3);
buf_u8[px] = b;
b = 0;
p = 0;
}
}
}
/*Process the last byte of the row*/
if(p) {
/*Make the rest of the bits white*/
b |= (1 << (8 - p)) - 1;
uint32_t px = row_byte_cnt * y + (x >> 3);
buf_u8[px] = b;
}
/*The Qr is probably scaled so simply to the repeated rows*/
int s;
const uint8_t * row_ori = buf_u8 + row_byte_cnt * y;
for(s = 1; s < scale; s++) {
memcpy((uint8_t*)buf_u8 + row_byte_cnt * (y + s), row_ori, row_byte_cnt);
}
}
EXIT:
if(qr0){
lv_mem_free(qr0);
}
if(data_tmp){
lv_mem_free(data_tmp);
}
return ret;
}
/**
* Delete a QR code object
* @param qrcode pointer to a QR code obejct
*/
void lv_qrcode_delete(lv_obj_t * qrcode)
{
lv_img_dsc_t * img = lv_canvas_get_img(qrcode);
lv_img_cache_invalidate_src(img);
lv_mem_free(img->data);
lv_obj_del(qrcode);
}
/**********************
* STATIC FUNCTIONS
**********************/

67
code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/lv_qrcode.h Executable file
View File

@ -0,0 +1,67 @@
/**
* @file lv_qrcode
*
*/
#ifndef LV_QRCODE_H
#define LV_QRCODE_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include <lvgl.h>
#else
#include <lvgl/lvgl.h>
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/**
* Create an empty QR code (an `lv_canvas`) object.
* @param parent point to an object where to create the QR code
* @param size width and height of the QR code
* @param dark_color dark color of the QR code
* @param light_color light color of the QR code
* @return pointer to the created QR code object
*/
lv_obj_t * lv_qrcode_create(lv_obj_t * parent, lv_coord_t size, lv_color_t dark_color, lv_color_t light_color);
/**
* Set the data of a QR code object
* @param qrcode pointer to aQ code object
* @param data data to display
* @param data_len length of data in bytes
* @return LV_RES_OK: if no error; LV_RES_INV: on error
*/
lv_res_t lv_qrcode_update(lv_obj_t * qrcode, const void * data, uint32_t data_len);
/**
* Delete a QR code object
* @param qrcode pointer to a QR code object
*/
void lv_qrcode_delete(lv_obj_t * qrcode);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /*LV_QRCODE_H*/

1009
code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/qrcodegen.c Executable file
View File

File diff suppressed because it is too large Load Diff

311
code/lib/source/lvgl/lvgl/src/lv_lib_qrcode/qrcodegen.h Executable file
View File

@ -0,0 +1,311 @@
/*
* QR Code generator library (C)
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/qr-code-generator-library
*
* 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.
*/
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* This library creates QR Code symbols, which is a type of two-dimension barcode.
* Invented by Denso Wave and described in the ISO/IEC 18004 standard.
* A QR Code structure is an immutable square grid of black and white cells.
* The library provides functions to create a QR Code from text or binary data.
* The library covers the QR Code Model 2 specification, supporting all versions (sizes)
* from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
*
* Ways to create a QR Code object:
* - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
* - Low level: Custom-make the list of segments and call
* qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
* (Note that all ways require supplying the desired error correction level and various byte buffers.)
*/
/*---- Enum and struct types----*/
/*
* The error correction level in a QR Code symbol.
*/
enum qrcodegen_Ecc {
// Must be declared in ascending order of error protection
// so that an internal qrcodegen function works properly
qrcodegen_Ecc_LOW = 0 , // The QR Code can tolerate about 7% erroneous codewords
qrcodegen_Ecc_MEDIUM , // The QR Code can tolerate about 15% erroneous codewords
qrcodegen_Ecc_QUARTILE, // The QR Code can tolerate about 25% erroneous codewords
qrcodegen_Ecc_HIGH , // The QR Code can tolerate about 30% erroneous codewords
};
/*
* The mask pattern used in a QR Code symbol.
*/
enum qrcodegen_Mask {
// A special value to tell the QR Code encoder to
// automatically select an appropriate mask pattern
qrcodegen_Mask_AUTO = -1,
// The eight actual mask patterns
qrcodegen_Mask_0 = 0,
qrcodegen_Mask_1,
qrcodegen_Mask_2,
qrcodegen_Mask_3,
qrcodegen_Mask_4,
qrcodegen_Mask_5,
qrcodegen_Mask_6,
qrcodegen_Mask_7,
};
/*
* Describes how a segment's data bits are interpreted.
*/
enum qrcodegen_Mode {
qrcodegen_Mode_NUMERIC = 0x1,
qrcodegen_Mode_ALPHANUMERIC = 0x2,
qrcodegen_Mode_BYTE = 0x4,
qrcodegen_Mode_KANJI = 0x8,
qrcodegen_Mode_ECI = 0x7,
};
/*
* A segment of character/binary/control data in a QR Code symbol.
* The mid-level way to create a segment is to take the payload data
* and call a factory function such as qrcodegen_makeNumeric().
* The low-level way to create a segment is to custom-make the bit buffer
* and initialize a qrcodegen_Segment struct with appropriate values.
* Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
* Any segment longer than this is meaningless for the purpose of generating QR Codes.
* Moreover, the maximum allowed bit length is 32767 because
* the largest QR Code (version 40) has 31329 modules.
*/
struct qrcodegen_Segment {
// The mode indicator of this segment.
enum qrcodegen_Mode mode;
// The length of this segment's unencoded data. Measured in characters for
// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
// Always zero or positive. Not the same as the data's bit length.
int numChars;
// The data bits of this segment, packed in bitwise big endian.
// Can be null if the bit length is zero.
uint8_t *data;
// The number of valid data bits used in the buffer. Requires
// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
// The character count (numChars) must agree with the mode and the bit buffer length.
int bitLength;
};
/*---- Macro constants and functions ----*/
#define qrcodegen_VERSION_MIN 1 // The minimum version number supported in the QR Code Model 2 standard
#define qrcodegen_VERSION_MAX 40 // The maximum version number supported in the QR Code Model 2 standard
// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
#define qrcodegen_BUFFER_LEN_FOR_VERSION(n) ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
// The worst-case number of bytes needed to store one QR Code, up to and including
// version 40. This value equals 3918, which is just under 4 kilobytes.
// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
#define qrcodegen_BUFFER_LEN_MAX qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
/*---- Functions (high level) to generate QR Codes ----*/
/*
* Encodes the given text string to a QR Code, returning true if encoding succeeded.
* If the data is too long to fit in any version in the given range
* at the given ECC level, then false is returned.
* - The input text must be encoded in UTF-8 and contain no NULs.
* - The variables ecl and mask must correspond to enum constant values.
* - Requires 1 <= minVersion <= maxVersion <= 40.
* - The arrays tempBuffer and qrcode must each have a length
* of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
* - After the function returns, tempBuffer contains no useful data.
* - If successful, the resulting QR Code may use numeric,
* alphanumeric, or byte mode to encode the text.
* - In the most optimistic case, a QR Code at version 40 with low ECC
* can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
* up to 4296 characters, or any digit string up to 7089 characters.
* These numbers represent the hard upper limit of the QR Code standard.
* - Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*/
bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
/*
* Encodes the given binary data to a QR Code, returning true if encoding succeeded.
* If the data is too long to fit in any version in the given range
* at the given ECC level, then false is returned.
* - The input array range dataAndTemp[0 : dataLen] should normally be
* valid UTF-8 text, but is not required by the QR Code standard.
* - The variables ecl and mask must correspond to enum constant values.
* - Requires 1 <= minVersion <= maxVersion <= 40.
* - The arrays dataAndTemp and qrcode must each have a length
* of at least qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion).
* - After the function returns, the contents of dataAndTemp may have changed,
* and does not represent useful data anymore.
* - If successful, the resulting QR Code will use byte mode to encode the data.
* - In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
* sequence up to length 2953. This is the hard upper limit of the QR Code standard.
* - Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*/
bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
/*---- Functions (low level) to generate QR Codes ----*/
/*
* Renders a QR Code representing the given segments at the given error correction level.
* The smallest possible QR Code version is automatically chosen for the output. Returns true if
* QR Code creation succeeded, or false if the data is too long to fit in any version. The ECC level
* of the result may be higher than the ecl argument if it can be done without increasing the version.
* This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
* result in them being clobbered, but the QR Code output will still be correct.
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
*/
bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
/*
* Renders a QR Code representing the given segments with the given encoding parameters.
* Returns true if QR Code creation succeeded, or false if the data is too long to fit in the range of versions.
* The smallest possible QR Code version within the given range is automatically
* chosen for the output. Iff boostEcl is true, then the ECC level of the result
* may be higher than the ecl argument if it can be done without increasing the
* version. The mask number is either between 0 to 7 (inclusive) to force that
* mask, or -1 to automatically choose an appropriate mask (which may be slow).
* This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
* result in them being clobbered, but the QR Code output will still be correct.
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
*/
bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
/*
* Tests whether the given string can be encoded as a segment in alphanumeric mode.
* A string is encodable iff each character is in the following set: 0 to 9, A to Z
* (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
*/
bool qrcodegen_isAlphanumeric(const char *text);
/*
* Tests whether the given string can be encoded as a segment in numeric mode.
* A string is encodable iff each character is in the range 0 to 9.
*/
bool qrcodegen_isNumeric(const char *text);
/*
* Returns the number of bytes (uint8_t) needed for the data buffer of a segment
* containing the given number of characters using the given mode. Notes:
* - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or
* the number of needed bits exceeds INT16_MAX (i.e. 32767).
* - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
* - It is okay for the user to allocate more bytes for the buffer than needed.
* - For byte mode, numChars measures the number of bytes, not Unicode code points.
* - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
* An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
*/
size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
/*
* Returns a segment representing the given binary data encoded in
* byte mode. All input byte arrays are acceptable. Any text string
* can be converted to UTF-8 bytes and encoded as a byte mode segment.
*/
struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
/*
* Returns a segment representing the given string of decimal digits encoded in numeric mode.
*/
struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
/*
* Returns a segment representing the given text string encoded in alphanumeric mode.
* The characters allowed are: 0 to 9, A to Z (uppercase only), space,
* dollar, percent, asterisk, plus, hyphen, period, slash, colon.
*/
struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
/*
* Returns a segment representing an Extended Channel Interpretation
* (ECI) designator with the given assignment value.
*/
struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
/*---- Functions to extract raw data from QR Codes ----*/
/*
* Returns the side length of the given QR Code, assuming that encoding succeeded.
* The result is in the range [21, 177]. Note that the length of the array buffer
* is related to the side length - every 'uint8_t qrcode[]' must have length at least
* qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
*/
int qrcodegen_getSize(const uint8_t qrcode[]);
/*
* Returns the color of the module (pixel) at the given coordinates, which is false
* for white or true for black. The top left corner has the coordinates (x=0, y=0).
* If the given coordinates are out of bounds, then false (white) is returned.
*/
bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
#ifdef __cplusplus
}
#endif