xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
xiaozhengsheng
2025-08-19 09:49:41 +08:00
parent 10f1ddf1c1
commit 6df0f7d96e
2974 changed files with 1712873 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

628
components/libraries/gfx/nrf_gfx.c Normal file
View File

@@ -0,0 +1,628 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "sdk_common.h"
#if NRF_MODULE_ENABLED(NRF_GFX)
#include "nrf_gfx.h"
#include <stdlib.h>
#include "app_util_platform.h"
#include "nrf_assert.h"
#define NRF_LOG_MODULE_NAME gfx
#include "nrf_log.h"
NRF_LOG_MODULE_REGISTER();
static inline void pixel_draw(nrf_lcd_t const * p_instance,
uint16_t x,
uint16_t y,
uint32_t color)
{
uint16_t lcd_width = nrf_gfx_width_get(p_instance);
uint16_t lcd_height = nrf_gfx_height_get(p_instance);
if ((x >= lcd_width) || (y >= lcd_height))
{
return;
}
p_instance->lcd_pixel_draw(x, y, color);
}
static void rect_draw(nrf_lcd_t const * p_instance,
uint16_t x,
uint16_t y,
uint16_t width,
uint16_t height,
uint32_t color)
{
uint16_t lcd_width = nrf_gfx_width_get(p_instance);
uint16_t lcd_height = nrf_gfx_height_get(p_instance);
if ((x >= lcd_width) || (y >= lcd_height))
{
return;
}
if (width > (lcd_width - x))
{
width = lcd_width - x;
}
if (height > (lcd_height - y))
{
height = lcd_height - y;
}
p_instance->lcd_rect_draw(x, y, width, height, color);
}
static void line_draw(nrf_lcd_t const * p_instance,
uint16_t x_0,
uint16_t y_0,
uint16_t x_1,
int16_t y_1,
uint32_t color)
{
uint16_t x = x_0;
uint16_t y = y_0;
int16_t d;
int16_t d_1;
int16_t d_2;
int16_t ai;
int16_t bi;
int16_t xi = (x_0 < x_1) ? 1 : (-1);
int16_t yi = (y_0 < y_1) ? 1 : (-1);
bool swapped = false;
d_1 = abs(x_1 - x_0);
d_2 = abs(y_1 - y_0);
pixel_draw(p_instance, x, y, color);
if (d_1 < d_2)
{
d_1 = d_1 ^ d_2;
d_2 = d_1 ^ d_2;
d_1 = d_2 ^ d_1;
swapped = true;
}
ai = (d_2 - d_1) * 2;
bi = d_2 * 2;
d = bi - d_1;
while ((y != y_1) || (x != x_1))
{
if (d >= 0)
{
x += xi;
y += yi;
d += ai;
}
else
{
d += bi;
if (swapped)
{
y += yi;
}
else
{
x += xi;
}
}
pixel_draw(p_instance, x, y, color);
}
}
static void write_character(nrf_lcd_t const * p_instance,
nrf_gfx_font_desc_t const * p_font,
uint8_t character,
uint16_t * p_x,
uint16_t y,
uint16_t font_color)
{
uint8_t char_idx = character - p_font->startChar;
uint16_t bytes_in_line = CEIL_DIV(p_font->charInfo[char_idx].widthBits, 8);
if (character == ' ')
{
*p_x += p_font->height / 2;
return;
}
for (uint16_t i = 0; i < p_font->height; i++)
{
for (uint16_t j = 0; j < bytes_in_line; j++)
{
for (uint8_t k = 0; k < 8; k++)
{
if ((1 << (7 - k)) &
p_font->data[p_font->charInfo[char_idx].offset + i * bytes_in_line + j])
{
pixel_draw(p_instance, *p_x + j * 8 + k, y + i, font_color);
}
}
}
}
*p_x += p_font->charInfo[char_idx].widthBits + p_font->spacePixels;
}
ret_code_t nrf_gfx_init(nrf_lcd_t const * p_instance)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state == NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_instance->lcd_init != NULL);
ASSERT(p_instance->lcd_uninit != NULL);
ASSERT(p_instance->lcd_pixel_draw != NULL);
ASSERT(p_instance->lcd_rect_draw != NULL);
ASSERT(p_instance->lcd_display != NULL);
ASSERT(p_instance->lcd_rotation_set != NULL);
ASSERT(p_instance->lcd_display_invert != NULL);
ASSERT(p_instance->p_lcd_cb != NULL);
ret_code_t err_code;
err_code = p_instance->lcd_init();
if (err_code == NRF_SUCCESS)
{
p_instance->p_lcd_cb->state = NRFX_DRV_STATE_INITIALIZED;
}
return err_code;
}
void nrf_gfx_uninit(nrf_lcd_t const * p_instance)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
p_instance->p_lcd_cb->state = NRFX_DRV_STATE_UNINITIALIZED;
p_instance->lcd_uninit();
}
void nrf_gfx_point_draw(nrf_lcd_t const * p_instance,
nrf_gfx_point_t const * p_point,
uint32_t color)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_point != NULL);
pixel_draw(p_instance, p_point->x, p_point->y, color);
}
ret_code_t nrf_gfx_line_draw(nrf_lcd_t const * p_instance,
nrf_gfx_line_t const * p_line,
uint32_t color)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_line != NULL);
uint16_t x_thick = 0;
uint16_t y_thick = 0;
if (((p_line->x_start > nrf_gfx_width_get(p_instance)) &&
(p_line->x_end > nrf_gfx_height_get(p_instance))) ||
((p_line->y_start > nrf_gfx_width_get(p_instance)) &&
(p_line->y_end > nrf_gfx_height_get(p_instance))))
{
return NRF_ERROR_INVALID_PARAM;
}
if (abs(p_line->x_start - p_line->x_end) > abs(p_line->y_start - p_line->y_end))
{
y_thick = p_line->thickness;
}
else
{
x_thick = p_line->thickness;
}
if ((p_line->x_start == p_line->x_end) || (p_line->y_start == p_line->y_end))
{
rect_draw(p_instance,
p_line->x_start,
p_line->y_start,
abs(p_line->x_end - p_line->x_start) + x_thick,
abs(p_line->y_end - p_line->y_start) + y_thick,
color);
}
else
{
if (x_thick > 0)
{
for (uint16_t i = 0; i < p_line->thickness; i++)
{
line_draw(p_instance,
p_line->x_start + i,
p_line->y_start,
p_line->x_end + i,
p_line->y_end,
color);
}
}
else if (y_thick > 0)
{
for (uint16_t i = 0; i < p_line->thickness; i++)
{
line_draw(p_instance,
p_line->x_start,
p_line->y_start + i,
p_line->x_end,
p_line->y_end + i,
color);
}
}
else
{
line_draw(p_instance,
p_line->x_start + x_thick,
p_line->y_start + y_thick,
p_line->x_end + x_thick,
p_line->y_end + y_thick,
color);
}
}
return NRF_SUCCESS;
}
ret_code_t nrf_gfx_circle_draw(nrf_lcd_t const * p_instance,
nrf_gfx_circle_t const * p_circle,
uint32_t color,
bool fill)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_circle != NULL);
int16_t y = 0;
int16_t err = 0;
int16_t x = p_circle->r;
if ((p_circle->x - p_circle->r > nrf_gfx_width_get(p_instance)) ||
(p_circle->y - p_circle->r > nrf_gfx_height_get(p_instance)))
{
return NRF_ERROR_INVALID_PARAM;
}
while (x >= y)
{
if (fill)
{
if ((-y + p_circle->x < 0) || (-x + p_circle->x < 0))
{
rect_draw(p_instance, 0, (-x + p_circle->y), (y + p_circle->x + 1), 1, color);
rect_draw(p_instance, 0, (-y + p_circle->y), (x + p_circle->x + 1), 1, color);
rect_draw(p_instance, 0, (y + p_circle->y), (x + p_circle->x + 1), 1, color);
rect_draw(p_instance, 0, (x + p_circle->y), (y + p_circle->x + 1), 1, color);
}
else
{
rect_draw(p_instance, (-y + p_circle->x), (-x + p_circle->y), (2 * y + 1), 1, color);
rect_draw(p_instance, (-x + p_circle->x), (-y + p_circle->y), (2 * x + 1), 1, color);
rect_draw(p_instance, (-x + p_circle->x), (y + p_circle->y), (2 * x + 1), 1, color);
rect_draw(p_instance, (-y + p_circle->x), (x + p_circle->y), (2 * y + 1), 1, color);
}
}
else
{
pixel_draw(p_instance, (y + p_circle->x), (x + p_circle->y), color);
pixel_draw(p_instance, (-y + p_circle->x), (x + p_circle->y), color);
pixel_draw(p_instance, (x + p_circle->x), (y + p_circle->y), color);
pixel_draw(p_instance, (-x + p_circle->x), (y + p_circle->y), color);
pixel_draw(p_instance, (-y + p_circle->x), (-x + p_circle->y), color);
pixel_draw(p_instance, (y + p_circle->x), (-x + p_circle->y), color);
pixel_draw(p_instance, (-x + p_circle->x), (-y + p_circle->y), color);
pixel_draw(p_instance, (x + p_circle->x), (-y + p_circle->y), color);
}
if (err <= 0)
{
y += 1;
err += 2 * y + 1;
}
if (err > 0)
{
x -= 1;
err -= 2 * x + 1;
}
}
return NRF_SUCCESS;
}
ret_code_t nrf_gfx_rect_draw(nrf_lcd_t const * p_instance,
nrf_gfx_rect_t const * p_rect,
uint16_t thickness,
uint32_t color,
bool fill)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_rect != NULL);
uint16_t rect_width = p_rect->width - thickness;
uint16_t rect_height = p_rect->height - thickness;
if ((p_rect->width == 1) ||
(p_rect->height == 1) ||
(thickness * 2 > p_rect->width) ||
(thickness * 2 > p_rect->height) ||
((p_rect->x > nrf_gfx_width_get(p_instance)) &&
(p_rect->y > nrf_gfx_height_get(p_instance))))
{
return NRF_ERROR_INVALID_PARAM;
}
if (fill)
{
rect_draw(p_instance,
p_rect->x,
p_rect->y,
p_rect->width,
p_rect->height,
color);
}
else
{
nrf_gfx_line_t line;
// Top horizontal line.
line.x_start = p_rect->x;
line.y_start = p_rect->y;
line.x_end = p_rect->x + p_rect->width;
line.y_end = p_rect->y;
line.thickness = thickness;
(void)nrf_gfx_line_draw(p_instance, &line, color);
// Bottom horizontal line.
line.x_start = p_rect->x;
line.y_start = p_rect->y + rect_height;
line.x_end = p_rect->x + p_rect->width;
line.y_end = p_rect->y + rect_height;
(void)nrf_gfx_line_draw(p_instance, &line, color);
// Left vertical line.
line.x_start = p_rect->x;
line.y_start = p_rect->y + thickness;
line.x_end = p_rect->x;
line.y_end = p_rect->y + rect_height;
(void)nrf_gfx_line_draw(p_instance, &line, color);
// Right vertical line.
line.x_start = p_rect->x + rect_width;
line.y_start = p_rect->y + thickness;
line.x_end = p_rect->x + rect_width;
line.y_end = p_rect->y + rect_height;
(void)nrf_gfx_line_draw(p_instance, &line, color);
}
return NRF_SUCCESS;
}
void nrf_gfx_screen_fill(nrf_lcd_t const * p_instance, uint32_t color)
{
rect_draw(p_instance, 0, 0, nrf_gfx_width_get(p_instance), nrf_gfx_height_get(p_instance), color);
}
ret_code_t nrf_gfx_bmp565_draw(nrf_lcd_t const * p_instance,
nrf_gfx_rect_t const * p_rect,
uint16_t const * img_buf)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_rect != NULL);
ASSERT(img_buf != NULL);
if ((p_rect->x > nrf_gfx_width_get(p_instance)) || (p_rect->y > nrf_gfx_height_get(p_instance)))
{
return NRF_ERROR_INVALID_PARAM;
}
size_t idx;
uint16_t pixel;
uint8_t padding = p_rect->width % 2;
for (int32_t i = 0; i < p_rect->height; i++)
{
for (uint32_t j = 0; j < p_rect->width; j++)
{
idx = (uint32_t)((p_rect->height - i - 1) * (p_rect->width + padding) + j);
pixel = (img_buf[idx] >> 8) | (img_buf[idx] << 8);
pixel_draw(p_instance, p_rect->x + j, p_rect->y + i, pixel);
}
}
return NRF_SUCCESS;
}
void nrf_gfx_background_set(nrf_lcd_t const * p_instance, uint16_t const * img_buf)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(img_buf != NULL);
const nrf_gfx_rect_t rectangle =
{
.x = 0,
.y = 0,
.width = nrf_gfx_width_get(p_instance),
.height = nrf_gfx_height_get(p_instance)
};
(void)nrf_gfx_bmp565_draw(p_instance, &rectangle, img_buf);
}
void nrf_gfx_display(nrf_lcd_t const * p_instance)
{
ASSERT(p_instance != NULL);
p_instance->lcd_display();
}
void nrf_gfx_rotation_set(nrf_lcd_t const * p_instance, nrf_lcd_rotation_t rotation)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
bool rotated = (bool)(p_instance->p_lcd_cb->rotation % 2);
uint16_t height = !rotated ? nrf_gfx_height_get(p_instance) :
nrf_gfx_width_get(p_instance);
uint16_t width = !rotated ? nrf_gfx_width_get(p_instance) :
nrf_gfx_height_get(p_instance);
p_instance->p_lcd_cb->rotation = rotation;
switch (rotation) {
case NRF_LCD_ROTATE_0:
p_instance->p_lcd_cb->height = height;
p_instance->p_lcd_cb->width = width;
break;
case NRF_LCD_ROTATE_90:
p_instance->p_lcd_cb->height = width;
p_instance->p_lcd_cb->width = height;
break;
case NRF_LCD_ROTATE_180:
p_instance->p_lcd_cb->height = height;
p_instance->p_lcd_cb->width = width;
break;
case NRF_LCD_ROTATE_270:
p_instance->p_lcd_cb->height = width;
p_instance->p_lcd_cb->width = height;
break;
default:
break;
}
p_instance->lcd_rotation_set(rotation);
}
void nrf_gfx_invert(nrf_lcd_t const * p_instance, bool invert)
{
ASSERT(p_instance != NULL);
p_instance->lcd_display_invert(invert);
}
ret_code_t nrf_gfx_print(nrf_lcd_t const * p_instance,
nrf_gfx_point_t const * p_point,
uint16_t font_color,
const char * string,
const nrf_gfx_font_desc_t * p_font,
bool wrap)
{
ASSERT(p_instance != NULL);
ASSERT(p_instance->p_lcd_cb->state != NRFX_DRV_STATE_UNINITIALIZED);
ASSERT(p_point != NULL);
ASSERT(string != NULL);
ASSERT(p_font != NULL);
uint16_t x = p_point->x;
uint16_t y = p_point->y;
if (y > (nrf_gfx_height_get(p_instance) - p_font->height))
{
// Not enough space to write even single char.
return NRF_ERROR_INVALID_PARAM;
}
for (size_t i = 0; string[i] != '\0' ; i++)
{
if (string[i] == '\n')
{
x = p_point->x;
y += p_font->height + p_font->height / 10;
}
else
{
write_character(p_instance, p_font, (uint8_t)string[i], &x, y, font_color);
}
uint8_t char_idx = string[i] - p_font->startChar;
uint16_t char_width = string[i] == ' ' ? (p_font->height / 2) :
p_font->charInfo[char_idx].widthBits;
if (x > (nrf_gfx_width_get(p_instance) - char_width))
{
if (wrap)
{
x = p_point->x;
y += p_font->height + p_font->height / 10;
}
else
{
break;
}
if (y > (nrf_gfx_height_get(p_instance) - p_font->height))
{
break;
}
}
}
return NRF_SUCCESS;
}
uint16_t nrf_gfx_height_get(nrf_lcd_t const * p_instance)
{
ASSERT(p_instance != NULL);
return p_instance->p_lcd_cb->height;
}
uint16_t nrf_gfx_width_get(nrf_lcd_t const * p_instance)
{
ASSERT(p_instance != NULL);
return p_instance->p_lcd_cb->width;
}
#endif //NRF_MODULE_ENABLED(NRF_GFX)

