331 lines
10 KiB
C
331 lines
10 KiB
C
/***************************************************************************
|
|
* Copyright (C) 2020 by Federico Izzo IU2NUO, *
|
|
* Niccolò Izzo IU2KIN, *
|
|
* Silvano Seva IU2KWO *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 3 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/> *
|
|
***************************************************************************/
|
|
|
|
/**
|
|
* This source file provides an RGB implementation for the graphics.h interface
|
|
* It is suitable for color displays, it will have grayscale and B/W counterparts
|
|
*/
|
|
|
|
#include <os.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <hwconfig.h>
|
|
#include "display.h"
|
|
#include "graphics.h"
|
|
|
|
/* This graphics driver is meant for an RGB565 little endian pixel format.
|
|
* Thus, to accomodate for the endianness, the fields in struct rgb565_t have to
|
|
* be written in reversed order.
|
|
*
|
|
* For more details about endianness and bitfield structs see the following web
|
|
* page: http://mjfrazer.org/mjfrazer/bitfields/
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
uint16_t b : 5;
|
|
uint16_t g : 6;
|
|
uint16_t r : 5;
|
|
} rgb565_t;
|
|
|
|
bool initialized = 0;
|
|
rgb565_t *buf;
|
|
|
|
void gfx_init()
|
|
{
|
|
display_init();
|
|
buf = (rgb565_t *)(display_getFrameBuffer());
|
|
initialized = 1;
|
|
}
|
|
|
|
void gfx_terminate()
|
|
{
|
|
display_terminate();
|
|
initialized = 0;
|
|
}
|
|
|
|
void gfx_renderRows(uint8_t startRow, uint8_t endRow)
|
|
{
|
|
display_renderRows(startRow, endRow);
|
|
}
|
|
|
|
void gfx_render()
|
|
{
|
|
display_render();
|
|
}
|
|
|
|
bool gfx_renderingInProgress()
|
|
{
|
|
return display_renderingInProgress();
|
|
}
|
|
|
|
rgb565_t _true2highColor(color_t true_color)
|
|
{
|
|
rgb565_t high_color;
|
|
high_color.r = true_color.r >> 3;
|
|
high_color.g = true_color.g >> 2;
|
|
high_color.b = true_color.b >> 3;
|
|
|
|
return high_color;
|
|
}
|
|
|
|
void gfx_clearRows(uint8_t startRow, uint8_t endRow)
|
|
{
|
|
if(!initialized) return;
|
|
if(endRow < startRow) return;
|
|
uint16_t start = startRow * SCREEN_WIDTH * sizeof(rgb565_t);
|
|
uint16_t height = endRow - startRow * SCREEN_WIDTH * sizeof(rgb565_t);
|
|
// Set the specified rows to 0x00 = make the screen black
|
|
memset(buf + start, 0x00, height);
|
|
}
|
|
|
|
void gfx_clearScreen()
|
|
{
|
|
if(!initialized) return;
|
|
// Set the whole framebuffer to 0x00 = make the screen black
|
|
memset(buf, 0x00, sizeof(rgb565_t) * SCREEN_WIDTH * SCREEN_HEIGHT);
|
|
}
|
|
|
|
void gfx_fillScreen(color_t color)
|
|
{
|
|
if(!initialized) return;
|
|
rgb565_t color_565 = _true2highColor(color);
|
|
for(int y = 0; y < SCREEN_HEIGHT; y++)
|
|
{
|
|
for(int x = 0; x < SCREEN_WIDTH; x++)
|
|
{
|
|
buf[x + y*SCREEN_WIDTH] = color_565;
|
|
}
|
|
}
|
|
}
|
|
|
|
void gfx_setPixel(point_t pos, color_t color)
|
|
{
|
|
if (pos.x >= SCREEN_WIDTH || pos.y >= SCREEN_HEIGHT)
|
|
return; // off the screen
|
|
|
|
buf[pos.x + pos.y*SCREEN_WIDTH] = _true2highColor(color);
|
|
}
|
|
|
|
void gfx_drawLine(point_t start, point_t end, color_t color)
|
|
{
|
|
if(!initialized) return;
|
|
rgb565_t color_565 = _true2highColor(color);
|
|
for(int y = start.y; y <= end.y; y++)
|
|
{
|
|
for(int x = start.x; x <= end.x; x++)
|
|
{
|
|
buf[x + y*SCREEN_WIDTH] = color_565;
|
|
}
|
|
}
|
|
}
|
|
|
|
void gfx_drawRect(point_t start, uint16_t width, uint16_t height, color_t color, bool fill)
|
|
{
|
|
if(!initialized) return;
|
|
rgb565_t color_565 = _true2highColor(color);
|
|
uint16_t x_max = start.x + width - 1;
|
|
uint16_t y_max = start.y + height - 1;
|
|
bool perimeter = 0;
|
|
if(x_max > (SCREEN_WIDTH - 1)) x_max = SCREEN_WIDTH - 1;
|
|
if(y_max > (SCREEN_HEIGHT - 1)) y_max = SCREEN_HEIGHT - 1;
|
|
for(int y = start.y; y <= y_max; y++)
|
|
{
|
|
for(int x = start.x; x <= x_max; x++)
|
|
{
|
|
if(y == start.y || y == y_max || x == start.x || x == x_max) perimeter = 1;
|
|
else perimeter = 0;
|
|
// If fill is false, draw only rectangle perimeter
|
|
if(fill || perimeter) buf[x + y*SCREEN_WIDTH] = color_565;
|
|
}
|
|
}
|
|
}
|
|
|
|
void gfx_drawHLine(uint16_t y, uint16_t height, color_t color)
|
|
{
|
|
point_t start = {0, y};
|
|
gfx_drawRect(start, SCREEN_WIDTH, height, color, 1);
|
|
}
|
|
|
|
void gfx_drawVLine(uint16_t x, uint16_t width, color_t color)
|
|
{
|
|
point_t start = {x, 0};
|
|
gfx_drawRect(start, width, SCREEN_HEIGHT, color, 1);
|
|
}
|
|
|
|
/**
|
|
* Compute the pixel size of the first text line
|
|
* @param f: font used as the source of glyphs
|
|
* @param text: the input text
|
|
* @param length: the length of the input text, used for boundary checking
|
|
*/
|
|
static inline uint16_t get_line_size(GFXfont f,
|
|
const char *text,
|
|
uint16_t length) {
|
|
uint16_t line_size = 0;
|
|
for(unsigned i = 0;
|
|
i < length && text[i] != '\n' && text[i] != '\r';
|
|
i++) {
|
|
GFXglyph glyph = f.glyph[text[i] - f.first];
|
|
if (line_size + glyph.xAdvance < SCREEN_WIDTH)
|
|
line_size += glyph.xAdvance;
|
|
else
|
|
break;
|
|
}
|
|
return line_size;
|
|
}
|
|
|
|
/**
|
|
* Compute the start x coordinate of a new line of given pixel size
|
|
* @param alinment: enum representing the text alignment
|
|
* @param line_size: the size of the current text line in pixels
|
|
*/
|
|
static inline uint16_t get_reset_x(textAlign_t alignment, uint16_t line_size) {
|
|
switch(alignment)
|
|
{
|
|
case TEXT_ALIGN_LEFT:
|
|
return 0;
|
|
case TEXT_ALIGN_CENTER:
|
|
return (SCREEN_WIDTH - line_size)/2;
|
|
case TEXT_ALIGN_RIGHT:
|
|
return SCREEN_WIDTH - line_size;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void gfx_print(point_t start, const char *text, fontSize_t size, textAlign_t alignment, color_t color) {
|
|
|
|
rgb565_t color_565 = _true2highColor(color);
|
|
|
|
GFXfont f = fonts[size];
|
|
|
|
size_t len = strlen(text);
|
|
|
|
// Compute size of the first row in pixels
|
|
uint16_t line_size = get_line_size(f, text, len);
|
|
uint16_t reset_x = get_reset_x(alignment, line_size);
|
|
start.x = reset_x;
|
|
|
|
/* For each char in the string */
|
|
for(unsigned i = 0; i < len; i++) {
|
|
char c = text[i];
|
|
GFXglyph glyph = f.glyph[c - f.first];
|
|
uint8_t *bitmap = f.bitmap;
|
|
|
|
uint16_t bo = glyph.bitmapOffset;
|
|
uint8_t w = glyph.width, h = glyph.height;
|
|
int8_t xo = glyph.xOffset,
|
|
yo = glyph.yOffset;
|
|
uint8_t xx, yy, bits = 0, bit = 0;
|
|
|
|
// Handle newline and carriage return
|
|
if (c == '\n') {
|
|
start.x = reset_x;
|
|
start.y += f.yAdvance;
|
|
continue;
|
|
} else if (c == '\r') {
|
|
start.x = reset_x;
|
|
continue;
|
|
}
|
|
|
|
// Handle wrap around
|
|
if (start.x + glyph.xAdvance > SCREEN_WIDTH) {
|
|
// Compute size of the first row in pixels
|
|
line_size = get_line_size(f, text, len);
|
|
start.x = reset_x = get_reset_x(alignment, line_size);
|
|
start.y += f.yAdvance;
|
|
}
|
|
|
|
// Draw bitmap
|
|
for (yy = 0; yy < h; yy++) {
|
|
for (xx = 0; xx < w; xx++) {
|
|
if (!(bit++ & 7)) {
|
|
bits = bitmap[bo++];
|
|
}
|
|
if (bits & 0x80) {
|
|
if (start.y + yo + yy < SCREEN_HEIGHT && start.x + xo + xx < SCREEN_WIDTH && start.y + yo + yy > 0 && start.x + xo + xx > 0)
|
|
buf[(start.y + yo + yy) * SCREEN_WIDTH +
|
|
start.x + xo + xx] = color_565;
|
|
}
|
|
bits <<= 1;
|
|
}
|
|
}
|
|
start.x += glyph.xAdvance;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function to draw battery of arbitrary size
|
|
* starting coordinates are relative to the top left point.
|
|
*
|
|
* ****************** |
|
|
* * * |
|
|
* * ******* * |
|
|
* * ******* ** |
|
|
* * ******* ** | <-- Height (px)
|
|
* * ******* * |
|
|
* * * |
|
|
* ****************** |
|
|
*
|
|
* __________________
|
|
*
|
|
* ^
|
|
* |
|
|
*
|
|
* Width (px)
|
|
*
|
|
*/
|
|
void gfx_drawBattery(point_t start, uint16_t width, uint16_t height, float percentage) {
|
|
printf("AFTER: %f\n", percentage);
|
|
color_t white = {255, 255, 255};
|
|
color_t green = {0, 255, 0 };
|
|
color_t yellow = {250, 180, 19 };
|
|
color_t red = {255, 0, 0 };
|
|
color_t black = {0, 0, 0 };
|
|
|
|
// Select color according to percentage
|
|
color_t bat_color = yellow;
|
|
if (percentage < 0.2)
|
|
bat_color = red;
|
|
else if (percentage > 0.8)
|
|
bat_color = green;
|
|
|
|
// Draw the battery outline
|
|
gfx_drawRect(start, width, height, white, false);
|
|
|
|
// Draw the battery fill
|
|
point_t fill_start = {start.x + 2, start.y + 2};
|
|
gfx_drawRect(fill_start, (int)(((float)(width - 4)) * percentage), height - 4, bat_color, true);
|
|
|
|
// Round corners
|
|
point_t top_left = start;
|
|
point_t top_right = {start.x + width - 1, start.y};
|
|
point_t bottom_left = {start.x, start.y + height - 1};
|
|
point_t bottom_right = {start.x + width - 1, start.y + height - 1};
|
|
gfx_setPixel(top_left, black);
|
|
gfx_setPixel(top_right, black);
|
|
gfx_setPixel(bottom_left, black);
|
|
gfx_setPixel(bottom_right, black);
|
|
|
|
// Draw the button
|
|
point_t button_start = {start.x + width, start.y + (height / 2) - 2};
|
|
point_t button_end = {start.x + width, start.y + (height / 2) + 2};
|
|
gfx_drawLine(button_start, button_end, white);
|
|
}
|