/* EPD library * * Author: LoBo (loboris@gmail.com, loboris.github) * * Module supporting SPI ePaper displays */ #include #include #include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_system.h" #include "time.h" #include #include "rom/tjpgd.h" #include "esp_heap_alloc_caps.h" #include "EPD.h" #include "EPDspi.h" #include "rom/tjpgd.h" #define DEG_TO_RAD 0.01745329252 #define RAD_TO_DEG 57.295779513 #define deg_to_rad 0.01745329252 + 3.14159265359 #define swap(a, b) { int16_t t = a; a = b; b = t; } #define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt))) #if !defined(max) #define max(A,B) ( (A) > (B) ? (A):(B)) #endif #if !defined(min) #define min(A,B) ( (A) < (B) ? (A):(B)) #endif // Embedded fonts extern uint8_t tft_SmallFont[]; extern uint8_t tft_DefaultFont[]; extern uint8_t tft_Dejavu18[]; extern uint8_t tft_Dejavu24[]; extern uint8_t tft_Ubuntu16[]; extern uint8_t tft_Comic24[]; extern uint8_t tft_minya24[]; extern uint8_t tft_tooney32[]; // ============================================================== // ==== Set default values of global variables ================== uint8_t orientation = LANDSCAPE_0; // screen orientation uint16_t font_rotate = 0; // font rotation uint8_t font_transparent = 0; uint8_t font_forceFixed = 0; uint8_t text_wrap = 0; // character wrapping to new line color_t _fg = EPD_BLACK; color_t _bg = EPD_WHITE; float _angleOffset = DEFAULT_ANGLE_OFFSET; int EPD_X = 0; int EPD_Y = 0; dispWin_t dispWin = { .x1 = 0, .y1 = 0, .x2 = EPD_DISPLAY_WIDTH-1, .y2 = EPD_DISPLAY_HEIGHT-1, }; Font_t cfont = { .font = tft_DefaultFont, .x_size = 0, .y_size = 0x0B, .offset = 0, .numchars = 95, .bitmap = 1, }; uint8_t font_line_space = 0; uint8_t image_debug = 0; // ============================================================== typedef struct { uint8_t charCode; int adjYOffset; int width; int height; int xOffset; int xDelta; uint16_t dataPtr; } propFont; static dispWin_t dispWinTemp; static uint8_t *userfont = NULL; static int EPD_OFFSET = 0; static propFont fontChar; static float _arcAngleMax = DEFAULT_ARC_ANGLE_MAX; // ============================================================================================================== //---------------------------------------------- static void drawPixel(int x, int y, uint8_t val) { if (orientation == LANDSCAPE_180) { x = _width - x - 1; y = _height - y - 1; } if (_gs) { val &= 0x0F; //if (gs_drawBuff[(y * _width) + x] != val) { gs_drawBuff[(y * _width) + x] = val; gs_used_shades |= (1<> 3)) + (y>>3)]; uint8_t new_val = buf_val; if (val) new_val &= (0x80 >> (y % 8)) ^ 0xFF; else new_val |= (0x80 >> (y % 8)); //if (new_val != buf_val) drawBuff[(x * (_height>>3)) + (y>>3)] = new_val; drawBuff[(x * (_height>>3)) + (y>>3)] = new_val; } } //------------------------------------------------------------------------- static void EPD_pushColorRep(int x1, int y1, int x2, int y2, color_t color) { if (_gs == 0) color &= 0x01; else color &= 0x0F; for (int y=y1; y<=y2; y++) { for (int x = x1; x<=x2; x++){ drawPixel(x, y, color); } } } /* //--------------------------------------------------------------------------------------- static void copyBuff(int x1, int y1, int x2, int y2, uint8_t *src_buf, uint8_t *dest_buf) { if uint8_t buf_val1 = (src_buf[(x1 * (EPD_DISPLAY_HEIGHT>>3)) + (y1>>3)]) ; uint8_t val = 0x80 >> (y1 % 8); if (val) buf_val &= (0x80 >> (y % 8)) ^ 0xFF; else buf_val |= (0x80 >> (y % 8)); drawBuff[(x * (EPD_DISPLAY_HEIGHT>>3)) + (y>>3)] = buf_val; } */ // ============================================================================================================== // ========================================================================= // ** All drawings are clipped to 'dispWin' ** // ** All x,y coordinates in public functions are relative to clip window ** // =========== : Public functions // ----------- : Local functions // ========================================================================= // Compare two colors; return 0 if equal //============================================ int EPD_compare_colors(color_t c1, color_t c2) { if (c1 != c2) return 1; return 0; } // draw color pixel on screen //----------------------------------------------------------- static void _drawPixel(int16_t x, int16_t y, color_t color) { if ((x < dispWin.x1) || (y < dispWin.y1) || (x > dispWin.x2) || (y > dispWin.y2)) return; drawPixel(x, y, color); } //======================================================= void EPD_drawPixel(int16_t x, int16_t y, color_t color) { _drawPixel(x+dispWin.x1, y+dispWin.y1, color); } //-------------------------------------------------------------------------- static void _drawFastVLine(int16_t x, int16_t y, int16_t h, color_t color) { // clipping if ((x < dispWin.x1) || (x > dispWin.x2) || (y > dispWin.y2)) return; if (y < dispWin.y1) { h -= (dispWin.y1 - y); y = dispWin.y1; } if (h < 0) h = 0; if ((y + h) > (dispWin.y2+1)) h = dispWin.y2 - y + 1; if (h == 0) h = 1; EPD_pushColorRep(x, y, x, y+h-1, color); } //-------------------------------------------------------------------------- static void _drawFastHLine(int16_t x, int16_t y, int16_t w, color_t color) { // clipping if ((y < dispWin.y1) || (x > dispWin.x2) || (y > dispWin.y2)) return; if (x < dispWin.x1) { w -= (dispWin.x1 - x); x = dispWin.x1; } if (w < 0) w = 0; if ((x + w) > (dispWin.x2+1)) w = dispWin.x2 - x + 1; if (w == 0) w = 1; EPD_pushColorRep(x, y, x+w-1, y, color); } //====================================================================== void EPD_drawFastVLine(int16_t x, int16_t y, int16_t h, color_t color) { _drawFastVLine(x+dispWin.x1, y+dispWin.y1, h, color); } //====================================================================== void EPD_drawFastHLine(int16_t x, int16_t y, int16_t w, color_t color) { _drawFastHLine(x+dispWin.x1, y+dispWin.y1, w, color); } // Bresenham's algorithm - thx wikipedia - speed enhanced by Bodmer this uses // the eficient FastH/V Line draw routine for segments of 2 pixels or more //---------------------------------------------------------------------------------- static void _drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color) { if (x0 == x1) { if (y0 <= y1) _drawFastVLine(x0, y0, y1-y0, color); else _drawFastVLine(x0, y1, y0-y1, color); return; } if (y0 == y1) { if (x0 <= x1) _drawFastHLine(x0, y0, x1-x0, color); else _drawFastHLine(x1, y0, x0-x1, color); return; } int steep = 0; if (abs(y1 - y0) > abs(x1 - x0)) steep = 1; if (steep) { swap(x0, y0); swap(x1, y1); } if (x0 > x1) { swap(x0, x1); swap(y0, y1); } int16_t dx = x1 - x0, dy = abs(y1 - y0);; int16_t err = dx >> 1, ystep = -1, xs = x0, dlen = 0; if (y0 < y1) ystep = 1; // Split into steep and not steep for FastH/V separation if (steep) { for (; x0 <= x1; x0++) { dlen++; err -= dy; if (err < 0) { err += dx; if (dlen == 1) _drawPixel(y0, xs, color); else _drawFastVLine(y0, xs, dlen, color); dlen = 0; y0 += ystep; xs = x0 + 1; } } if (dlen) _drawFastVLine(y0, xs, dlen, color); } else { for (; x0 <= x1; x0++) { dlen++; err -= dy; if (err < 0) { err += dx; if (dlen == 1) _drawPixel(xs, y0, color); else _drawFastHLine(xs, y0, dlen, color); dlen = 0; y0 += ystep; xs = x0 + 1; } } if (dlen) _drawFastHLine(xs, y0, dlen, color); } } //============================================================================== void EPD_drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, color_t color) { _drawLine(x0+dispWin.x1, y0+dispWin.y1, x1+dispWin.x1, y1+dispWin.y1, color); } // fill a rectangle //-------------------------------------------------------------------------------- static void _fillRect(int16_t x, int16_t y, int16_t w, int16_t h, color_t color) { // clipping if ((x >= dispWin.x2) || (y > dispWin.y2)) return; if (x < dispWin.x1) { w -= (dispWin.x1 - x); x = dispWin.x1; } if (y < dispWin.y1) { h -= (dispWin.y1 - y); y = dispWin.y1; } if (w < 0) w = 0; if (h < 0) h = 0; if ((x + w) > (dispWin.x2+1)) w = dispWin.x2 - x + 1; if ((y + h) > (dispWin.y2+1)) h = dispWin.y2 - y + 1; if (w == 0) w = 1; if (h == 0) h = 1; EPD_pushColorRep(x, y, x+w-1, y+h-1, color); } //============================================================================ void EPD_fillRect(int16_t x, int16_t y, int16_t w, int16_t h, color_t color) { _fillRect(x+dispWin.x1, y+dispWin.y1, w, h, color); } //================================== void EPD_fillScreen(color_t color) { color &= 0x0F; memset(disp_buffer, ((color&1) ? 0 : 0xFF), _width * (_height/8)); memset(gs_disp_buffer, color, _width * _height); gs_used_shades = 0; } //================================== void EPD_fillWindow(color_t color) { EPD_pushColorRep(dispWin.x1, dispWin.y1, dispWin.x2, dispWin.y2, 0xFF); } // ^^^============= Basics drawing functions ================================^^^ // ================ Graphics drawing functions ================================== //----------------------------------------------------------------------------------- static void _drawRect(uint16_t x1,uint16_t y1,uint16_t w,uint16_t h, color_t color) { _drawFastHLine(x1,y1,w, color); _drawFastVLine(x1+w-1,y1,h, color); _drawFastHLine(x1,y1+h-1,w, color); _drawFastVLine(x1,y1,h, color); } //=============================================================================== void EPD_drawRect(uint16_t x1,uint16_t y1,uint16_t w,uint16_t h, color_t color) { _drawRect(x1+dispWin.x1, y1+dispWin.y1, w, h, color); } //------------------------------------------------------------------------------------------------- static void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, color_t color) { int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r; while (x < y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x; if (cornername & 0x4) { _drawPixel(x0 + x, y0 + y, color); _drawPixel(x0 + y, y0 + x, color); } if (cornername & 0x2) { _drawPixel(x0 + x, y0 - y, color); _drawPixel(x0 + y, y0 - x, color); } if (cornername & 0x8) { _drawPixel(x0 - y, y0 + x, color); _drawPixel(x0 - x, y0 + y, color); } if (cornername & 0x1) { _drawPixel(x0 - y, y0 - x, color); _drawPixel(x0 - x, y0 - y, color); } } } // Used to do circles and roundrects //---------------------------------------------------------------------------------------------------------------- static void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, color_t color) { int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r; int16_t ylm = x0 - r; while (x < y) { if (f >= 0) { if (cornername & 0x1) _drawFastVLine(x0 + y, y0 - x, 2 * x + 1 + delta, color); if (cornername & 0x2) _drawFastVLine(x0 - y, y0 - x, 2 * x + 1 + delta, color); ylm = x0 - y; y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x; if ((x0 - x) > ylm) { if (cornername & 0x1) _drawFastVLine(x0 + x, y0 - y, 2 * y + 1 + delta, color); if (cornername & 0x2) _drawFastVLine(x0 - x, y0 - y, 2 * y + 1 + delta, color); } } } // Draw a rounded rectangle //============================================================================================= void EPD_drawRoundRect(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t r, color_t color) { x += dispWin.x1; y += dispWin.y1; // smarter version _drawFastHLine(x + r, y, w - 2 * r, color); // Top _drawFastHLine(x + r, y + h - 1, w - 2 * r, color); // Bottom _drawFastVLine(x, y + r, h - 2 * r, color); // Left _drawFastVLine(x + w - 1, y + r, h - 2 * r, color); // Right // draw four corners drawCircleHelper(x + r, y + r, r, 1, color); drawCircleHelper(x + w - r - 1, y + r, r, 2, color); drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4, color); drawCircleHelper(x + r, y + h - r - 1, r, 8, color); } // Fill a rounded rectangle //============================================================================================= void EPD_fillRoundRect(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t r, color_t color) { x += dispWin.x1; y += dispWin.y1; // smarter version _fillRect(x + r, y, w - 2 * r, h, color); // draw four corners fillCircleHelper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color); fillCircleHelper(x + r, y + r, r, 2, h - 2 * r - 1, color); } //----------------------------------------------------------------------------------------------- static void _drawLineByAngle(int16_t x, int16_t y, int16_t angle, uint16_t length, color_t color) { _drawLine( x, y, x + length * cos((angle + _angleOffset) * DEG_TO_RAD), y + length * sin((angle + _angleOffset) * DEG_TO_RAD), color); } //--------------------------------------------------------------------------------------------------------------- static void _DrawLineByAngle(int16_t x, int16_t y, int16_t angle, uint16_t start, uint16_t length, color_t color) { _drawLine( x + start * cos((angle + _angleOffset) * DEG_TO_RAD), y + start * sin((angle + _angleOffset) * DEG_TO_RAD), x + (start + length) * cos((angle + _angleOffset) * DEG_TO_RAD), y + (start + length) * sin((angle + _angleOffset) * DEG_TO_RAD), color); } //=========================================================================================================== void EPD_drawLineByAngle(uint16_t x, uint16_t y, uint16_t start, uint16_t len, uint16_t angle, color_t color) { x += dispWin.x1; y += dispWin.y1; if (start == 0) _drawLineByAngle(x, y, angle, len, color); else _DrawLineByAngle(x, y, angle, start, len, color); } // Draw a triangle //-------------------------------------------------------------------------------------------------------------------- static void _drawTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, color_t color) { _drawLine(x0, y0, x1, y1, color); _drawLine(x1, y1, x2, y2, color); _drawLine(x2, y2, x0, y0, color); } //================================================================================================================ void EPD_drawTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, color_t color) { x0 += dispWin.x1; y0 += dispWin.y1; x1 += dispWin.x1; y1 += dispWin.y1; x2 += dispWin.x1; y2 += dispWin.y1; _drawLine(x0, y0, x1, y1, color); _drawLine(x1, y1, x2, y2, color); _drawLine(x2, y2, x0, y0, color); } // Fill a triangle //-------------------------------------------------------------------------------------------------------------------- static void _fillTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, color_t color) { int16_t a, b, y, last; // Sort coordinates by Y order (y2 >= y1 >= y0) if (y0 > y1) { swap(y0, y1); swap(x0, x1); } if (y1 > y2) { swap(y2, y1); swap(x2, x1); } if (y0 > y1) { swap(y0, y1); swap(x0, x1); } if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing a = b = x0; if(x1 < a) a = x1; else if(x1 > b) b = x1; if(x2 < a) a = x2; else if(x2 > b) b = x2; _drawFastHLine(a, y0, b-a+1, color); return; } int16_t dx01 = x1 - x0, dy01 = y1 - y0, dx02 = x2 - x0, dy02 = y2 - y0, dx12 = x2 - x1, dy12 = y2 - y1; int32_t sa = 0, sb = 0; // For upper part of triangle, find scanline crossings for segments // 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1 // is included here (and second loop will be skipped, avoiding a /0 // error there), otherwise scanline y1 is skipped here and handled // in the second loop...which also avoids a /0 error here if y0=y1 // (flat-topped triangle). if(y1 == y2) last = y1; // Include y1 scanline else last = y1-1; // Skip it for(y=y0; y<=last; y++) { a = x0 + sa / dy01; b = x0 + sb / dy02; sa += dx01; sb += dx02; /* longhand: a = x0 + (x1 - x0) * (y - y0) / (y1 - y0); b = x0 + (x2 - x0) * (y - y0) / (y2 - y0); */ if(a > b) swap(a,b); _drawFastHLine(a, y, b-a+1, color); } // For lower part of triangle, find scanline crossings for segments // 0-2 and 1-2. This loop is skipped if y1=y2. sa = dx12 * (y - y1); sb = dx02 * (y - y0); for(; y<=y2; y++) { a = x1 + sa / dy12; b = x0 + sb / dy02; sa += dx12; sb += dx02; /* longhand: a = x1 + (x2 - x1) * (y - y1) / (y2 - y1); b = x0 + (x2 - x0) * (y - y0) / (y2 - y0); */ if(a > b) swap(a,b); _drawFastHLine(a, y, b-a+1, color); } } //================================================================================================================ void EPD_fillTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, color_t color) { _fillTriangle( x0 + dispWin.x1, y0 + dispWin.y1, x1 + dispWin.x1, y1 + dispWin.y1, x2 + dispWin.x1, y2 + dispWin.y1, color); } //==================================================================== void EPD_drawCircle(int16_t x, int16_t y, int radius, color_t color) { x += dispWin.x1; y += dispWin.y1; int f = 1 - radius; int ddF_x = 1; int ddF_y = -2 * radius; int x1 = 0; int y1 = radius; _drawPixel(x, y + radius, color); _drawPixel(x, y - radius, color); _drawPixel(x + radius, y, color); _drawPixel(x - radius, y, color); while(x1 < y1) { if (f >= 0) { y1--; ddF_y += 2; f += ddF_y; } x1++; ddF_x += 2; f += ddF_x; _drawPixel(x + x1, y + y1, color); _drawPixel(x - x1, y + y1, color); _drawPixel(x + x1, y - y1, color); _drawPixel(x - x1, y - y1, color); _drawPixel(x + y1, y + x1, color); _drawPixel(x - y1, y + x1, color); _drawPixel(x + y1, y - x1, color); _drawPixel(x - y1, y - x1, color); } } //==================================================================== void EPD_fillCircle(int16_t x, int16_t y, int radius, color_t color) { x += dispWin.x1; y += dispWin.y1; _drawFastVLine(x, y-radius, 2*radius+1, color); fillCircleHelper(x, y, radius, 3, 0, color); } //---------------------------------------------------------------------------------------------------------------- static void _draw_ellipse_section(uint16_t x, uint16_t y, uint16_t x0, uint16_t y0, color_t color, uint8_t option) { // upper right if ( option & EPD_ELLIPSE_UPPER_RIGHT ) _drawPixel(x0 + x, y0 - y, color); // upper left if ( option & EPD_ELLIPSE_UPPER_LEFT ) _drawPixel(x0 - x, y0 - y, color); // lower right if ( option & EPD_ELLIPSE_LOWER_RIGHT ) _drawPixel(x0 + x, y0 + y, color); // lower left if ( option & EPD_ELLIPSE_LOWER_LEFT ) _drawPixel(x0 - x, y0 + y, color); } //===================================================================================================== void EPD_drawEllipse(uint16_t x0, uint16_t y0, uint16_t rx, uint16_t ry, color_t color, uint8_t option) { x0 += dispWin.x1; y0 += dispWin.y1; uint16_t x, y; int32_t xchg, ychg; int32_t err; int32_t rxrx2; int32_t ryry2; int32_t stopx, stopy; rxrx2 = rx; rxrx2 *= rx; rxrx2 *= 2; ryry2 = ry; ryry2 *= ry; ryry2 *= 2; x = rx; y = 0; xchg = 1; xchg -= rx; xchg -= rx; xchg *= ry; xchg *= ry; ychg = rx; ychg *= rx; err = 0; stopx = ryry2; stopx *= rx; stopy = 0; while( stopx >= stopy ) { _draw_ellipse_section(x, y, x0, y0, color, option); y++; stopy += rxrx2; err += ychg; ychg += rxrx2; if ( 2*err+xchg > 0 ) { x--; stopx -= ryry2; err += xchg; xchg += ryry2; } } x = 0; y = ry; xchg = ry; xchg *= ry; ychg = 1; ychg -= ry; ychg -= ry; ychg *= rx; ychg *= rx; err = 0; stopx = 0; stopy = rxrx2; stopy *= ry; while( stopx <= stopy ) { _draw_ellipse_section(x, y, x0, y0, color, option); x++; stopx += ryry2; err += xchg; xchg += ryry2; if ( 2*err+ychg > 0 ) { y--; stopy -= rxrx2; err += ychg; ychg += rxrx2; } } } //----------------------------------------------------------------------------------------------------------------------- static void _draw_filled_ellipse_section(uint16_t x, uint16_t y, uint16_t x0, uint16_t y0, color_t color, uint8_t option) { // upper right if ( option & EPD_ELLIPSE_UPPER_RIGHT ) _drawFastVLine(x0+x, y0-y, y+1, color); // upper left if ( option & EPD_ELLIPSE_UPPER_LEFT ) _drawFastVLine(x0-x, y0-y, y+1, color); // lower right if ( option & EPD_ELLIPSE_LOWER_RIGHT ) _drawFastVLine(x0+x, y0, y+1, color); // lower left if ( option & EPD_ELLIPSE_LOWER_LEFT ) _drawFastVLine(x0-x, y0, y+1, color); } //===================================================================================================== void EPD_fillEllipse(uint16_t x0, uint16_t y0, uint16_t rx, uint16_t ry, color_t color, uint8_t option) { x0 += dispWin.x1; y0 += dispWin.y1; uint16_t x, y; int32_t xchg, ychg; int32_t err; int32_t rxrx2; int32_t ryry2; int32_t stopx, stopy; rxrx2 = rx; rxrx2 *= rx; rxrx2 *= 2; ryry2 = ry; ryry2 *= ry; ryry2 *= 2; x = rx; y = 0; xchg = 1; xchg -= rx; xchg -= rx; xchg *= ry; xchg *= ry; ychg = rx; ychg *= rx; err = 0; stopx = ryry2; stopx *= rx; stopy = 0; while( stopx >= stopy ) { _draw_filled_ellipse_section(x, y, x0, y0, color, option); y++; stopy += rxrx2; err += ychg; ychg += rxrx2; if ( 2*err+xchg > 0 ) { x--; stopx -= ryry2; err += xchg; xchg += ryry2; } } x = 0; y = ry; xchg = ry; xchg *= ry; ychg = 1; ychg -= ry; ychg -= ry; ychg *= rx; ychg *= rx; err = 0; stopx = 0; stopy = rxrx2; stopy *= ry; while( stopx <= stopy ) { _draw_filled_ellipse_section(x, y, x0, y0, color, option); x++; stopx += ryry2; err += xchg; xchg += ryry2; if ( 2*err+ychg > 0 ) { y--; stopy -= rxrx2; err += ychg; ychg += rxrx2; } } } // ==== ARC DRAWING =================================================================== //--------------------------------------------------------------------------------------------------------------------------------- static void _fillArcOffsetted(uint16_t cx, uint16_t cy, uint16_t radius, uint16_t thickness, float start, float end, color_t color) { //float sslope = (float)cos_lookup(start) / (float)sin_lookup(start); //float eslope = (float)cos_lookup(end) / (float)sin_lookup(end); float sslope = (cos(start/_arcAngleMax * 2 * PI) * _arcAngleMax) / (sin(start/_arcAngleMax * 2 * PI) * _arcAngleMax) ; float eslope = (cos(end/_arcAngleMax * 2 * PI) * _arcAngleMax) / (sin(end/_arcAngleMax * 2 * PI) * _arcAngleMax); if (end == 360) eslope = -1000000; int ir2 = (radius - thickness) * (radius - thickness); int or2 = radius * radius; for (int x = -radius; x <= radius; x++) { for (int y = -radius; y <= radius; y++) { int x2 = x * x; int y2 = y * y; if ( (x2 + y2 < or2 && x2 + y2 >= ir2) && ( (y > 0 && start < 180 && x <= y * sslope) || (y < 0 && start > 180 && x >= y * sslope) || (y < 0 && start <= 180) || (y == 0 && start <= 180 && x < 0) || (y == 0 && start == 0 && x > 0) ) && ( (y > 0 && end < 180 && x >= y * eslope) || (y < 0 && end > 180 && x <= y * eslope) || (y > 0 && end >= 180) || (y == 0 && end >= 180 && x < 0) || (y == 0 && start == 0 && x > 0) ) ) _drawPixel(cx+x, cy+y, color); } } } //=========================================================================================================================== void EPD_drawArc(uint16_t cx, uint16_t cy, uint16_t r, uint16_t th, float start, float end, color_t color, color_t fillcolor) { cx += dispWin.x1; cy += dispWin.y1; if (th < 1) th = 1; if (th > r) th = r; int f = EPD_compare_colors(fillcolor, color); float astart = fmodf(start, _arcAngleMax); float aend = fmodf(end, _arcAngleMax); astart += _angleOffset; aend += _angleOffset; if (astart < 0) astart += (float)360; if (aend < 0) aend += (float)360; if (aend == 0) aend = (float)360; if (astart > aend) { _fillArcOffsetted(cx, cy, r, th, astart, _arcAngleMax, fillcolor); _fillArcOffsetted(cx, cy, r, th, 0, aend, fillcolor); if (f) { _fillArcOffsetted(cx, cy, r, 1, astart, _arcAngleMax, color); _fillArcOffsetted(cx, cy, r, 1, 0, aend, color); _fillArcOffsetted(cx, cy, r-th, 1, astart, _arcAngleMax, color); _fillArcOffsetted(cx, cy, r-th, 1, 0, aend, color); } } else { _fillArcOffsetted(cx, cy, r, th, astart, aend, fillcolor); if (f) { _fillArcOffsetted(cx, cy, r, 1, astart, aend, color); _fillArcOffsetted(cx, cy, r-th, 1, astart, aend, color); } } if (f) { _drawLine(cx + (r-th) * cos(astart * DEG_TO_RAD), cy + (r-th) * sin(astart * DEG_TO_RAD), cx + (r-1) * cos(astart * DEG_TO_RAD), cy + (r-1) * sin(astart * DEG_TO_RAD), color); _drawLine(cx + (r-th) * cos(aend * DEG_TO_RAD), cy + (r-th) * sin(aend * DEG_TO_RAD), cx + (r-1) * cos(aend * DEG_TO_RAD), cy + (r-1) * sin(aend * DEG_TO_RAD), color); } } //============================================================================================================= void EPD_drawPolygon(int cx, int cy, int sides, int diameter, color_t color, color_t fill, int rot, uint8_t th) { cx += dispWin.x1; cy += dispWin.y1; int deg = rot - _angleOffset; int f = EPD_compare_colors(fill, color); if (sides < MIN_POLIGON_SIDES) sides = MIN_POLIGON_SIDES; // This ensures the minimum side number if (sides > MAX_POLIGON_SIDES) sides = MAX_POLIGON_SIDES; // This ensures the maximum side number int Xpoints[sides], Ypoints[sides]; // Set the arrays based on the number of sides entered int rads = 360 / sides; // This equally spaces the points. for (int idx = 0; idx < sides; idx++) { Xpoints[idx] = cx + sin((float)(idx*rads + deg) * deg_to_rad) * diameter; Ypoints[idx] = cy + cos((float)(idx*rads + deg) * deg_to_rad) * diameter; } // Draw the polygon on the screen. if (f) { for(int idx = 0; idx < sides; idx++) { if((idx+1) < sides) _fillTriangle(cx,cy,Xpoints[idx],Ypoints[idx],Xpoints[idx+1],Ypoints[idx+1], fill); else _fillTriangle(cx,cy,Xpoints[idx],Ypoints[idx],Xpoints[0],Ypoints[0], fill); } } if (th) { for (int n=0; n 0) { for (int idx = 0; idx < sides; idx++) { Xpoints[idx] = cx + sin((float)(idx*rads + deg) * deg_to_rad) * (diameter-n); Ypoints[idx] = cy + cos((float)(idx*rads + deg) * deg_to_rad) * (diameter-n); } } for(int idx = 0; idx < sides; idx++) { if( (idx+1) < sides) _drawLine(Xpoints[idx],Ypoints[idx],Xpoints[idx+1],Ypoints[idx+1], color); // draw the lines else _drawLine(Xpoints[idx],Ypoints[idx],Xpoints[0],Ypoints[0], color); // finishes the last line to close up the polygon. } } } } /* // Similar to the Polygon function. //===================================================================================== void EPD_drawStar(int cx, int cy, int diameter, color_t color, bool fill, float factor) { cx += dispWin.x1; cy += dispWin.y1; factor = constrain(factor, 1.0, 4.0); uint8_t sides = 5; uint8_t rads = 360 / sides; int Xpoints_O[sides], Ypoints_O[sides], Xpoints_I[sides], Ypoints_I[sides];//Xpoints_T[5], Ypoints_T[5]; for(int idx = 0; idx < sides; idx++) { // makes the outer points Xpoints_O[idx] = cx + sin((float)(idx*rads + 72) * deg_to_rad) * diameter; Ypoints_O[idx] = cy + cos((float)(idx*rads + 72) * deg_to_rad) * diameter; // makes the inner points Xpoints_I[idx] = cx + sin((float)(idx*rads + 36) * deg_to_rad) * ((float)(diameter)/factor); // 36 is half of 72, and this will allow the inner and outer points to line up like a triangle. Ypoints_I[idx] = cy + cos((float)(idx*rads + 36) * deg_to_rad) * ((float)(diameter)/factor); } for(int idx = 0; idx < sides; idx++) { if((idx+1) < sides) { if(fill) {// this part below should be self explanatory. It fills in the star. _fillTriangle(cx,cy,Xpoints_I[idx],Ypoints_I[idx],Xpoints_O[idx],Ypoints_O[idx], color); _fillTriangle(cx,cy,Xpoints_O[idx],Ypoints_O[idx],Xpoints_I[idx+1],Ypoints_I[idx+1], color); } else { _drawLine(Xpoints_O[idx],Ypoints_O[idx],Xpoints_I[idx+1],Ypoints_I[idx+1], color); _drawLine(Xpoints_I[idx],Ypoints_I[idx],Xpoints_O[idx],Ypoints_O[idx], color); } } else { if(fill) { _fillTriangle(cx,cy,Xpoints_I[0],Ypoints_I[0],Xpoints_O[idx],Ypoints_O[idx], color); _fillTriangle(cx,cy,Xpoints_O[idx],Ypoints_O[idx],Xpoints_I[idx],Ypoints_I[idx], color); } else { _drawLine(Xpoints_O[idx],Ypoints_O[idx],Xpoints_I[idx],Ypoints_I[idx], color); _drawLine(Xpoints_I[0],Ypoints_I[0],Xpoints_O[idx],Ypoints_O[idx], color); } } } } */ // ================ Font and string functions ================================== //-------------------------------------------------------- static int load_file_font(const char * fontfile, int info) { int err = 0; char err_msg[256] = {'\0'}; if (userfont != NULL) { free(userfont); userfont = NULL; } struct stat sb; // Open the file FILE *fhndl = fopen(fontfile, "r"); if (!fhndl) { sprintf(err_msg, "Error opening font file '%s'", fontfile); err = 1; goto exit; } // Get file size if (stat(fontfile, &sb) != 0) { sprintf(err_msg, "Error getting font file size"); err = 2; goto exit; } int fsize = sb.st_size; if (fsize < 30) { sprintf(err_msg, "Error getting font file size"); err = 3; goto exit; } userfont = malloc(fsize+4); if (userfont == NULL) { sprintf(err_msg, "Font memory allocation error"); fclose(fhndl); err = 4; goto exit; } int read = fread(userfont, 1, fsize, fhndl); fclose(fhndl); if (read != fsize) { sprintf(err_msg, "Font read error"); err = 5; goto exit; } userfont[read] = 0; if (strstr((char *)(userfont+read-8), "RPH_font") == NULL) { sprintf(err_msg, "Font ID not found"); err = 6; goto exit; } // Check size int size = 0; int numchar = 0; int width = userfont[0]; int height = userfont[1]; uint8_t first = 255; uint8_t last = 0; //int offst = 0; int pminwidth = 255; int pmaxwidth = 0; if (width != 0) { // Fixed font numchar = userfont[3]; first = userfont[2]; last = first + numchar - 1; size = ((width * height * numchar) / 8) + 4; } else { // Proportional font size = 4; // point at first char data uint8_t charCode; int charwidth; do { charCode = userfont[size]; charwidth = userfont[size+2]; if (charCode != 0xFF) { numchar++; if (charwidth != 0) size += ((((charwidth * userfont[size+3])-1) / 8) + 7); else size += 6; if (info) { if (charwidth > pmaxwidth) pmaxwidth = charwidth; if (charwidth < pminwidth) pminwidth = charwidth; if (charCode < first) first = charCode; if (charCode > last) last = charCode; } } else size++; } while ((size < (read-8)) && (charCode != 0xFF)); } if (size != (read-8)) { sprintf(err_msg, "Font size error: found %d expected %d)", size, (read-8)); err = 7; goto exit; } if (info) { if (width != 0) { printf("Fixed width font:\r\n size: %d width: %d height: %d characters: %d (%d~%d)", size, width, height, numchar, first, last); } else { printf("Proportional font:\r\n size: %d width: %d~%d height: %d characters: %d (%d~%d)\n", size, pminwidth, pmaxwidth, height, numchar, first, last); } } exit: if (err) { if (userfont) { free(userfont); userfont = NULL; } if (info) printf("Error: %d [%s]\r\n", err, err_msg); } return err; } //------------------------------------------------ int compile_font_file(char *fontfile, uint8_t dbg) { int err = 0; char err_msg[128] = {'\0'}; char outfile[128] = {'\0'}; size_t len; struct stat sb; FILE *ffd = NULL; FILE *ffd_out = NULL; char *sourcebuf = NULL; len = strlen(fontfile); // check here that filename end with ".c". if ((len < 3) || (len > 125) || (strcmp(fontfile + len - 2, ".c") != 0)) { sprintf(err_msg, "not a .c file"); err = 1; goto exit; } sprintf(outfile, "%s", fontfile); sprintf(outfile+strlen(outfile)-1, "fon"); // Open the source file if (stat(fontfile, &sb) != 0) { sprintf(err_msg, "Error opening source file '%s'", fontfile); err = 2; goto exit; } // Open the file ffd = fopen(fontfile, "rb"); if (!ffd) { sprintf(err_msg, "Error opening source file '%s'", fontfile); err = 3; goto exit; } // Open the font file ffd_out= fopen(outfile, "wb"); if (!ffd_out) { sprintf(err_msg, "error opening destination file"); err = 4; goto exit; } // Get file size int fsize = sb.st_size; if (fsize <= 0) { sprintf(err_msg, "source file size error"); err = 5; goto exit; } sourcebuf = malloc(fsize+4); if (sourcebuf == NULL) { sprintf(err_msg, "memory allocation error"); err = 6; goto exit; } char *fbuf = sourcebuf; int rdsize = fread(fbuf, 1, fsize, ffd); fclose(ffd); ffd = NULL; if (rdsize != fsize) { sprintf(err_msg, "error reading from source file"); err = 7; goto exit; } *(fbuf+rdsize) = '\0'; fbuf = strchr(fbuf, '{'); // beginning of font data char *fend = strstr(fbuf, "};"); // end of font data if ((fbuf == NULL) || (fend == NULL) || ((fend-fbuf) < 22)) { sprintf(err_msg, "wrong source file format"); err = 8; goto exit; } fbuf++; *fend = '\0'; char hexstr[5] = {'\0'}; int lastline = 0; fbuf = strstr(fbuf, "0x"); int size = 0; char *nextline; char *numptr; int bptr = 0; while ((fbuf != NULL) && (fbuf < fend) && (lastline == 0)) { nextline = strchr(fbuf, '\n'); // beginning of the next line if (nextline == NULL) { nextline = fend-1; lastline++; } else nextline++; while (fbuf < nextline) { numptr = strstr(fbuf, "0x"); if ((numptr == NULL) || ((fbuf+4) > nextline)) numptr = strstr(fbuf, "0X"); if ((numptr != NULL) && ((numptr+4) <= nextline)) { fbuf = numptr; if (bptr >= 128) { // buffer full, write to file if (fwrite(outfile, 1, 128, ffd_out) != 128) goto error; bptr = 0; size += 128; } memcpy(hexstr, fbuf, 4); hexstr[4] = 0; outfile[bptr++] = (uint8_t)strtol(hexstr, NULL, 0); fbuf += 4; } else fbuf = nextline; } fbuf = nextline; } if (bptr > 0) { size += bptr; if (fwrite(outfile, 1, bptr, ffd_out) != bptr) goto error; } // write font ID sprintf(outfile, "RPH_font"); if (fwrite(outfile, 1, 8, ffd_out) != 8) goto error; // === Test compiled font === sprintf(outfile, "%s", fontfile); sprintf(outfile+strlen(outfile)-1, "fon"); uint8_t *uf = userfont; // save userfont pointer userfont = NULL; if (load_file_font(outfile, 1) == 0) { sprintf(err_msg, "Error compiling file!"); } else { free(userfont); sprintf(err_msg, "File compiled successfully."); } userfont = uf; // restore userfont goto exit; error: sprintf(err_msg, "error writing to destination file"); err = 9; exit: if (sourcebuf) free(sourcebuf); if (ffd) fclose(ffd); if (ffd_out) fclose(ffd_out); if (dbg) printf("%s\r\n", err_msg); return err; } // ----------------------------------------------------------------------------------------- // Individual Proportional Font Character Format: // ----------------------------------------------------------------------------------------- // Character Code // yOffset (start Y of visible pixels) // Width (width of the visible pixels) // Height (height of the visible pixels) // xOffset (start X of visible pixels) // xDelta (the distance to move the cursor. Effective width of the character.) // Data[n] // ----------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------- // Character drawing rectangle is (0, 0) (xDelta-1, cfont.y_size-1) // Character visible pixels rectangle is (xOffset, yOffset) (xOffset+Width-1, yOffset+Height-1) //--------------------------------------------------------------------------------------------- //---------------------------------- void getFontCharacters(uint8_t *buf) { if (cfont.bitmap == 2) { //For 7 segment font only characters 0,1,2,3,4,5,6,7,8,9, . , - , : , / are available. for (uint8_t n=0; n < 11; n++) { buf[n] = n + 0x30; } buf[11] = '.'; buf[12] = '-'; buf[13] = '/'; buf[14] = '\0'; return; } if (cfont.x_size > 0) { for (uint8_t n=0; n < cfont.numchars; n++) { buf[n] = cfont.offset + n; } buf[cfont.numchars] = '\0'; return; } uint16_t tempPtr = 4; // point at first char data uint8_t cc, cw, ch, n; n = 0; cc = cfont.font[tempPtr++]; while (cc != 0xFF) { cfont.numchars++; tempPtr++; cw = cfont.font[tempPtr++]; ch = cfont.font[tempPtr++]; tempPtr++; tempPtr++; if (cw != 0) { // packed bits tempPtr += (((cw * ch)-1) / 8) + 1; } buf[n++] = cc; cc = cfont.font[tempPtr++]; } buf[n] = '\0'; } // Set max width & height of the proportional font //----------------------------- static void getMaxWidthHeight() { uint16_t tempPtr = 4; // point at first char data uint8_t cc, cw, ch, cd, cy; cfont.numchars = 0; cfont.max_x_size = 0; cc = cfont.font[tempPtr++]; while (cc != 0xFF) { cfont.numchars++; cy = cfont.font[tempPtr++]; cw = cfont.font[tempPtr++]; ch = cfont.font[tempPtr++]; tempPtr++; cd = cfont.font[tempPtr++]; cy += ch; if (cw > cfont.max_x_size) cfont.max_x_size = cw; if (cd > cfont.max_x_size) cfont.max_x_size = cd; if (ch > cfont.y_size) cfont.y_size = ch; if (cy > cfont.y_size) cfont.y_size = cy; if (cw != 0) { // packed bits tempPtr += (((cw * ch)-1) / 8) + 1; } cc = cfont.font[tempPtr++]; } cfont.size = tempPtr; } // Return the Glyph data for an individual character in the proportional font //------------------------------------ static uint8_t getCharPtr(uint8_t c) { uint16_t tempPtr = 4; // point at first char data do { fontChar.charCode = cfont.font[tempPtr++]; if (fontChar.charCode == 0xFF) return 0; fontChar.adjYOffset = cfont.font[tempPtr++]; fontChar.width = cfont.font[tempPtr++]; fontChar.height = cfont.font[tempPtr++]; fontChar.xOffset = cfont.font[tempPtr++]; fontChar.xOffset = fontChar.xOffset < 0x80 ? fontChar.xOffset : -(0xFF - fontChar.xOffset); fontChar.xDelta = cfont.font[tempPtr++]; if (c != fontChar.charCode && fontChar.charCode != 0xFF) { if (fontChar.width != 0) { // packed bits tempPtr += (((fontChar.width * fontChar.height)-1) / 8) + 1; } } } while ((c != fontChar.charCode) && (fontChar.charCode != 0xFF)); fontChar.dataPtr = tempPtr; if (c == fontChar.charCode) { if (font_forceFixed > 0) { // fix width & offset for forced fixed width fontChar.xDelta = cfont.max_x_size; fontChar.xOffset = (fontChar.xDelta - fontChar.width) / 2; } } else return 0; return 1; } /* //----------------------- static void _testFont() { if (cfont.x_size) { printf("FONT TEST: fixed font\r\n"); return; } uint16_t tempPtr = 4; // point at first char data uint8_t c = 0x20; for (c=0x20; c <0xFF; c++) { fontChar.charCode = cfont.font[tempPtr++]; if (fontChar.charCode == 0xFF) break; if (fontChar.charCode != c) { printf("FONT TEST: last sequential char: %d, expected %d\r\n", fontChar.charCode, c); break; } c = fontChar.charCode; fontChar.adjYOffset = cfont.font[tempPtr++]; fontChar.width = cfont.font[tempPtr++]; fontChar.height = cfont.font[tempPtr++]; fontChar.xOffset = cfont.font[tempPtr++]; fontChar.xOffset = fontChar.xOffset < 0x80 ? fontChar.xOffset : -(0xFF - fontChar.xOffset); fontChar.xDelta = cfont.font[tempPtr++]; if (fontChar.charCode != 0xFF) { if (fontChar.width != 0) { // packed bits tempPtr += (((fontChar.width * fontChar.height)-1) / 8) + 1; } } } printf("FONT TEST: W=%d H=%d last char: %d [%c]; length: %d\r\n", cfont.max_x_size, cfont.y_size, c, c, tempPtr); } */ //=================================================== void EPD_setFont(uint8_t font, const char *font_file) { cfont.font = NULL; if (font == FONT_7SEG) { cfont.bitmap = 2; cfont.x_size = 24; cfont.y_size = 6; cfont.offset = 0; cfont.color = _fg; } else { if (font == USER_FONT) { if (load_file_font(font_file, 0) != 0) cfont.font = tft_DefaultFont; else cfont.font = userfont; } else if (font == DEJAVU18_FONT) cfont.font = tft_Dejavu18; else if (font == DEJAVU24_FONT) cfont.font = tft_Dejavu24; else if (font == UBUNTU16_FONT) cfont.font = tft_Ubuntu16; else if (font == COMIC24_FONT) cfont.font = tft_Comic24; else if (font == MINYA24_FONT) cfont.font = tft_minya24; else if (font == TOONEY32_FONT) cfont.font = tft_tooney32; else if (font == SMALL_FONT) cfont.font = tft_SmallFont; else cfont.font = tft_DefaultFont; cfont.bitmap = 1; cfont.x_size = cfont.font[0]; cfont.y_size = cfont.font[1]; if (cfont.x_size > 0) { cfont.offset = cfont.font[2]; cfont.numchars = cfont.font[3]; cfont.size = cfont.x_size * cfont.y_size * cfont.numchars; } else { cfont.offset = 4; getMaxWidthHeight(); } //_testFont(); } } // ----------------------------------------------------------------------------------------- // Individual Proportional Font Character Format: // ----------------------------------------------------------------------------------------- // Character Code // yOffset (start Y of visible pixels) // Width (width of the visible pixels) // Height (height of the visible pixels) // xOffset (start X of visible pixels) // xDelta (the distance to move the cursor. Effective width of the character.) // Data[n] // ----------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------- // Character drawing rectangle is (0, 0) (xDelta-1, cfont.y_size-1) // Character visible pixels rectangle is (xOffset, yOffset) (xOffset+Width-1, yOffset+Height-1) //--------------------------------------------------------------------------------------------- // print non-rotated proportional character // character is already in fontChar //---------------------------------------------- static int printProportionalChar(int x, int y) { uint8_t ch = 0; int i, j, char_width; char_width = ((fontChar.width > fontChar.xDelta) ? fontChar.width : fontChar.xDelta); int cx, cy; if (!font_transparent) _fillRect(x, y, char_width+1, cfont.y_size, _bg); // draw Glyph uint8_t mask = 0x80; for (j=0; j < fontChar.height; j++) { for (i=0; i < fontChar.width; i++) { if (((i + (j*fontChar.width)) % 8) == 0) { mask = 0x80; ch = cfont.font[fontChar.dataPtr++]; } if ((ch & mask) !=0) { cx = (uint16_t)(x+fontChar.xOffset+i); cy = (uint16_t)(y+j+fontChar.adjYOffset); _drawPixel(cx, cy, _fg); } mask >>= 1; } } return char_width; } // non-rotated fixed width character //---------------------------------------------- static void printChar(uint8_t c, int x, int y) { uint8_t i, j, ch, fz, mask; uint16_t k, temp, cx, cy; // fz = bytes per char row fz = cfont.x_size/8; if (cfont.x_size % 8) fz++; // get character position in buffer temp = ((c-cfont.offset)*((fz)*cfont.y_size))+4; if (!font_transparent) _fillRect(x, y, cfont.x_size, cfont.y_size, _bg); for (j=0; j>= 1; } } temp += (fz); } } // print rotated proportional character // character is already in fontChar //--------------------------------------------------- static int rotatePropChar(int x, int y, int offset) { uint8_t ch = 0; double radian = font_rotate * DEG_TO_RAD; float cos_radian = cos(radian); float sin_radian = sin(radian); uint8_t mask = 0x80; for (int j=0; j < fontChar.height; j++) { for (int i=0; i < fontChar.width; i++) { if (((i + (j*fontChar.width)) % 8) == 0) { mask = 0x80; ch = cfont.font[fontChar.dataPtr++]; } int newX = (int)(x + (((offset + i) * cos_radian) - ((j+fontChar.adjYOffset)*sin_radian))); int newY = (int)(y + (((j+fontChar.adjYOffset) * cos_radian) + ((offset + i) * sin_radian))); if ((ch & mask) != 0) _drawPixel(newX,newY,_fg); else if (!font_transparent) _drawPixel(newX,newY,_bg); mask >>= 1; } } return fontChar.xDelta+1; } // rotated fixed width character //-------------------------------------------------------- static void rotateChar(uint8_t c, int x, int y, int pos) { uint8_t i,j,ch,fz,mask; uint16_t temp; int newx,newy; double radian = font_rotate*0.0175; float cos_radian = cos(radian); float sin_radian = sin(radian); int zz; if( cfont.x_size < 8 ) fz = cfont.x_size; else fz = cfont.x_size/8; temp=((c-cfont.offset)*((fz)*cfont.y_size))+4; for (j=0; j>= 1; } } temp+=(fz); } // calculate x,y for the next char EPD_X = (int)(x + ((pos+1) * cfont.x_size * cos_radian)); EPD_Y = (int)(y + ((pos+1) * cfont.x_size * sin_radian)); } //---------------------- static int _7seg_width() { return (2 * (2 * cfont.y_size + 1)) + cfont.x_size; } //----------------------- static int _7seg_height() { return (3 * (2 * cfont.y_size + 1)) + (2 * cfont.x_size); } // Returns the string width in pixels. // Useful for positions strings on the screen. //=============================== int EPD_getStringWidth(char* str) { int strWidth = 0; if (cfont.bitmap == 2) strWidth = ((_7seg_width()+2) * strlen(str)) - 2; // 7-segment font else if (cfont.x_size != 0) strWidth = strlen(str) * cfont.x_size; // fixed width font else { // calculate the width of the string of proportional characters char* tempStrptr = str; while (*tempStrptr != 0) { if (getCharPtr(*tempStrptr++)) { strWidth += (((fontChar.width > fontChar.xDelta) ? fontChar.width : fontChar.xDelta) + 1); } } strWidth--; } return strWidth; } //=============================================== void EPD_clearStringRect(int x, int y, char *str) { int w = EPD_getStringWidth(str); int h = EPD_getfontheight(); EPD_fillRect(x+dispWin.x1, y+dispWin.y1, w, h, _bg); } //============================================================================== /** * bit-encoded bar position of all digits' bcd segments * * 6 * +-----+ * 3 | . | 2 * +--5--+ * 1 | . | 0 * +--.--+ * 4 */ static const uint16_t font_bcd[] = { 0x200, // 0010 0000 0000 // - 0x080, // 0000 1000 0000 // . 0x06C, // 0100 0110 1100 // /, degree 0x05f, // 0000 0101 1111, // 0 0x005, // 0000 0000 0101, // 1 0x076, // 0000 0111 0110, // 2 0x075, // 0000 0111 0101, // 3 0x02d, // 0000 0010 1101, // 4 0x079, // 0000 0111 1001, // 5 0x07b, // 0000 0111 1011, // 6 0x045, // 0000 0100 0101, // 7 0x07f, // 0000 0111 1111, // 8 0x07d, // 0000 0111 1101 // 9 0x900 // 1001 0000 0000 // : }; //----------------------------------------------------------------------------------------------- static void barVert(int16_t x, int16_t y, int16_t w, int16_t l, color_t color, color_t outline) { _fillTriangle(x+1, y+2*w, x+w, y+w+1, x+2*w-1, y+2*w, color); _fillTriangle(x+1, y+2*w+l+1, x+w, y+3*w+l, x+2*w-1, y+2*w+l+1, color); _fillRect(x, y+2*w+1, 2*w+1, l, color); if (cfont.offset) { _drawTriangle(x+1, y+2*w, x+w, y+w+1, x+2*w-1, y+2*w, outline); _drawTriangle(x+1, y+2*w+l+1, x+w, y+3*w+l, x+2*w-1, y+2*w+l+1, outline); _drawRect(x, y+2*w+1, 2*w+1, l, outline); } } //---------------------------------------------------------------------------------------------- static void barHor(int16_t x, int16_t y, int16_t w, int16_t l, color_t color, color_t outline) { _fillTriangle(x+2*w, y+2*w-1, x+w+1, y+w, x+2*w, y+1, color); _fillTriangle(x+2*w+l+1, y+2*w-1, x+3*w+l, y+w, x+2*w+l+1, y+1, color); _fillRect(x+2*w+1, y, l, 2*w+1, color); if (cfont.offset) { _drawTriangle(x+2*w, y+2*w-1, x+w+1, y+w, x+2*w, y+1, outline); _drawTriangle(x+2*w+l+1, y+2*w-1, x+3*w+l, y+w, x+2*w+l+1, y+1, outline); _drawRect(x+2*w+1, y, l, 2*w+1, outline); } } //-------------------------------------------------------------------------------------------- static void _draw7seg(int16_t x, int16_t y, int8_t num, int16_t w, int16_t l, color_t color) { /* TODO: clipping */ if (num < 0x2D || num > 0x3A) return; int16_t c = font_bcd[num-0x2D]; int16_t d = 2*w+l+1; // === Clear unused segments === /* if (!(c & 0x001)) barVert(x+d, y+d, w, l, _bg, _bg); if (!(c & 0x002)) barVert(x, y+d, w, l, _bg, _bg); if (!(c & 0x004)) barVert(x+d, y, w, l, _bg, _bg); if (!(c & 0x008)) barVert(x, y, w, l, _bg, _bg); if (!(c & 0x010)) barHor(x, y+2*d, w, l, _bg, _bg); if (!(c & 0x020)) barHor(x, y+d, w, l, _bg, _bg); if (!(c & 0x040)) barHor(x, y, w, l, _bg, _bg); if (!(c & 0x080)) { // low point _fillRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, _bg); if (cfont.offset) _drawRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, _bg); } if (!(c & 0x100)) { // down middle point _fillRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, _bg); if (cfont.offset) _drawRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, _bg); } if (!(c & 0x800)) { // up middle point _fillRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, _bg); if (cfont.offset) _drawRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, _bg); } if (!(c & 0x200)) { // middle, minus _fillRect(x+2*w+1, y+d, l, 2*w+1, _bg); if (cfont.offset) _drawRect(x+2*w+1, y+d, l, 2*w+1, _bg); } */ barVert(x+d, y+d, w, l, _bg, _bg); barVert(x, y+d, w, l, _bg, _bg); barVert(x+d, y, w, l, _bg, _bg); barVert(x, y, w, l, _bg, _bg); barHor(x, y+2*d, w, l, _bg, _bg); barHor(x, y+d, w, l, _bg, _bg); barHor(x, y, w, l, _bg, _bg); _fillRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, _bg); _drawRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, _bg); _fillRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, _bg); _drawRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, _bg); _fillRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, _bg); _drawRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, _bg); _fillRect(x+2*w+1, y+d, l, 2*w+1, _bg); _drawRect(x+2*w+1, y+d, l, 2*w+1, _bg); // === Draw used segments === if (c & 0x001) barVert(x+d, y+d, w, l, color, cfont.color); // down right if (c & 0x002) barVert(x, y+d, w, l, color, cfont.color); // down left if (c & 0x004) barVert(x+d, y, w, l, color, cfont.color); // up right if (c & 0x008) barVert(x, y, w, l, color, cfont.color); // up left if (c & 0x010) barHor(x, y+2*d, w, l, color, cfont.color); // down if (c & 0x020) barHor(x, y+d, w, l, color, cfont.color); // middle if (c & 0x040) barHor(x, y, w, l, color, cfont.color); // up if (c & 0x080) { // low point _fillRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, color); if (cfont.offset) _drawRect(x+(d/2), y+2*d, 2*w+1, 2*w+1, cfont.color); } if (c & 0x100) { // down middle point _fillRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, color); if (cfont.offset) _drawRect(x+(d/2), y+d+2*w+1, 2*w+1, l/2, cfont.color); } if (c & 0x800) { // up middle point _fillRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, color); if (cfont.offset) _drawRect(x+(d/2), y+(2*w)+1+(l/2), 2*w+1, l/2, cfont.color); } if (c & 0x200) { // middle, minus _fillRect(x+2*w+1, y+d, l, 2*w+1, color); if (cfont.offset) _drawRect(x+2*w+1, y+d, l, 2*w+1, cfont.color); } } //============================================================================== //====================================== void EPD_print(char *st, int x, int y) { int stl, i, tmpw, tmph, fh; uint8_t ch; if (cfont.bitmap == 0) return; // wrong font selected // ** Rotated strings cannot be aligned if ((font_rotate != 0) && ((x <= CENTER) || (y <= CENTER))) return; if ((x < LASTX) || (font_rotate == 0)) EPD_OFFSET = 0; if ((x >= LASTX) && (x < LASTY)) x = EPD_X + (x-LASTX); else if (x > CENTER) x += dispWin.x1; if (y >= LASTY) y = EPD_Y + (y-LASTY); else if (y > CENTER) y += dispWin.y1; // ** Get number of characters in string to print stl = strlen(st); // ** Calculate CENTER, RIGHT or BOTTOM position tmpw = EPD_getStringWidth(st); // string width in pixels fh = cfont.y_size; // font height if ((cfont.x_size != 0) && (cfont.bitmap == 2)) { // 7-segment font fh = (3 * (2 * cfont.y_size + 1)) + (2 * cfont.x_size); // 7-seg character height } if (x == RIGHT) x = dispWin.x2 - tmpw + dispWin.x1; else if (x == CENTER) x = (((dispWin.x2 - dispWin.x1 + 1) - tmpw) / 2) + dispWin.x1; if (y == BOTTOM) y = dispWin.y2 - fh + dispWin.y1; else if (y==CENTER) y = (((dispWin.y2 - dispWin.y1 + 1) - (fh/2)) / 2) + dispWin.y1; if (x < dispWin.x1) x = dispWin.x1; if (y < dispWin.y1) y = dispWin.y1; if ((x > dispWin.x2) || (y > dispWin.y2)) return; EPD_X = x; EPD_Y = y; // ** Adjust y position tmph = cfont.y_size; // font height // for non-proportional fonts, char width is the same for all chars tmpw = cfont.x_size; if (cfont.x_size != 0) { if (cfont.bitmap == 2) { // 7-segment font tmpw = _7seg_width(); // character width tmph = _7seg_height(); // character height } } else EPD_OFFSET = 0; // fixed font; offset not needed if (( EPD_Y + tmph - 1) > dispWin.y2) return; int offset = EPD_OFFSET; for (i=0; i (dispWin.y2-tmph)) break; EPD_X = dispWin.x1; } } else { // ==== other characters ==== if (cfont.x_size == 0) { // for proportional font get character data to 'fontChar' if (getCharPtr(ch)) tmpw = fontChar.xDelta; else continue; } // check if character can be displayed in the current line if (( EPD_X+tmpw) > (dispWin.x2)) { if (text_wrap == 0) break; EPD_Y += tmph + font_line_space; if ( EPD_Y > (dispWin.y2-tmph)) break; EPD_X = dispWin.x1; } // Let's print the character if (cfont.x_size == 0) { // == proportional font if (font_rotate == 0) EPD_X += printProportionalChar( EPD_X, EPD_Y) + 1; else { // rotated proportional font offset += rotatePropChar(x, y, offset); EPD_OFFSET = offset; } } else { if (cfont.bitmap == 1) { // == fixed font if ((ch < cfont.offset) || ((ch-cfont.offset) > cfont.numchars)) ch = cfont.offset; if (font_rotate == 0) { printChar(ch, EPD_X, EPD_Y); EPD_X += tmpw; } else rotateChar(ch, x, y, i); } else if (cfont.bitmap == 2) { // == 7-segment font == _draw7seg( EPD_X, EPD_Y, ch, cfont.y_size, cfont.x_size, _fg); EPD_X += (tmpw + 2); } } } } } // ================ Service functions ========================================== //===================================================================== void EPD_setclipwin(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) { dispWin.x1 = x1; dispWin.y1 = y1; dispWin.x2 = x2; dispWin.y2 = y2; if (dispWin.x2 >= EPD_DISPLAY_WIDTH) dispWin.x2 = EPD_DISPLAY_WIDTH-1; if (dispWin.y2 >= EPD_DISPLAY_HEIGHT) dispWin.y2 = EPD_DISPLAY_HEIGHT-1; if (dispWin.x1 > dispWin.x2) dispWin.x1 = dispWin.x2; if (dispWin.y1 > dispWin.y2) dispWin.y1 = dispWin.y2; } //===================== void EPD_resetclipwin() { dispWin.x2 = EPD_DISPLAY_WIDTH-1; dispWin.y2 = EPD_DISPLAY_HEIGHT-1; dispWin.x1 = 0; dispWin.y1 = 0; } //========================================================================== void set_7seg_font_atrib(uint8_t l, uint8_t w, int outline, color_t color) { if (cfont.bitmap != 2) return; if (l < 6) l = 6; if (l > 40) l = 40; if (w < 1) w = 1; if (w > (l/2)) w = l/2; if (w > 12) w = 12; cfont.x_size = l; cfont.y_size = w; cfont.offset = outline; cfont.color = color; } //========================================== int EPD_getfontsize(int *width, int* height) { if (cfont.bitmap == 1) { if (cfont.x_size != 0) *width = cfont.x_size; // fixed width font else *width = cfont.max_x_size; // proportional font *height = cfont.y_size; } else if (cfont.bitmap == 2) { // 7-segment font *width = _7seg_width(); *height = _7seg_height(); } else { *width = 0; *height = 0; return 0; } return 1; } //===================== int EPD_getfontheight() { if (cfont.bitmap == 1) return cfont.y_size; // Bitmap font else if (cfont.bitmap == 2) return _7seg_height(); // 7-segment font return 0; } //==================== void EPD_saveClipWin() { dispWinTemp.x1 = dispWin.x1; dispWinTemp.y1 = dispWin.y1; dispWinTemp.x2 = dispWin.x2; dispWinTemp.y2 = dispWin.y2; } //======================= void EPD_restoreClipWin() { dispWin.x1 = dispWinTemp.x1; dispWin.y1 = dispWinTemp.y1; dispWin.x2 = dispWinTemp.x2; dispWin.y2 = dispWinTemp.y2; } // ================ JPG SUPPORT ================================================ // RGB to GRAYSCALE constants // 0.2989 0.5870 0.1140 #define GS_FACT_R 0.2989 #define GS_FACT_G 0.4870 #define GS_FACT_B 0.2140 // User defined device identifier typedef struct { FILE *fhndl; // File handler for input function int x; // image top left point X position int y; // image top left point Y position uint8_t *membuff; // memory buffer containing the image uint32_t bufsize; // size of the memory buffer uint32_t bufptr; // memory buffer current position } JPGIODEV; // User defined call-back function to input JPEG data from file //--------------------- static UINT tjd_input ( JDEC* jd, // Decompression object BYTE* buff, // Pointer to the read buffer (NULL:skip) UINT nd // Number of bytes to read/skip from input stream ) { int rb = 0; // Device identifier for the session (5th argument of jd_prepare function) JPGIODEV *dev = (JPGIODEV*)jd->device; if (buff) { // Read nd bytes from the input strem rb = fread(buff, 1, nd, dev->fhndl); return rb; // Returns actual number of bytes read } else { // Remove nd bytes from the input stream if (fseek(dev->fhndl, nd, SEEK_CUR) >= 0) return nd; else return 0; } } // User defined call-back function to input JPEG data from memory buffer //------------------------- static UINT tjd_buf_input ( JDEC* jd, // Decompression object BYTE* buff, // Pointer to the read buffer (NULL:skip) UINT nd // Number of bytes to read/skip from input stream ) { // Device identifier for the session (5th argument of jd_prepare function) JPGIODEV *dev = (JPGIODEV*)jd->device; if (!dev->membuff) return 0; if (dev->bufptr >= (dev->bufsize + 2)) return 0; // end of stream if ((dev->bufptr + nd) > (dev->bufsize + 2)) nd = (dev->bufsize + 2) - dev->bufptr; if (buff) { // Read nd bytes from the input strem memcpy(buff, dev->membuff + dev->bufptr, nd); dev->bufptr += nd; return nd; // Returns number of bytes read } else { // Remove nd bytes from the input stream dev->bufptr += nd; return nd; } } // User defined call-back function to output RGB bitmap to display device //---------------------- static UINT tjd_output ( JDEC* jd, // Decompression object of current session void* bitmap, // Bitmap data to be output JRECT* rect // Rectangular region to output ) { // Device identifier for the session (5th argument of jd_prepare function) JPGIODEV *dev = (JPGIODEV*)jd->device; // ** Put the rectangular into the display device ** int x; int y; int dleft, dtop, dright, dbottom; BYTE *src = (BYTE*)bitmap; int left = rect->left + dev->x; int top = rect->top + dev->y; int right = rect->right + dev->x; int bottom = rect->bottom + dev->y; if ((left > dispWin.x2) || (top > dispWin.y2)) return 1; // out of screen area, return if ((right < dispWin.x1) || (bottom < dispWin.y1)) return 1;// out of screen area, return if (left < dispWin.x1) dleft = dispWin.x1; else dleft = left; if (top < dispWin.y1) dtop = dispWin.y1; else dtop = top; if (right > dispWin.x2) dright = dispWin.x2; else dright = right; if (bottom > dispWin.y2) dbottom = dispWin.y2; else dbottom = bottom; if ((dleft > dispWin.x2) || (dtop > dispWin.y2)) return 1; // out of screen area, return if ((dright < dispWin.x1) || (dbottom < dispWin.y1)) return 1; // out of screen area, return uint32_t len = ((dright-dleft+1) * (dbottom-dtop+1)); // calculate length of data float gs_clr = 0; uint8_t rgb_color[3]; uint8_t last_lvl, i; uint8_t pix; if ((len > 0) && (len <= JPG_IMAGE_LINE_BUF_SIZE)) { for (y = top; y <= bottom; y++) { for (x = left; x <= right; x++) { // Clip to display area if ((x >= dleft) && (y >= dtop) && (x <= dright) && (y <= dbottom)) { // Directly convert color to 4-bit gray scale pix = 0; pix |= ((*src++) >> 4) & 0x08; pix |= ((*src++) >> 5) & 0x06; pix |= ((*src++) >> 7); pix ^= 0x0F; /* Convert rgb color to gray scale memcpy(rgb_color, src, 3); src += 3; gs_clr = (GS_FACT_R * rgb_color[0]) + (GS_FACT_G * rgb_color[1]) + (GS_FACT_B * rgb_color[2]); if (gs_clr > 255) gs_clr = 255; // Use only 4 bits & invert //pix = ((uint8_t)gs_clr >> 4) ^ 0x0F; pix = (uint8_t)gs_clr; // Using gray scale lookup table last_lvl = 0; i = 0; for (i=0; i<16; i++) { if ((pix > last_lvl) && (pix <= lvl_buf_jpg[i])) { pix = 15 - i; last_lvl = lvl_buf[i]; break; } last_lvl = lvl_buf[i]; } */ gs_disp_buffer[(y * EPD_DISPLAY_WIDTH) + x] = pix; gs_used_shades |= (1 << pix); } else src += 3; // skip } } } else { printf("Data size error: %d jpg: (%d,%d,%d,%d) disp: (%d,%d,%d,%d)\r\n", len, left,top,right,bottom, dleft,dtop,dright,dbottom); return 0; // stop decompression } return 1; // Continue to decompression } // X & Y can be < 0 ! //================================================================================= int EPD_jpg_image(int x, int y, uint8_t scale, char *fname, uint8_t *buf, int size) { JPGIODEV dev; struct stat sb; char *work = NULL; // Pointer to the working buffer (must be 4-byte aligned) UINT sz_work = 3800; // Size of the working buffer (must be power of 2) JDEC jd; // Decompression object (70 bytes) JRESULT rc; int res = -10; if (fname == NULL) { // image from buffer dev.fhndl = NULL; dev.membuff = buf; dev.bufsize = size; dev.bufptr = 0; } else { // image from file dev.membuff = NULL; dev.bufsize = 0; dev.bufptr = 0; if (stat(fname, &sb) != 0) { if (image_debug) printf("File error: %ss\r\n", strerror(errno)); res = -11; goto exit; } dev.fhndl = fopen(fname, "r"); if (!dev.fhndl) { if (image_debug) printf("Error opening file: %s\r\n", strerror(errno)); res = -12; goto exit; } } if (scale > 3) scale = 3; work = malloc(sz_work); if (work) { if (dev.membuff) rc = jd_prepare(&jd, tjd_buf_input, (void *)work, sz_work, &dev); else rc = jd_prepare(&jd, tjd_input, (void *)work, sz_work, &dev); if (rc == JDR_OK) { if (x == CENTER) x = ((dispWin.x2 - dispWin.x1 + 1 - (int)(jd.width >> scale)) / 2) + dispWin.x1; else if (x == RIGHT) x = dispWin.x2 + 1 - (int)(jd.width >> scale); if (y == CENTER) y = ((dispWin.y2 - dispWin.y1 + 1 - (int)(jd.height >> scale)) / 2) + dispWin.y1; else if (y == BOTTOM) y = dispWin.y2 + 1 - (int)(jd.height >> scale); if (x < ((dispWin.x2-1) * -1)) x = (dispWin.x2-1) * -1; if (y < ((dispWin.y2-1)) * -1) y = (dispWin.y2-1) * -1; if (x > (dispWin.x2-1)) x = dispWin.x2 - 1; if (y > (dispWin.y2-1)) y = dispWin.y2-1; dev.x = x; dev.y = y; // Start to decode the JPEG file rc = jd_decomp(&jd, tjd_output, scale); if (rc != JDR_OK) { if (image_debug) printf("jpg decompression error %d\r\n", rc); res = rc * -1; } res = 0; if (image_debug) printf("Jpg size: %dx%d, position; %d,%d, scale: %d, bytes used: %d\r\n", jd.width, jd.height, x, y, scale, jd.sz_pool); } else { if (image_debug) printf("jpg prepare error %d\r\n", rc); res = rc * -1; } } else { if (image_debug) printf("work buffer allocation error\r\n"); res = -13; } exit: if (work) free(work); // free work buffer if (dev.fhndl) fclose(dev.fhndl); // close input file return res; }