320
components/libraries/gfx/nrf_gfx.h Normal file
View File

@@ -0,0 +1,320 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef NRF_GFX_H__
#define NRF_GFX_H__
#include <stdint.h>
#include <stdbool.h>
#include "sdk_errors.h"
#include "nrf_lcd.h"
#include "nrf_font.h"
/** @file
*
* @addtogroup ili9341_config
* @ingroup ext_drivers
*
* @addtogroup st7735_config
* @ingroup ext_drivers
*
* @defgroup nrf_gfx GFX Library
* @{
* @ingroup app_common
*
* @brief Module for drawing graphical objects like lines, circles, and rectangles.
Provides support for different fonts.
*/
/**
* @brief GFX point object structure.
*/
typedef struct
{
uint16_t x; /**< Horizontal coordinate of the point where to start drawing the object. */
uint16_t y; /**< Vertical coordinate of the point where to start drawing the object. */
}nrf_gfx_point_t;
/**
* @brief GFX line object structure.
*/
typedef struct
{
uint16_t x_start; /**< Horizontal coordinate of the point where to start drawing the object. */
uint16_t y_start; /**< Vertical coordinate of the point where to start drawing the object. */
uint16_t x_end; /**< Horizontal coordinate of the point where to end drawing the object. */
uint16_t y_end; /**< Vertical coordinate of the point where to end drawing the object. */
uint16_t thickness; /**< Thickness of the border of the object. */
}nrf_gfx_line_t;
/**
* @brief GFX circle object structure.
*/
typedef struct
{
uint16_t x; /**< Horizontal coordinate of the centre of the object. */
uint16_t y; /**< Vertical coordinate of the centre of the object. */
uint16_t r; /**< Radius of the object. */
}nrf_gfx_circle_t;
/**
* @brief GFX rectangle object structure.
*/
typedef struct
{
uint16_t x; /**< Horizontal coordinate of the point where to start drawing the object. */
uint16_t y; /**< Vertical coordinate of the point where to start drawing the object. */
uint16_t width; /**< Width of the object. */
uint16_t height; /**< Height of the object. */
}nrf_gfx_rect_t;
/**
* @defgroup nrf_gfx_macros Macros for defining new graphic objects
* @{
*/
#define NRF_GFX_POINT(_x, _y) \
{ \
.x = (_x), \
.y = (_y) \
}
#define NRF_GFX_LINE(_x_0, _y_0, _x_1, _y_1, _thickness) \
{ \
.x_start = (_x_0), \
.y_start = (_y_0), \
.x_end = (_x_1), \
.y_end = (_y_1), \
.thickness = (_thickness) \
}
#define NRF_GFX_CIRCLE(_x, _y, _radius) \
{ \
.x = (_x), \
.y = (_y), \
.r = (_radius) \
}
#define NRF_GFX_RECT(_x, _y, _width, _height) \
{ \
.x = (_x), \
.y = (_y), \
.width = (_width), \
.height = (_height) \
}
/* @} */
/**
* @brief Font descriptor type.
*/
typedef FONT_INFO nrf_gfx_font_desc_t;
/**
* @brief Function for initializing the GFX library.
*
* @param[in] p_instance Pointer to the LCD instance.
*
* @return Values returned by @ref nrf_lcd_t::lcd_init.
*/
ret_code_t nrf_gfx_init(nrf_lcd_t const * p_instance);
/**
* @brief Function for uninitializing the GFX library.
*
* @param[in] p_instance Pointer to the LCD instance.
*
* @return Values returned by @ref nrf_lcd_t::lcd_uninit.
*/
void nrf_gfx_uninit(nrf_lcd_t const * p_instance);
/**
* @brief Function for drawing a point.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_point Pointer to the point object.
* @param[in] color Color of the object in the display accepted format.
*/
void nrf_gfx_point_draw(nrf_lcd_t const * p_instance, nrf_gfx_point_t const * p_point, uint32_t color);
/**
* @brief Function for drawing a line.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_line Pointer to the line object.
* @param[in] color Color of the object in the display accepted format.
*
* @retval NRF_ERROR_INVALID_PARAM If object position is not on the screen.
* @retval NRF_SUCCESS If object was successfully drawn.
*/
ret_code_t nrf_gfx_line_draw(nrf_lcd_t const * p_instance, nrf_gfx_line_t const * p_line, uint32_t color);
/**
* @brief Function for drawing a circle.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_circle Pointer to the circle object.
* @param[in] color Color of the object in the display accepted format.
* @param[in] fill If true, the circle will be filled.
*
* @retval NRF_ERROR_INVALID_PARAM If object position is not on the screen.
* @retval NRF_SUCCESS If object was successfully drawn.
*
* @note The height and width of the drawn circle are determined by: radius * 2 + 1.
*
*/
ret_code_t nrf_gfx_circle_draw(nrf_lcd_t const * p_instance,
nrf_gfx_circle_t const * p_circle,
uint32_t color,
bool fill);
/**
* @brief Function for drawing a rectangle.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_rect Pointer to the rectangle object.
* @param[in] thickness Thickness of the rectangle border.
* @param[in] color Color of the object in the display accepted format.
* @param[in] fill If true, the rectangle will be filled.
*
* @retval NRF_ERROR_INVALID_PARAM If object position is not on the screen.
* @retval NRF_SUCCESS If object was successfully drawn.
*/
ret_code_t nrf_gfx_rect_draw(nrf_lcd_t const * p_instance,
nrf_gfx_rect_t const * p_rect,
uint16_t thickness,
uint32_t color,
bool fill);
/**
* @brief Function for filling the screen with selected color.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] color Color of the screen in the display accepted format.
*/
void nrf_gfx_screen_fill(nrf_lcd_t const * p_instance, uint32_t color);
/**
* @brief Function for drawing an image from a .bmp file.
*
* Data in img_buf is expected to be stored in 2-byte samples, little endianness, RGB565 format.
* Pointer should skip the header and point to the first byte of data.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_rect Pointer to the rectangle object.
* @param[in] img_buf Pointer to data from the .bmp file.
*
* @note Only compatible with displays that accept pixels in RGB565 format.
*/
ret_code_t nrf_gfx_bmp565_draw(nrf_lcd_t const * p_instance,
nrf_gfx_rect_t const * p_rect,
uint16_t const * img_buf);
/**
* @brief Function for drawing an image from a .bmp file.
*
* Data in img_buf is expected to be stored in 2-byte samples, little endianness, RGB565 format.
* Pointer should skip the header and point to the first byte of data.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] img_buf Pointer to data from the .bmp file.
*
* @note Only compatible with displays that accept pixels in RGB565 format.
*/
void nrf_gfx_background_set(nrf_lcd_t const * p_instance, uint16_t const * img_buf);
/**
* @brief Function for displaying data from an internal frame buffer.
*
* @param[in] p_instance Pointer to the LCD instance.
*/
void nrf_gfx_display(nrf_lcd_t const * p_instance);
/**
* @brief Function for setting screen rotation.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] rotation Rotation to be made.
*/
void nrf_gfx_rotation_set(nrf_lcd_t const * p_instance, nrf_lcd_rotation_t rotation);
/**
* @brief Function for setting inversion of colors.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] invert If true, inversion will be set.
*/
void nrf_gfx_invert(nrf_lcd_t const * p_instance, bool invert);
/**
* @brief Function for printing a string to the screen.
*
* @param[in] p_instance Pointer to the LCD instance.
* @param[in] p_point Pointer to the point where to start drawing the object.
* @param[in] font_color Color of the font in the display accepted format.
* @param[in] p_string Pointer to the string.
* @param[in] p_font Pointer to the font descriptor.
* @param[in] wrap If true, the string will be wrapped to the new line.
*/
ret_code_t nrf_gfx_print(nrf_lcd_t const * p_instance,
nrf_gfx_point_t const * p_point,
uint16_t font_color,
const char * p_string,
const nrf_gfx_font_desc_t * p_font,
bool wrap);
/**
* @brief Function for getting the height of the screen.
*
* @param[in] p_instance Pointer to the LCD instance.
*
*/
uint16_t nrf_gfx_height_get(nrf_lcd_t const * p_instance);
/**
* @brief Function for getting the width of the screen.
*
* @param[in] p_instance Pointer to the LCD instance.
*
*/
uint16_t nrf_gfx_width_get(nrf_lcd_t const * p_instance);
/* @} */
#endif //NRF_GFX_H__

144
components/libraries/gfx/nrf_lcd.h Normal file
View File

@@ -0,0 +1,144 @@
/**
* Copyright (c) 2017 - 2020, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef NRF_LCD_H__
#define NRF_LCD_H__
#include <nrfx.h>
/** @file
*
* @defgroup nrf_lcd LCD Library
* @{
* @ingroup nrf_gfx
*
* @brief This module defines generic API for LCDs.
*/
/**
* @brief Enumerator with available rotations.
*/
typedef enum{
NRF_LCD_ROTATE_0 = 0, /**< Rotate 0 degrees, clockwise. */
NRF_LCD_ROTATE_90, /**< Rotate 90 degrees, clockwise. */
NRF_LCD_ROTATE_180, /**< Rotate 180 degrees, clockwise. */
NRF_LCD_ROTATE_270 /**< Rotate 270 degrees, clockwise. */
}nrf_lcd_rotation_t;
/**
* @brief LCD instance control block.
*/
typedef struct
{
nrfx_drv_state_t state; /**< State of LCD instance. */
uint16_t height; /**< LCD height. */
uint16_t width; /**< LCD width. */
nrf_lcd_rotation_t rotation; /**< LCD rotation. */
}lcd_cb_t;
/**
* @brief LCD instance type.
*
* This structure provides generic API for LCDs.
*/
typedef struct
{
/**
* @brief Function for initializing the LCD controller.
*/
ret_code_t (* lcd_init)(void);
/**
* @brief Function for uninitializing the LCD controller.
*/
void (* lcd_uninit)(void);
/**
* @brief Function for drawing a single pixel.
*
* @param[in] x Horizontal coordinate of the pixel.
* @param[in] y Vertical coordinate of the pixel.
* @param[in] color Color of the pixel in LCD accepted format.
*/
void (* lcd_pixel_draw)(uint16_t x, uint16_t y, uint32_t color);
/**
* @brief Function for drawing a filled rectangle.
*
* @param[in] x Horizontal coordinate of the point where to start drawing the rectangle.
* @param[in] y Vertical coordinate of the point where to start drawing the rectangle.
* @param[in] width Width of the image.
* @param[in] height Height of the image.
* @param[in] color Color with which to fill the rectangle in LCD accepted format.
*/
void (* lcd_rect_draw)(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint32_t color);
/**
* @brief Function for displaying data from an internal frame buffer.
*
* This function may be used when functions for drawing do not write directly to
* LCD but to an internal frame buffer. It could be implemented to write data from this
* buffer to LCD.
*/
void (* lcd_display)(void);
/**
* @brief Function for rotating the screen.
*
* @param[in] rotation Rotation as enumerated value.
*/
void (* lcd_rotation_set)(nrf_lcd_rotation_t rotation);
/**
* @brief Function for setting inversion of colors on the screen.
*
* @param[in] invert If true, inversion will be set.
*/
void (* lcd_display_invert)(bool invert);
/**
* @brief Pointer to the LCD instance control block.
*/
lcd_cb_t * p_lcd_cb;
}nrf_lcd_t;
/* @} */
#endif // NRF_LCD_H__