Mercurial > public > ostc4

comparison Discovery/Src/gfx_engine.c @ 38:5f11787b4f42

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
include in ostc4 repository
author heinrichsweikamp
date Sat, 28 Apr 2018 11:52:34 +0200
parents
children e97deb6e2705
comparison
equal deleted inserted replaced
37:ccc45c0e1ea2 38:5f11787b4f42
1 /**
2 ******************************************************************************
3 * @file gfx_engine.c
4 * @author heinrichs weikamp gmbh
5 * @version V0.0.2
6 * @date 30-April-2014
7 * @brief Main source file of GFX Graphic Engine
8 * This file provides firmware functions to manage the following
9 * functions to draw on the screen:
10 * + write string to display
11 *
12 ******************************************************************************
13 * @attention
14 *
15 * <h2><center>&copy; COPYRIGHT(c) 2014 heinrichs weikamp</center></h2>
16 *
17 ******************************************************************************
18 */
19
20 /* Includes ------------------------------------------------------------------*/
21
22 #include <stdlib.h>
23 #include <stdint.h>
24
25 #include "stm32f4xx_hal.h"
26
27 #include "gfx.h"
28 #include "gfx_engine.h"
29 #include "gfx_fonts.h"
30 #include "gfx_colors.h"
31 #include "ostc.h"
32 #include "settings.h"
33 #include "text_multilanguage.h"
34
35 /* Exported variables --------------------------------------------------------*/
36
37 /* Private types -------------------------------------------------------------*/
38
39 typedef struct
40 {
41 uint32_t Xdelta;
42 uint32_t Ydelta;
43 uint8_t invert;
44 uint8_t color;
45 uint8_t dualFont;
46 uint8_t resize;
47 uint32_t font;
48 uint8_t spaceMode;
49 uint8_t singleSpaceWithSizeOfNextChar;
50 uint8_t useTinyFont;
51 uint32_t TinyFont;
52 int8_t TinyFontExtraYdelta;
53 tFont *actualFont;
54 uint8_t doubleSize;
55 } GFX_CfgWriteString;
56
57 typedef struct
58 {
59 uint32_t pBuffer;
60 uint32_t height;
61 uint32_t width;
62 uint32_t leftStart;
63 uint32_t bottomStart;
64 } GFX_layerSingle;
65 /*
66 typedef struct
67 {
68 GFX_layerSingle top;
69 GFX_layerSingle bottom;
70 } GFX_layersTopBottom;
71 */
72 typedef struct
73 {
74 uint32_t pActualTopBuffer;
75 uint32_t pNextTopBuffer[2];
76 GFX_layerSingle actualBottom;
77 GFX_layerSingle nextBottom[2];
78 uint8_t boolNextTop;
79 uint8_t boolNextBottom;
80 } GFX_layerControl;
81
82 typedef struct
83 {
84 uint32_t StartAddress;
85 int8_t status;
86 uint8_t caller;
87 } SFrameList;
88
89 enum FRAMESTATE
90 {
91 CLEAR = 0,
92 BLOCKED,
93 RELEASED
94 };
95
96 enum LOGOSTATE
97 {
98 LOGOOFF = 0,
99 LOGOSTART = 1,
100 LOGOSTOP = 255
101 };
102
103 // should be 43
104 #define MAXFRAMES 39
105
106 #define SDRAM_BANK_ADDR ((uint32_t)0xD0000000)
107 #define FBGlobalStart SDRAM_BANK_ADDR
108 #define FBOffsetEachIndex (800*480*2)
109
110 #define SDRAM_DOUBLE_BUFFER_ONE ((uint32_t)(FBGlobalStart + (MAXFRAMES * FBOffsetEachIndex)))
111 #define SDRAM_DOUBLE_BUFFER_TWO ((uint32_t)(SDRAM_DOUBLE_BUFFER_ONE + (2 * FBOffsetEachIndex)))
112 #define SDRAM_DOUBLE_BUFFER_END ((uint32_t)(SDRAM_DOUBLE_BUFFER_TWO + (2 * FBOffsetEachIndex)))
113
114 /* Semi Private variables ---------------------------------------------------------*/
115
116 DMA2D_HandleTypeDef Dma2dHandle;
117 LTDC_HandleTypeDef LtdcHandle;
118
119 /* Private variables ---------------------------------------------------------*/
120
121 uint8_t DMA2D_at_work = 0;
122
123 GFX_layerControl FrameHandler = { 0 };
124
125 uint32_t pInvisibleFrame = 0;
126 uint32_t pLogoFrame = 0;
127 uint8_t logoStatus;
128 uint32_t pBackgroundHwFrame = 0;
129 uint8_t backgroundHwStatus;
130
131 SFrameList frame[MAXFRAMES];
132
133 #define MAXFRAMECOUNTER (28)
134 uint8_t frameCounter[MAXFRAMECOUNTER] = { 0 };
135
136 _Bool lock_changeLTDC = 0;
137
138 /* ITM Trace-----------------------------------------------------------------*/
139
140 #include "stdio.h"
141
142 #define ITM_Port8(n) (*((volatile unsigned char *)(0xE0000000+4*n)))
143 #define ITM_Port16(n) (*((volatile unsigned short*)(0xE0000000+4*n)))
144 #define ITM_Port32(n) (*((volatile unsigned long *)(0xE0000000+4*n)))
145
146 #define DEMCR (*((volatile unsigned long *)(0xE000EDFC)))
147 #define TRCENA 0x01000000
148
149 struct __FILE { int handle; /* Add whatever needed */ };
150 FILE __stdout;
151 FILE __stdin;
152
153 int fputc(int ch, FILE *f) {
154 if (DEMCR & TRCENA) {
155 while (ITM_Port32(0) == 0);
156 ITM_Port8(0) = ch;
157 }
158 return(ch);
159 }
160
161 uint32_t MinU32GFX(uint32_t a, uint32_t b)
162 {
163 return ((a<b)?a:b);
164 }
165
166
167 uint32_t MaxU32GFX(uint32_t a, uint32_t b)
168 {
169 return((a>b)?a:b);
170 }
171
172 /* Private function prototypes -----------------------------------------------*/
173
174 static uint32_t GFX_write_char(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font);
175 static uint32_t GFX_write_substring(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, uint8_t textId, int8_t nextCharFor2Byte);
176 uint32_t GFX_write__Modify_Xdelta__Centered(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pText);
177 uint32_t GFX_write__Modify_Xdelta__RightAlign(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput);
178 static void GFX_Error_Handler(void);
179 static void GFX_Dma2d_TransferComplete(DMA2D_HandleTypeDef* Dma2dHandle);
180 static void GFX_Dma2d_TransferError(DMA2D_HandleTypeDef* Dma2dHandle);
181 void GFX_clear_frame_dma2d(uint8_t frameId);
182
183 uint32_t GFX_doubleBufferOne(void);
184 uint32_t GFX_doubleBufferTwo(void);
185
186
187 /* Exported functions --------------------------------------------------------*/
188
189 uint8_t GFX_logoStatus(void)
190 {
191 return logoStatus;
192 }
193
194
195 void GFX_helper_font_memory_list(const tFont *Font)
196 {
197 int i;
198 uint8_t character;
199
200 // -----------------------------
201
202 for(character = 0x20; character < 0xFF; character++)
203 {
204 for(i=0;i<Font->length;i++)
205 {
206 if(Font->chars[i].code == character)
207 {
208 printf("%02x: 0x%0lx 0x%0lx\n\r",(uint8_t)character, (uint32_t)(Font->chars[i].image->data),((uint32_t)(Font->chars[i+1].image->data)-(uint32_t)(Font->chars[i].image->data)));
209 break;
210 }
211 }
212 }
213 }
214
215
216
217 void GFX_SetWindowLayer0(uint32_t pDestination, int16_t XleftGimpStyle, int16_t XrightGimpStyle, int16_t YtopGimpStyle, int16_t YbottomGimpStyle)
218 {
219 int16_t XSize, YSize, X0, Y0;
220
221 if(XleftGimpStyle < 0) XleftGimpStyle = 0;
222 if(XrightGimpStyle < 0) XrightGimpStyle = 0;
223 if(XleftGimpStyle > 799) XleftGimpStyle = 800;
224 if(XrightGimpStyle > 799) XrightGimpStyle = 800;
225
226 if(YtopGimpStyle < 0) YtopGimpStyle = 0;
227 if(YbottomGimpStyle < 0) YbottomGimpStyle = 0;
228 if(YtopGimpStyle > 479) YtopGimpStyle = 480;
229 if(YbottomGimpStyle > 479) YbottomGimpStyle = 480;
230
231 /*
232 XSize = YbottomGimpStyle - YtopGimpStyle;
233 YSize = XrightGimpStyle - XleftGimpStyle;
234 if((XSize <= 0) || (YSize <= 0))
235 return;
236 X0 = 479 - YbottomGimpStyle;
237 Y0 = XleftGimpStyle;
238 while((LTDC->CPSR & LTDC_CPSR_CYPOS) <= (uint32_t)800);
239 HAL_LTDC_SetWindowSize(&LtdcHandle, XSize, YSize, LayerIdx);
240 HAL_LTDC_SetWindowPosition(&LtdcHandle, X0, Y0,LayerIdx);
241 HAL_LTDC_SetAddress(&LtdcHandle, pDestination, LayerIdx);
242 */
243
244 XSize = XrightGimpStyle - XleftGimpStyle;
245 YSize = YbottomGimpStyle - YtopGimpStyle;
246 if((XSize <= 0) || (YSize <= 0))
247 return;
248 Y0 = 479 - YbottomGimpStyle;
249 X0 = XleftGimpStyle;
250
251 GFX_SetFrameBottom(pDestination, X0, Y0, XSize, YSize);
252 }
253
254
255 void GFX_logoAutoOff(void)
256 {
257 if(logoStatus == LOGOOFF)
258 logoStatus = LOGOSTART;
259 }
260
261 /*
262 uint8_t GFX_printf_firmware(char *text)
263 {
264 uint8_t zahl, ptr;
265
266 ptr = 0;
267 zahl = settingsGetPointer()->firmwareVersion16to32bit.ub.first;
268 if(zahl >= 10)
269 {
270 text[ptr++] = '0' + (zahl / 10);
271 zahl = zahl - ((zahl / 10 ) * 10);
272 }
273 text[ptr++] = '0' + zahl;
274 text[ptr++] = '.';
275
276 zahl = settingsGetPointer()->firmwareVersion16to32bit.ub.second;
277 if(zahl >= 10)
278 {
279 text[ptr++] = '0' + (zahl / 10);
280 zahl = zahl - ((zahl / 10 ) * 10);
281 }
282 text[ptr++] = '0' + zahl;
283 text[ptr++] = '.';
284
285 zahl = settingsGetPointer()->firmwareVersion16to32bit.ub.third;
286 if(zahl >= 10)
287 {
288 text[ptr++] = '0' + (zahl / 10);
289 zahl = zahl - ((zahl / 10 ) * 10);
290 }
291 text[ptr++] = '0' + zahl;
292
293 if(settingsGetPointer()->firmwareVersion16to32bit.ub.betaFlag)
294 {
295 text[ptr++] = ' ';
296 text[ptr++] = 'b';
297 text[ptr++] = 'e';
298 text[ptr++] = 't';
299 text[ptr++] = 'a';
300 }
301 text[ptr] = 0;
302
303 return ptr;
304 }
305 */
306
307 void GFX_hwBackgroundOn(void)
308 {
309 backgroundHwStatus = LOGOSTART;
310 }
311
312
313 void GFX_hwBackgroundOff(void)
314 {
315 backgroundHwStatus = LOGOSTOP;
316 }
317
318
319 void GFX_build_hw_background_frame(void)
320 {
321 GFX_DrawCfgScreen tLogoTemp;
322 SWindowGimpStyle windowGimp;
323
324 pBackgroundHwFrame = getFrame(1);
325 backgroundHwStatus = 0;
326
327 tLogoTemp.FBStartAdress = pBackgroundHwFrame;
328 tLogoTemp.ImageHeight = 480;
329 tLogoTemp.ImageWidth = 800;
330 tLogoTemp.LayerIndex = 1;
331
332 windowGimp.left = (800 - 400) / 2;
333 windowGimp.top = 0;//(480 - 46) / 2;
334
335 GFX_draw_image_color(&tLogoTemp, windowGimp, &ImgHWcolor);
336 /*
337 char localtext[256];
338 uint8_t ptr = 0;
339
340 localtext[ptr++] = ' ';
341 localtext[ptr++] = ' ';
342 localtext[ptr++] = 'O';
343 localtext[ptr++] = 'S';
344 localtext[ptr++] = ' ';
345 ptr += GFX_printf_firmware(&localtext[ptr]);
346 localtext[ptr] = 0;
347
348 write_content_simple(&tLogoTemp, 0, 800, 240-24, &FontT24,localtext,CLUT_Font020);
349 */
350 }
351
352
353
354
355 void GFX_build_logo_frame(void)
356 {
357 GFX_DrawCfgScreen tLogoTemp;
358 SWindowGimpStyle windowGimp;
359
360 pLogoFrame = getFrame(1);
361 logoStatus = LOGOOFF;
362
363 tLogoTemp.FBStartAdress = pLogoFrame;
364 tLogoTemp.ImageHeight = 480;
365 tLogoTemp.ImageWidth = 800;
366 tLogoTemp.LayerIndex = 1;
367
368 windowGimp.left = (800 - 400) / 2;
369 windowGimp.top = (480 - 46) / 2;
370
371 GFX_draw_image_color(&tLogoTemp, windowGimp, &ImgHWcolor);
372 /*
373 char localtext[256];
374 uint8_t ptr = 0;
375
376 localtext[ptr++] = ' ';
377 localtext[ptr++] = ' ';
378 localtext[ptr++] = 'O';
379 localtext[ptr++] = 'S';
380 localtext[ptr++] = ' ';
381 ptr += GFX_printf_firmware(&localtext[ptr]);
382 localtext[ptr] = 0;
383
384 write_content_simple(&tLogoTemp, 0, 800, 240-24, &FontT24,localtext,CLUT_Font020);
385 */
386 }
387
388
389 void GFX_init(uint32_t * pDestinationOut)
390 {
391 frame[0].StartAddress = FBGlobalStart;
392 GFX_clear_frame_immediately(frame[0].StartAddress);
393 frame[0].status = CLEAR;
394 frame[0].caller = 0;
395
396 for(int i=1;i<MAXFRAMES;i++)
397 {
398 frame[i].StartAddress = frame[i-1].StartAddress + FBOffsetEachIndex;
399 GFX_clear_frame_immediately(frame[i].StartAddress);
400 frame[i].status = CLEAR;
401 frame[i].caller = 0;
402 }
403
404 for(int i=1;i<MAXFRAMECOUNTER;i++)
405 {
406 frameCounter[i] = 0;
407 }
408
409 pInvisibleFrame = getFrame(2);
410 *pDestinationOut = pInvisibleFrame;
411
412 GFX_build_logo_frame();
413 GFX_build_hw_background_frame();
414
415 /* Register to memory mode with ARGB8888 as color Mode */
416 Dma2dHandle.Init.Mode = DMA2D_R2M;
417 Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444;//to fake AL88, before: DMA2D_ARGB8888;
418 Dma2dHandle.Init.OutputOffset = 0;
419
420 /* DMA2D Callbacks Configuration */
421 Dma2dHandle.XferCpltCallback = GFX_Dma2d_TransferComplete;
422 Dma2dHandle.XferErrorCallback = GFX_Dma2d_TransferError;
423
424 Dma2dHandle.Instance = DMA2D;
425
426 /* DMA2D Initialisation */
427 if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
428 GFX_Error_Handler();
429
430 if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
431 GFX_Error_Handler();
432
433 DMA2D_at_work = 255;
434 }
435
436
437 void GFX_init1_no_DMA(uint32_t * pDestinationOut, uint8_t blockFrames)
438 {
439 frame[0].StartAddress = FBGlobalStart;
440 GFX_clear_frame_immediately(frame[0].StartAddress);
441 frame[0].status = CLEAR;
442 frame[0].caller = 0;
443
444 for(int i=1;i<MAXFRAMES;i++)
445 {
446 frame[i].StartAddress = frame[i-1].StartAddress + FBOffsetEachIndex;
447 GFX_clear_frame_immediately(frame[i].StartAddress);
448 frame[i].status = CLEAR;
449 frame[i].caller = 0;
450 }
451
452 for(int i=0;i<blockFrames;i++)
453 {
454 frame[i].status = BLOCKED;
455 frame[i].caller = 1;
456 }
457
458 pInvisibleFrame = getFrame(2);
459 *pDestinationOut = pInvisibleFrame;
460
461 GFX_build_logo_frame();
462 GFX_build_hw_background_frame();
463 }
464
465
466 void GFX_init2_DMA(void)
467 {
468 /* Register to memory mode with ARGB8888 as color Mode */
469 Dma2dHandle.Init.Mode = DMA2D_R2M;
470 Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444;//to fake AL88, before: DMA2D_ARGB8888;
471 Dma2dHandle.Init.OutputOffset = 0;
472
473 /* DMA2D Callbacks Configuration */
474 Dma2dHandle.XferCpltCallback = GFX_Dma2d_TransferComplete;
475 Dma2dHandle.XferErrorCallback = GFX_Dma2d_TransferError;
476
477 Dma2dHandle.Instance = DMA2D;
478
479 /* DMA2D Initialisation */
480 if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK)
481 GFX_Error_Handler();
482
483 if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK)
484 GFX_Error_Handler();
485
486 DMA2D_at_work = 255;
487 }
488
489
490
491 void GFX_SetFrameTop(uint32_t pDestination)
492 {
493 lock_changeLTDC = 1;
494 uint8_t boolNextTop = !FrameHandler.boolNextTop;
495
496 if(pDestination == 0)
497 pDestination = pInvisibleFrame;
498
499 FrameHandler.pNextTopBuffer[boolNextTop] = pDestination;
500 FrameHandler.boolNextTop = boolNextTop;
501 lock_changeLTDC = 0;
502 }
503
504
505 void GFX_SetFrameBottom(uint32_t pDestination, uint32_t x0, uint32_t y0, uint32_t width, uint32_t height)
506 {
507 lock_changeLTDC = 1;
508 uint8_t boolNextBottom = !FrameHandler.boolNextBottom;
509
510 if(pDestination == 0)
511 pDestination = pInvisibleFrame;
512
513 FrameHandler.nextBottom[boolNextBottom].pBuffer = pDestination;
514 FrameHandler.nextBottom[boolNextBottom].height = height;
515 FrameHandler.nextBottom[boolNextBottom].width = width;
516 FrameHandler.nextBottom[boolNextBottom].leftStart = x0;
517 FrameHandler.nextBottom[boolNextBottom].bottomStart = y0;
518 FrameHandler.boolNextBottom = boolNextBottom;
519 lock_changeLTDC = 0;
520 }
521
522
523 void GFX_SetFramesTopBottom(uint32_t pTop, uint32_t pBottom, uint32_t heightBottom)
524 {
525 GFX_SetFrameTop(pTop);
526 GFX_SetFrameBottom(pBottom, 0, 0, 800, heightBottom);
527 }
528
529
530 uint32_t GFX_get_pActualFrameTop(void)
531 {
532 return FrameHandler.pActualTopBuffer;
533 }
534
535
536 uint32_t GFX_get_pActualFrameBottom(void)
537 {
538 return FrameHandler.actualBottom.pBuffer;
539 }
540
541
542 void GFX_start_VSYNC_IRQ(void)
543 {
544 GPIO_InitTypeDef GPIO_InitStructure;
545
546 GPIO_InitStructure.Mode = GPIO_MODE_IT_FALLING;
547 GPIO_InitStructure.Pull = GPIO_NOPULL;
548 GPIO_InitStructure.Speed = GPIO_SPEED_LOW;
549 GPIO_InitStructure.Pin = VSYNC_IRQ_PIN;
550 HAL_GPIO_Init(VSYNC_IRQ_GPIO_PORT, &GPIO_InitStructure);
551
552 HAL_NVIC_SetPriority(VSYNC_IRQ_EXTI_IRQn, 1, 0);
553 HAL_NVIC_EnableIRQ(VSYNC_IRQ_EXTI_IRQn);
554 }
555
556
557 void GFX_change_LTDC(void)
558 {
559 if(lock_changeLTDC == 1)
560 return;
561
562 uint32_t pTop = 0;
563 uint32_t pBot = 0;
564 uint32_t heightBot = 0;
565 uint32_t widthBot = 0;
566 uint32_t leftStartBot = 0;
567 uint32_t bottomStartBot = 0;
568 uint8_t change_position = 0;
569 uint8_t change_size = 0;
570
571 // Top Frame
572 pTop = FrameHandler.pNextTopBuffer[FrameHandler.boolNextTop];
573 if(FrameHandler.pActualTopBuffer != pTop)
574 {
575 HAL_LTDC_SetAddress(&LtdcHandle, pTop, 1);
576 FrameHandler.pActualTopBuffer = pTop;
577 }
578
579 // Bottom Frame
580 if(logoStatus != LOGOOFF)
581 {
582 switch(logoStatus)
583 {
584 case LOGOSTART:
585 HAL_LTDC_SetAlpha(&LtdcHandle, 0, 1);
586 HAL_LTDC_SetAlpha(&LtdcHandle, 34, 0);
587 HAL_LTDC_ConfigCLUT(&LtdcHandle, (uint32_t *)indexHWcolor, indexHWcolorSIZE, 0);
588 HAL_LTDC_SetAddress(&LtdcHandle, pLogoFrame, 0);
589 HAL_LTDC_SetWindowSize(&LtdcHandle, 480, 800, 0);
590 HAL_LTDC_SetWindowPosition(&LtdcHandle, 0, 0, 0);
591 logoStatus = 2;
592 break;
593
594 case LOGOSTOP:
595 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 1);
596 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0);
597
598 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer;
599 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height;
600 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width;
601 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart;
602 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart;
603 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0);
604 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0);
605 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0);
606 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 0);
607 FrameHandler.actualBottom.height = heightBot;
608 FrameHandler.actualBottom.width = widthBot;
609 FrameHandler.actualBottom.leftStart = leftStartBot;
610 FrameHandler.actualBottom.bottomStart = bottomStartBot;
611 FrameHandler.actualBottom.pBuffer = pBot;
612
613 logoStatus = LOGOOFF;
614 if(backgroundHwStatus == 2)
615 {
616 backgroundHwStatus = LOGOSTART;
617 }
618 break;
619 default:
620 if(logoStatus < 35)
621 {
622 logoStatus++;
623 if(logoStatus <= 15)
624 HAL_LTDC_SetAlpha(&LtdcHandle, 17*logoStatus, 0);
625 }
626 else
627 {
628 logoStatus +=20;
629 HAL_LTDC_SetAlpha(&LtdcHandle, logoStatus-55, 1);
630 HAL_LTDC_SetAlpha(&LtdcHandle, 255+55-logoStatus, 0);
631 }
632 break;
633 }
634 return;
635 }
636 else if (backgroundHwStatus != LOGOOFF)
637 {
638 switch(backgroundHwStatus)
639 {
640 case LOGOSTART:
641 HAL_LTDC_ConfigCLUT(&LtdcHandle, (uint32_t *)indexHWcolor, indexHWcolorSIZE, 0);
642 HAL_LTDC_SetAddress(&LtdcHandle, pBackgroundHwFrame, 0);
643 HAL_LTDC_SetWindowSize(&LtdcHandle, 480, 800, 0);
644 HAL_LTDC_SetWindowPosition(&LtdcHandle, 0, 0, 0);
645 backgroundHwStatus = 2;
646 break;
647
648 case LOGOSTOP:
649 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0);
650 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer;
651 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height;
652 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width;
653 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart;
654 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart;
655 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0);
656 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0);
657 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0);
658 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 0);
659 FrameHandler.actualBottom.height = heightBot;
660 FrameHandler.actualBottom.width = widthBot;
661 FrameHandler.actualBottom.leftStart = leftStartBot;
662 FrameHandler.actualBottom.bottomStart = bottomStartBot;
663 FrameHandler.actualBottom.pBuffer = pBot;
664 backgroundHwStatus = LOGOOFF;
665 break;
666
667 default:
668 break;
669 }
670 return;
671 }
672 else
673 {
674 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer;
675 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height;
676 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width;
677 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart;
678 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart;
679
680 if(FrameHandler.actualBottom.pBuffer == pBot)
681 pBot = 0;
682
683 if((FrameHandler.actualBottom.height != heightBot) || (FrameHandler.actualBottom.width != widthBot))
684 change_size = 1;
685
686 if((FrameHandler.actualBottom.leftStart != leftStartBot) || (FrameHandler.actualBottom.bottomStart != bottomStartBot))
687 change_position = 1;
688
689 if(pBot || change_size || change_position)
690 {
691 if(heightBot && widthBot)
692 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0);
693
694 if(change_position || leftStartBot || bottomStartBot)
695 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0);
696
697 if(pBot)
698 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0);
699
700 if(change_size)
701 {
702 FrameHandler.actualBottom.height = heightBot;
703 FrameHandler.actualBottom.width = widthBot;
704 }
705 if(change_position)
706 {
707 FrameHandler.actualBottom.leftStart = leftStartBot;
708 FrameHandler.actualBottom.bottomStart = bottomStartBot;
709 }
710 if(pBot)
711 FrameHandler.actualBottom.pBuffer = pBot;
712 }
713 }
714 }
715
716 uint8_t GFX_is_colorschemeDiveStandard(void)
717 {
718 return (ColorLUT[CLUT_Font027] == 0x00FFFFFF);
719 }
720
721
722 void change_CLUT_entry(uint8_t entryToChange, uint8_t entryUsedForChange)
723 {
724 /* bug fix
725 static uint8_t counter = 0;
726
727 if(entryToChange == 0x1C)
728 counter++;
729 */
730 ColorLUT[entryToChange] = ColorLUT[entryUsedForChange];
731 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 1);
732 if(logoStatus == LOGOOFF)
733 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0);
734 }
735
736
737 void GFX_use_colorscheme(uint8_t colorscheme)
738 {
739 uint8_t ColorSchemeStart;
740
741 if(colorscheme > 3)
742 colorscheme = 0;
743
744 ColorSchemeStart = CLUT_Colorscheme0 + (8 * colorscheme);
745 for(int i=1; i<8; i++)
746 {
747 ColorLUT[CLUT_Font027 + i] = ColorLUT[ColorSchemeStart + i];
748 }
749 change_CLUT_entry(CLUT_Font027, ColorSchemeStart);
750 }
751
752
753 void GFX_VGA_transform(uint32_t pSource, uint32_t pDestination)
754 {
755 int h, v;
756 uint32_t offsetSource, offsetSourceStartOfLine;
757
758 offsetSourceStartOfLine = 480 + 480 - 2;
759 for(v=0;v<480;v++)
760 {
761 offsetSource = offsetSourceStartOfLine;
762 for(h=0;h<640;h++)
763 {
764 *(__IO uint8_t*)pDestination = *(uint8_t*)(pSource + offsetSource);
765 pDestination++;
766 offsetSource += 1;
767 *(__IO uint8_t*)pDestination = *(uint8_t*)(pSource + offsetSource);
768 pDestination++;
769 offsetSource += 480 + 479;
770 }
771 offsetSourceStartOfLine -= 2;
772 }
773 }
774
775 HAL_StatusTypeDef GFX_SetBackgroundColor(uint32_t LayerIdx, uint8_t red, uint8_t green, uint8_t blue)
776 {
777 uint32_t tmp = 0;
778 uint32_t tmp1 = 0;
779
780 /* Process locked */
781 __HAL_LOCK(&LtdcHandle);
782
783 /* Change LTDC peripheral state */
784 LtdcHandle.State = HAL_LTDC_STATE_BUSY;
785
786 /* Check the parameters */
787 assert_param(IS_LTDC_LAYER(LayerIdx));
788
789 /* Copy new layer configuration into handle structure */
790 LtdcHandle.LayerCfg[LayerIdx].Backcolor.Red = red;
791 LtdcHandle.LayerCfg[LayerIdx].Backcolor.Green = green;
792 LtdcHandle.LayerCfg[LayerIdx].Backcolor.Blue = blue;
793
794 /* Configure the LTDC Layer */
795 tmp = ((uint32_t)(green) << 8);
796 tmp1 = ((uint32_t)(red) << 16);
797 __HAL_LTDC_LAYER(&LtdcHandle, LayerIdx)->DCCR &= ~(LTDC_LxDCCR_DCBLUE | LTDC_LxDCCR_DCGREEN | LTDC_LxDCCR_DCRED | LTDC_LxDCCR_DCALPHA);
798 __HAL_LTDC_LAYER(&LtdcHandle, LayerIdx)->DCCR = (blue | tmp | tmp1 | 0xFF);
799
800 /* Sets the Reload type */
801 LtdcHandle.Instance->SRCR = LTDC_SRCR_IMR;
802
803 /* Initialize the LTDC state*/
804 LtdcHandle.State = HAL_LTDC_STATE_READY;
805
806 /* Process unlocked */
807 __HAL_UNLOCK(&LtdcHandle);
808
809 return HAL_OK;
810 }
811
812
813 void GFX_clear_frame_immediately(uint32_t pDestination)
814 {
815 uint32_t i;
816
817 for(i = 200*480; i > 0; i--)
818 {
819 *(__IO uint16_t*)pDestination = 0;
820 pDestination += 2;
821 *(__IO uint16_t*)pDestination = 0;
822 pDestination += 2;
823 *(__IO uint16_t*)pDestination = 0;
824 pDestination += 2;
825 *(__IO uint16_t*)pDestination = 0;
826 pDestination += 2;
827 }
828 }
829
830
831 void GFX_clear_window_immediately(GFX_DrawCfgWindow* hgfx)
832 {
833 uint32_t pDestination, i, j;
834 uint16_t left, width, bottom, height, nextlineStep;
835
836 pDestination = (uint32_t)hgfx->Image->FBStartAdress;
837
838 left = hgfx->WindowX0;
839 width = 1 + hgfx->WindowX1 - left;
840 bottom = hgfx->WindowY0;
841 height = 1 + hgfx->WindowY1 - bottom;
842 nextlineStep = hgfx->Image->ImageHeight - height;
843 nextlineStep *= 2;
844
845 pDestination += 2 * bottom;
846 pDestination += 2 * hgfx->Image->ImageHeight * left;
847
848 for(j = width; j > 0; j--)
849 {
850 for(i = height; i > 0; i--)
851 {
852 *(__IO uint16_t*)pDestination = 0;
853 pDestination += 2;
854 }
855 pDestination += nextlineStep;
856 }
857 }
858
859
860 void GFX_clear_frame_dma2d(uint8_t frameId)
861 {
862 if(frameId >= MAXFRAMES)
863 return;
864
865 DMA2D_at_work = frameId;
866
867 if (HAL_DMA2D_Start_IT(&Dma2dHandle, 0x0000000000, frame[frameId].StartAddress, 480, 800) != HAL_OK)
868 GFX_Error_Handler();
869 }
870
871
872 void GFX_fill_buffer(uint32_t pDestination, uint8_t alpha, uint8_t color)
873 {
874
875 union al88_u
876 {
877 uint8_t al8[2];
878 uint16_t al88;
879 };
880
881 union al88_u colorcombination;
882 uint32_t i;
883
884 colorcombination.al8[0] = color;
885 colorcombination.al8[1] = alpha;
886
887 for(i = 800*480; i > 0; i--)
888 {
889 *(__IO uint16_t*)pDestination = colorcombination.al88;
890 pDestination += 2;
891 }
892 }
893
894
895 void gfx_flip(point_t *p1, point_t *p2)
896 {
897 point_t temp;
898
899 temp = *p1;
900 *p1 = *p2;
901 *p2 = temp;
902 }
903
904
905 static inline void gfx_brush(uint8_t thickness, GFX_DrawCfgScreen *hgfx, uint16_t x0, uint16_t y0, uint8_t color)
906 {
907 uint32_t pDestination;
908 uint8_t offset = thickness/2;
909
910 pDestination = hgfx->FBStartAdress + 2*(x0 - offset)*hgfx->ImageHeight + 2*(y0-offset);
911 for(int x=thickness;x>0;x--)
912 {
913 for(int y=thickness;y>0;y--)
914 {
915 *(__IO uint16_t*)pDestination = 0xFF00 + color;
916 pDestination +=2;
917 }
918 pDestination += 2*(hgfx->ImageHeight - thickness);
919 }
920 }
921
922
923 void GFX_draw_thick_line(uint8_t thickness, GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color)
924 {
925 if(thickness < 2)
926 GFX_draw_line(hgfx, start, stop, color);
927
928 int x0 = start.x;
929 int y0 = start.y;
930 int x1 = stop.x;
931 int y1 = stop.y;
932 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
933 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
934 int err = (dx>dy ? dx : -dy)/2, e2;
935
936
937 if(start.x == stop.x)
938 {
939 if(start.y > stop.y) gfx_flip(&start,&stop);
940 for (int j = stop.y - start.y; j > 0; j--)
941 {
942 gfx_brush(thickness,hgfx,start.x,start.y++,color);
943 }
944 }
945 else
946 if(start.y == stop.y)
947 {
948 if(start.x > stop.x) gfx_flip(&start,&stop);
949
950 for (int j = stop.x - start.x; j > 0; j--)
951 {
952 gfx_brush(thickness,hgfx,start.x++,start.y,color);
953 }
954 }
955 else // diagonal
956 {
957 for(;;)
958 {
959 gfx_brush(thickness,hgfx,x0,y0,color);
960 if (x0==x1 && y0==y1) break;
961 e2 = err;
962 if (e2 >-dx) { err -= dy; x0 += sx; }
963 if (e2 < dy) { err += dx; y0 += sy; }
964 }
965 }
966 }
967
968
969 void GFX_draw_line(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color)
970 {
971 uint32_t pDestination;
972 uint32_t j;
973
974 if(start.x == stop.x)
975 {
976 if(start.y > stop.y) gfx_flip(&start,&stop);
977 pDestination = (uint32_t)hgfx->FBStartAdress;
978 pDestination += start.x * hgfx->ImageHeight * 2;
979 pDestination += start.y * 2;
980 for (j = stop.y - start.y; j > 0; j--)
981 {
982 *(__IO uint16_t*)pDestination = 0xFF00 + color;
983 pDestination += 2;
984 }
985 }
986 else
987 if(start.y == stop.y)
988 {
989 if(start.x > stop.x) gfx_flip(&start,&stop);
990 pDestination = (uint32_t)hgfx->FBStartAdress;
991 pDestination += start.x * hgfx->ImageHeight * 2;
992 pDestination += start.y * 2;
993 for (j = stop.x - start.x; j > 0; j--)
994 {
995 *(__IO uint16_t*)pDestination = 0xFF00 + color;
996 pDestination += hgfx->ImageHeight * 2;
997 }
998 }
999 else // diagonal
1000 {
1001 int x0 = start.x;
1002 int y0 = start.y;
1003 int x1 = stop.x;
1004 int y1 = stop.y;
1005 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
1006 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
1007 int err = (dx>dy ? dx : -dy)/2, e2;
1008
1009 for(;;)
1010 {
1011 pDestination = (uint32_t)hgfx->FBStartAdress;
1012 pDestination += ((x0 * hgfx->ImageHeight) + y0) * 2;
1013 *(__IO uint16_t*)pDestination = 0xFF00 + color;
1014 if (x0==x1 && y0==y1) break;
1015 e2 = err;
1016 if (e2 >-dx) { err -= dy; x0 += sx; }
1017 if (e2 < dy) { err += dx; y0 += sy; }
1018 }
1019 }
1020 }
1021
1022
1023 void GFX_draw_image_monochrome(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, const tImage *image, uint8_t color)
1024 {
1025 uint32_t pDestination;
1026 uint32_t j;
1027 point_t start, stop;
1028
1029 start.x = window.left;
1030 start.y = (hgfx->ImageHeight - image->height - window.top);
1031 stop.y = start.y + image->height;
1032 stop.x = start.x + image->width;
1033 j = 0;
1034
1035 for(int xx = start.x; xx < stop.x; xx++)
1036 {
1037 pDestination = (uint32_t)hgfx->FBStartAdress;
1038 pDestination += xx * hgfx->ImageHeight * 2;
1039 pDestination += start.y * 2;
1040 for(int yy = start.y; yy < stop.y; yy++)
1041 {
1042 *(__IO uint8_t*)pDestination = color;
1043 pDestination += 1;
1044 *(__IO uint8_t*)pDestination = image->data[j++];
1045 pDestination += 1;
1046 }
1047 }
1048 }
1049
1050
1051 void GFX_draw_image_color(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, const tImage *image)
1052 {
1053 uint32_t pDestination;
1054 uint32_t j;
1055 point_t start, stop;
1056
1057 start.x = window.left;
1058 start.y = (hgfx->ImageHeight - image->height - window.top);
1059 stop.y = start.y + image->height;
1060 stop.x = start.x + image->width;
1061 j = 0;
1062
1063 for(int xx = start.x; xx < stop.x; xx++)
1064 {
1065 pDestination = (uint32_t)hgfx->FBStartAdress;
1066 pDestination += xx * hgfx->ImageHeight * 2;
1067 pDestination += start.y * 2;
1068 for(int yy = start.y; yy < stop.y; yy++)
1069 {
1070 *(__IO uint8_t*)pDestination = image->data[j++];
1071 pDestination += 1;
1072 *(__IO uint8_t*)pDestination = 0xFF;
1073 pDestination += 1;
1074 }
1075 }
1076 }
1077
1078
1079 int16_Point_t switchToOctantZeroFrom(uint8_t octant, int16_t x, int16_t y)
1080 {
1081 int16_Point_t answer;
1082 switch(octant)
1083 {
1084 case 0:// return (x,y);
1085 answer.x = x;
1086 answer.y = y;
1087 break;
1088 case 1:// return (y,x);
1089 answer.x = y;
1090 answer.y = x;
1091 break;
1092 case 2:// return (y, -x);
1093 answer.x = y;
1094 answer.y = -x;
1095 break;
1096 case 3:// return (-x, y);
1097 answer.x = -x;
1098 answer.y = y;
1099 break;
1100 case 4:// return (-x, -y);
1101 answer.x = -x;
1102 answer.y = -y;
1103 break;
1104 case 5:// return (-y, -x);
1105 answer.x = -y;
1106 answer.y = -x;
1107 break;
1108 case 6:// return (-y, x);
1109 answer.x = -y;
1110 answer.y = x;
1111 break;
1112 case 7:// return (x, -y);
1113 answer.x = x;
1114 answer.y = -y;
1115 break;
1116 }
1117 return answer;
1118 }
1119
1120 /* this is NOT fast nor optimized */
1121 void GFX_draw_pixel(GFX_DrawCfgScreen *hgfx, int16_t x, int16_t y, uint8_t color)
1122 {
1123 uint32_t pDestination;
1124
1125 pDestination = (uint32_t)hgfx->FBStartAdress;
1126 pDestination += x * hgfx->ImageHeight * 2;
1127 pDestination += y * 2;
1128
1129 *(__IO uint8_t*)pDestination = color;
1130 pDestination += 1;
1131 *(__IO uint8_t*)pDestination = 0xFF;
1132 }
1133
1134
1135 /* store the quarter circle for given radius */
1136 void GFX_draw_circle_with_MEMORY(uint8_t use_memory, GFX_DrawCfgScreen *hgfx, point_t center, uint8_t radius, int8_t color)
1137 {
1138 }
1139
1140 /* this is NOT fast nor optimized */
1141 void GFX_draw_circle(GFX_DrawCfgScreen *hgfx, point_t center, uint8_t radius, int8_t color)
1142 {
1143 int x, y;
1144 int l;
1145 int r2, y2;
1146 int y2_new;
1147 int ty;
1148
1149 /* cos pi/4 = 185363 / 2^18 (approx) */
1150 l = (radius * 185363) >> 18;
1151
1152 /* hw */
1153 l += 1;
1154
1155 /* At x=0, y=radius */
1156 y = radius;
1157
1158 r2 = y2 = y * y;
1159 ty = (2 * y) - 1;
1160 y2_new = r2 + 3;
1161
1162 for (x = 0; x <= l; x++) {
1163 y2_new -= (2 * x) - 3;
1164
1165 if ((y2 - y2_new) >= ty) {
1166 y2 -= ty;
1167 y -= 1;
1168 ty -= 2;
1169 }
1170
1171 GFX_draw_pixel (hgfx, x + center.x, y + center.y, color);
1172 GFX_draw_pixel (hgfx, x + center.x, -y + center.y, color);
1173 GFX_draw_pixel (hgfx, -x + center.x, y + center.y, color);
1174 GFX_draw_pixel (hgfx, -x + center.x, -y + center.y, color);
1175
1176 GFX_draw_pixel (hgfx, y + center.x, x + center.y, color);
1177 GFX_draw_pixel (hgfx, y + center.x, -x + center.y, color);
1178 GFX_draw_pixel (hgfx, -y + center.x, x + center.y, color);
1179 GFX_draw_pixel (hgfx, -y + center.x, -x + center.y, color);
1180 }
1181 }
1182
1183
1184 void GFX_draw_colorline(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color)
1185 {
1186 uint32_t pDestination;
1187 uint32_t j;
1188 uint32_t temp;
1189
1190 if(start.x == stop.x)
1191 {
1192 if(stop.y < start.y)
1193 {
1194 temp = stop.y;
1195 stop.y = start.y;
1196 start.y = temp;
1197 }
1198 pDestination = (uint32_t)hgfx->FBStartAdress;
1199 pDestination += start.x * hgfx->ImageHeight * 2;
1200 pDestination += start.y * 2;
1201 for (j = stop.y - start.y; j > 0; j--)
1202 {
1203 *(__IO uint8_t*)pDestination = color;
1204 pDestination += 1;
1205 *(__IO uint8_t*)pDestination = 0xFF;
1206 pDestination += 1;
1207 }
1208 }
1209 else
1210 if(start.y == stop.y)
1211 {
1212 if(stop.x < start.x)
1213 {
1214 temp = stop.x;
1215 stop.x = start.x;
1216 start.x = temp;
1217 }
1218 pDestination = (uint32_t)hgfx->FBStartAdress;
1219 pDestination += start.x * hgfx->ImageHeight * 2;
1220 pDestination += start.y * 2;
1221 for (j = stop.x - start.x; j > 0; j--)
1222 {
1223 *(__IO uint8_t*)pDestination = color;
1224 pDestination += 1;
1225 *(__IO uint8_t*)pDestination = 0xFF;
1226 pDestination -= 1;
1227 pDestination += hgfx->ImageHeight * 2;
1228 }
1229 }
1230 else // diagonal Bresenham's_line_algorithm
1231 {
1232 int x0 = start.x;
1233 int y0 = start.y;
1234 int x1 = stop.x;
1235 int y1 = stop.y;
1236 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
1237 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
1238 int err = (dx>dy ? dx : -dy)/2, e2;
1239
1240 for(;;)
1241 {
1242 pDestination = (uint32_t)hgfx->FBStartAdress;
1243 pDestination += ((x0 * hgfx->ImageHeight) + y0) * 2;
1244 *(__IO uint8_t*)pDestination = color;
1245 pDestination += 1;
1246 *(__IO uint8_t*)pDestination = 0xFF;
1247 if (x0==x1 && y0==y1) break;
1248 e2 = err;
1249 if (e2 >-dx) { err -= dy; x0 += sx; }
1250 if (e2 < dy) { err += dx; y0 += sy; }
1251 }
1252 }
1253 }
1254
1255
1256 void GFX_draw_Grid(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, int vlines, float vdeltaline, int hlines, float hdeltalines, uint8_t color)
1257 {
1258 point_t p1;
1259 point_t p2;
1260 int winthight = window.bottom - window.top;
1261 int winwidth = window.right - window.left;
1262 float deltaline = 0;
1263
1264 if(vlines > 0)
1265 {
1266 deltaline = ((float)winwidth) /vlines;
1267
1268 p1.y = 479 - window.top;
1269 p2.y = 479 - window.bottom;
1270 for(int i = 0; i <= vlines; i++)
1271 {
1272 p1.x = window.left + (int)(i * deltaline + 0.5f);
1273 p2.x = p1.x ;
1274 GFX_draw_colorline(hgfx, p1,p2, color );
1275 }
1276 }
1277 if(vdeltaline > 0)
1278 {
1279 p1.y = 479 - window.top;
1280 p2.y = 479 - window.bottom;
1281 for(int i = 0; i < winwidth/vdeltaline; i++)
1282 {
1283 p1.x = window.left + (int)(i * vdeltaline + 0.5f);
1284 p2.x = p1.x ;
1285 GFX_draw_colorline(hgfx, p1,p2, color );
1286 }
1287 }
1288 if(hlines > 0)
1289 {
1290 deltaline = ((float)winthight)/hlines;
1291 p1.x = window.left;
1292 p2.x = window.right;
1293 for(int i = 0; i <= hlines; i++)
1294 {
1295 p1.y = 479 - window.top - (int)(i * deltaline + 0.5f);
1296 p2.y = p1.y;
1297 GFX_draw_colorline(hgfx, p1,p2, color );
1298 }
1299 }
1300 }
1301
1302 /* drawVeilUntil ist auff�llen des Bereichs unter der Kurve mit etwas hellerer Farbe
1303 * Xdivide ist nichr benutzt, wird weggelassen in dieser Version
1304 */
1305 /*
1306 void GFX_graph_print(GFX_DrawCfgScreen *hgfx, const SWindowGimpStyle *window, uint16_t drawVeilUntil, uint8_t Xdivide, uint16_t dataMin, uint16_t dataMax, uint16_t *data, uint16_t datalength, uint8_t color, uint8_t *colour_data)
1307 {
1308 if(window->bottom > 479)
1309 return;
1310 if(window->top > 479)
1311 return;
1312 if(window->right > 799)
1313 return;
1314 if(window->left > 799)
1315 return;
1316 if(window->bottom < 0)
1317 return;
1318 if(window->top < 0)
1319 return;
1320 if(window->right < 0)
1321 return;
1322 if(window->left < 0)
1323 return;
1324 if(window->bottom <= window->top)
1325 return;
1326 if(window->right <= window->left)
1327 return;
1328
1329 uint16_t windowwidth = (uint16_t)window->right - (uint16_t)window->left;
1330
1331 if(dataMax == dataMin)
1332 dataMax++;
1333
1334 uint8_t invert = 0;
1335 if(dataMin > dataMax)
1336 {
1337 uint16_t dataFlip;
1338 dataFlip = dataMin;
1339 dataMin = dataMax;
1340 dataMax = dataFlip;
1341 invert = 1;
1342 }
1343 else
1344 invert = 0;
1345
1346 uint16_t dataDelta = 0;
1347 dataDelta = dataMax - dataMin;
1348
1349 uint8_t colormask = color;
1350
1351 uint16_t loopX, loopData;
1352 loopX = 0;
1353 loopData = 0;
1354 while((loopX <= windowwidth) & (loopData < datalength))
1355 {
1356
1357 }
1358
1359
1360 uint32_t pDestination_zero_veil = 0;
1361 uint32_t pDestination = 0;
1362 uint32_t pDestinationOld = 0;
1363 int windowwidth = -1;
1364 int windowheight = -1;
1365 int w1 = -1;
1366 int w2 = -1;
1367 int value = -1;
1368 uint8_t colormask = 0;
1369
1370 // preparation
1371 windowheight = window->bottom - window->top;
1372 windowwidth = window->right - window->left;
1373 pDestination_zero_veil = hgfx->FBStartAdress + 2 * ( (479 - (drawVeilUntil - 2) ) + ( (window->left) * hgfx->ImageHeight) );
1374
1375 while((w1 <= windowwidth) & (w2 < datalength))
1376 {
1377 // before
1378 if(colour_data != NULL)
1379 {
1380 colormask = color + colour_data[w2];
1381 }
1382 pDestination = hgfx->FBStartAdress + 2 * ( (479 - (window->top + value) ) + ( (w1 + window->left) * hgfx->ImageHeight) );
1383
1384 // after
1385 pDestination_zero_veil += (window->left) * hgfx->ImageHeight;
1386 }
1387 }
1388 */
1389
1390
1391
1392 // ===============================================================================
1393 // GFX_graph_print
1394 /// @brief Print all those nice curves, especially in logbook und miniLiveLogGraph
1395 /// @version 0.0.2 hw 160519
1396 ///
1397 /// 151022 hw -bug fix
1398 /// - die aktuelle Version macht keine Linien mehr �ber die gesamte Bildschirmh�he.
1399 /// - daf�r sind L�cher in der Kurve (z.B. Temperaturgraph Tauchgang Matthias 17.10.15 15:19)
1400 ///
1401 /// more details about range can be found in show_logbook_logbook_show_log_page2() - temperature graph
1402 ///
1403 /// @param window: top and bottom is only the range used by the data of the graph, not the entire screen / scale
1404 /// @param drawVeilUntil: ist auff�llen des Bereichs unter der Kurve mit etwas hellerer Farbe
1405 /// @param Xdivide: wird bisher nichr benutzt.
1406 // ===============================================================================
1407
1408
1409 void GFX_graph_print(GFX_DrawCfgScreen *hgfx, const SWindowGimpStyle *window, int16_t drawVeilUntil, uint8_t Xdivide, uint16_t dataMin, uint16_t dataMax, uint16_t *data, uint16_t datalength, uint8_t color, uint8_t *colour_data)
1410 {
1411 //uint32_t pDestination,pDestination_old,
1412 uint32_t pDestination_tmp,pDestination_end, pDestination_start, pDestination_zero_veil;
1413
1414 uint32_t max = 0;
1415 int windowheight = -1;
1416 int windowwidth = -1;
1417 int i = -1;
1418 int w1 = -1;
1419 int w2 = -1;
1420
1421 uint32_t h_ulong = 0;
1422 uint32_t h_ulong_old = 0;
1423 _Bool invert = 0;
1424
1425 uint16_t dataDelta = 0;
1426 uint16_t dataDeltaHalve = 0;
1427 uint16_t dataTemp = 0;
1428
1429 uint8_t colorDataTemp;
1430 uint8_t colormask = 0;
1431
1432 if(dataMin > dataMax)
1433 {
1434 uint16_t dataFlip;
1435 dataFlip = dataMin;
1436 dataMin = dataMax;
1437 dataMax = dataFlip;
1438 invert = 1;
1439 }
1440 else
1441 invert = 0;
1442
1443 colormask = color;
1444
1445
1446 if(window->bottom > 479)
1447 return;
1448 if(window->top > 479)
1449 return;
1450 if(window->right > 799)
1451 return;
1452 if(window->left > 799)
1453 return;
1454 if(window->bottom < 0)
1455 return;
1456 if(window->top < 0)
1457 return;
1458 if(window->right < 0)
1459 return;
1460 if(window->left < 0)
1461 return;
1462 if(window->bottom <= window->top)
1463 return;
1464 if(window->right <= window->left)
1465 return;
1466
1467 windowheight = window->bottom - window->top ;
1468 windowwidth = window->right - window->left;
1469 w1 = 0;
1470 w2 = 0;
1471 if(dataMax == dataMin)
1472 dataMax++;
1473 dataDelta = (unsigned long)(dataMax - dataMin);
1474 dataDeltaHalve = dataDelta / 2;
1475 while((w1 <= windowwidth) & (w2 < datalength))
1476 {
1477 int tmp = (10 * w1 * (long)datalength)/windowwidth;
1478 w2 = tmp/10;
1479 int rest = tmp - w2*10;
1480 if(rest >= 5)
1481 w2++;
1482
1483 if((datalength - 1) < w2)
1484 w2 = datalength-1;
1485
1486 if(colour_data != NULL)
1487 {
1488 colorDataTemp = colour_data[w2];
1489 colormask = color + colorDataTemp;
1490 }
1491
1492 dataTemp = data[w2];
1493 if(Xdivide > 1)
1494 {
1495 w2++;
1496 for(i=1;i<Xdivide;i++)
1497 {
1498 if(data[w2]>dataTemp)
1499 dataTemp = data[w2];
1500 w2++;
1501 }
1502 }
1503
1504 if(dataTemp > dataMin)
1505 dataTemp -= dataMin;
1506 else
1507 dataTemp = 0;
1508
1509 if(invert)
1510 {
1511 if(dataTemp < dataDelta)
1512 dataTemp = dataDelta - dataTemp;
1513 else
1514 dataTemp = 0;
1515 }
1516
1517 h_ulong = (unsigned long)dataTemp;
1518 h_ulong *= windowheight;
1519 h_ulong += dataDeltaHalve;
1520 h_ulong /= dataDelta;
1521
1522 if(h_ulong > (window->bottom - window->top))
1523 h_ulong = (window->bottom - window->top);
1524
1525 if(drawVeilUntil > 0)
1526 {
1527 pDestination_zero_veil = hgfx->FBStartAdress + 2 * ( (479 - (drawVeilUntil - 2) ) + ( (w1 + window->left) * hgfx->ImageHeight) );
1528 }
1529 else if(drawVeilUntil < 0 )
1530 {
1531 pDestination_zero_veil = hgfx->FBStartAdress + 2 * ( (479 + (drawVeilUntil) ) + ( (w1 + window->left) * hgfx->ImageHeight) );
1532 }
1533
1534 if(h_ulong + window->top > max)
1535 {
1536 max = h_ulong + window->top;
1537 }
1538
1539 // hw 160519 wof�r ist das? Damit funktioniert Temperatur 25,5�C nicht!
1540 // if((dataMax == 255) || (data[w2] != 255))
1541 // {
1542 //output_content[pointer] = colormask;
1543 //output_mask[pointer] = true;
1544 if(w1 > 0)
1545 {
1546 pDestination_start = hgfx->FBStartAdress + (2 * ((479 - (window->top)) + ((w1 + window->left) * hgfx->ImageHeight)));
1547 pDestination_end = pDestination_start;
1548 if(h_ulong >= h_ulong_old)
1549 {
1550 pDestination_start -= 2 * h_ulong_old;
1551 pDestination_end -= 2 * h_ulong;
1552 }
1553 else
1554 {
1555 pDestination_start -= 2 * h_ulong;
1556 pDestination_end -= 2 * h_ulong_old;
1557 }
1558
1559 // deco stops
1560 if(drawVeilUntil < 0)
1561 {
1562 pDestination_tmp = pDestination_end;
1563 while(pDestination_tmp <= pDestination_zero_veil)
1564 {
1565 *(__IO uint8_t*)pDestination_tmp = colormask;
1566 pDestination_tmp -= 1;
1567 *(__IO uint8_t*)pDestination_tmp = 0x80;
1568 pDestination_tmp += 3;
1569 }
1570 }
1571 else
1572 {
1573 // regular graph with veil underneath if requested
1574 // von oben nach unten
1575 // von grossen pDestination Werten zu kleinen pDestination Werten
1576 pDestination_tmp = pDestination_start;
1577 while(pDestination_tmp >= pDestination_end)
1578 {
1579 *(__IO uint8_t*)pDestination_tmp = colormask;
1580 pDestination_tmp += 1;
1581 *(__IO uint8_t*)pDestination_tmp = 0xFF;
1582 pDestination_tmp -= 3;
1583 }
1584 while((drawVeilUntil > 0) && (pDestination_tmp >= pDestination_zero_veil))
1585 {
1586 *(__IO uint8_t*)pDestination_tmp = colormask;
1587 pDestination_tmp += 1;
1588 *(__IO uint8_t*)pDestination_tmp = 0x20;
1589 pDestination_tmp -= 3;
1590 }
1591 }
1592 }
1593 h_ulong_old = h_ulong;
1594 // }
1595 w1++;
1596 w2++;
1597 }
1598 }
1599
1600
1601 void GFX_draw_header(GFX_DrawCfgScreen *hgfx, uint8_t colorId)
1602 {
1603 uint32_t pDestination;
1604 point_t start, stop, now;
1605 uint8_t alpha;
1606
1607 /* display coordinate system */
1608 start.y = 400;
1609 stop.y = 479;
1610
1611 start.x = 0;
1612 stop.x = 799;
1613
1614 now.y = start.y;
1615 now.x = start.x;
1616
1617 while (now.x <= stop.x)
1618 {
1619 now.y = start.y;
1620 pDestination = (uint32_t)hgfx->FBStartAdress;
1621 pDestination += now.x * hgfx->ImageHeight * 2;
1622 pDestination += now.y * 2;
1623 now.x += 1;
1624
1625 alpha = 27;
1626 while(alpha < 246)
1627 {
1628 alpha += 9;
1629 *(__IO uint8_t*)pDestination = colorId;
1630 pDestination += 1;
1631 *(__IO uint8_t*)pDestination = alpha;
1632 pDestination += 1;
1633 now.y += 1;
1634 }
1635
1636 while(now.y <= stop.y)
1637 {
1638 *(__IO uint8_t*)pDestination = colorId;
1639 pDestination += 1;
1640 *(__IO uint8_t*)pDestination = 0xFF;
1641 pDestination += 1;
1642 now.y += 1;
1643 }
1644 }
1645 }
1646
1647 void GFX_draw_box2(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color, uint8_t roundCorners)
1648 {
1649 point_t point2, point4;
1650
1651 if(roundCorners)
1652 {
1653 point2.x = stop.x - start.x;
1654 point2.y = stop.y - start.y;
1655 GFX_draw_box(hgfx,start,point2,1,color);
1656 }
1657 else
1658 {
1659 point2.x = stop.x;
1660 point2.y = start.y;
1661
1662 point4.x = start.x;
1663 point4.y = stop.y;
1664
1665 GFX_draw_line(hgfx,start,point2,color);
1666 GFX_draw_line(hgfx,point2,stop,color);
1667 GFX_draw_line(hgfx,stop,point4,color);
1668 GFX_draw_line(hgfx,point4,start,color);
1669 }
1670 }
1671
1672 void GFX_draw_box(GFX_DrawCfgScreen *hgfx, point_t LeftLow, point_t WidthHeight, uint8_t Style, uint8_t color)
1673 {
1674 uint32_t pDestination, pStart;
1675 uint32_t j;
1676 uint32_t lineWidth, lineHeight;
1677 int x, y;
1678 uint8_t intensity;
1679
1680 typedef struct {
1681 int x;
1682 int y;
1683 uint8_t intensity;
1684 } corner_t;
1685 const corner_t corner[16] = {
1686 {3,3,255}, // nur einmal
1687 {9,0,242},
1688 {8,0,194},
1689 {7,0,115},
1690 {6,0,36},
1691 {9,1,33},
1692 {8,1,84},
1693 {7,1,161},
1694 {6,1,255},
1695 {5,1,242},
1696 {4,1,36},
1697 {6,2,33},
1698 {5,2,84},
1699 {4,2,255},
1700 {3,2,84},
1701 {4,3,110}
1702 };
1703
1704 lineWidth = WidthHeight.x;
1705 lineHeight = WidthHeight.y;
1706
1707 pStart = (uint32_t)hgfx->FBStartAdress;
1708 pStart += LeftLow.x * hgfx->ImageHeight * 2;
1709 pStart += LeftLow.y * 2;
1710
1711 // Untere Linie
1712 pDestination = pStart;
1713 if(Style)
1714 {
1715 pDestination += 2 * 10 * hgfx->ImageHeight;
1716 lineWidth -= 18;
1717 }
1718 for (j = lineWidth; j > 0; j--)
1719 {
1720 *(__IO uint16_t*)pDestination = 0xFF00 + color;
1721 pDestination += hgfx->ImageHeight * 2;
1722 }
1723
1724 // Obere Linie
1725 pDestination = pStart + 2 * WidthHeight.y;
1726 if(Style)
1727 {
1728 pDestination += 2 * 10 * hgfx->ImageHeight;
1729 }
1730
1731 for (j = lineWidth; j > 0; j--)
1732 {
1733 *(__IO uint16_t*)pDestination = 0xFF00 + color;
1734 pDestination += hgfx->ImageHeight * 2;
1735 }
1736
1737 // Linke Linie
1738 pDestination = pStart;
1739 if(Style)
1740 {
1741 pDestination += 2 * 10;
1742 lineHeight -= 18;
1743 }
1744
1745 for (j = lineHeight; j > 0; j--)
1746 {
1747 *(__IO uint16_t*)pDestination = 0xFF00 + color;
1748 pDestination += 2;
1749 }
1750
1751 // Rechte Linie
1752 pDestination = pStart + 2 * WidthHeight.x * hgfx->ImageHeight;
1753 if(Style)
1754 {
1755 pDestination += 2 * 10;
1756 }
1757
1758 for (j = lineHeight; j > 0; j--)
1759 {
1760 *(__IO uint16_t*)pDestination = 0xFF00 + color;
1761 pDestination += 2;
1762 }
1763
1764 // Ecken wenn notwendig == Style
1765 if(Style)
1766 {
1767 // links unten
1768 pDestination = pStart;
1769 x = corner[0].x;
1770 y = corner[0].y;
1771 intensity = corner[0].intensity;
1772 *(__IO uint16_t*)(pDestination + 2 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1773
1774 for(j = 15; j > 0; j--)
1775 {
1776 x = corner[j].x;
1777 y = corner[j].y;
1778 intensity = corner[j].intensity;
1779 *(__IO uint16_t*)(pDestination + 2 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1780 *(__IO uint16_t*)(pDestination + 2 * (x + (y * hgfx->ImageHeight))) = (intensity << 8) + color;
1781 }
1782 // links oben
1783 pDestination = pStart + 2 * WidthHeight.y;
1784 x = corner[0].x;
1785 y = corner[0].y;
1786 intensity = corner[0].intensity;
1787 *(__IO uint16_t*)(pDestination + 2 * (-y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1788
1789 for(j = 15; j > 0; j--)
1790 {
1791 x = corner[j].x;
1792 y = corner[j].y;
1793 intensity = corner[j].intensity;
1794 *(__IO uint16_t*)(pDestination + 2 * (-y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1795 *(__IO uint16_t*)(pDestination + 2 * (-x + (y * hgfx->ImageHeight))) = (intensity << 8) + color;
1796 }
1797 // rechts unten
1798 pDestination = pStart + 2 * WidthHeight.x * hgfx->ImageHeight;
1799 x = corner[0].x;
1800 y = corner[0].y;
1801 intensity = corner[0].intensity;
1802 *(__IO uint16_t*)(pDestination + 2 * (y - (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1803
1804 for(j = 15; j > 0; j--)
1805 {
1806 x = corner[j].x;
1807 y = corner[j].y;
1808 intensity = corner[j].intensity;
1809 *(__IO uint16_t*)(pDestination + 2 * (y - (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1810 *(__IO uint16_t*)(pDestination + 2 * (x - (y * hgfx->ImageHeight))) = (intensity << 8) + color;
1811 }
1812 // rechts oben
1813 pDestination = pStart + 2 * WidthHeight.y + 2 * WidthHeight.x * hgfx->ImageHeight;
1814 x = corner[0].x;
1815 y = corner[0].y;
1816 intensity = corner[0].intensity;
1817 *(__IO uint16_t*)(pDestination - 2 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1818
1819 for(j = 15; j > 0; j--)
1820 {
1821 x = corner[j].x;
1822 y = corner[j].y;
1823 intensity = corner[j].intensity;
1824 *(__IO uint16_t*)(pDestination - 2 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color;
1825 *(__IO uint16_t*)(pDestination - 2 * (x + (y * hgfx->ImageHeight))) = (intensity << 8) + color;
1826 }
1827 }
1828 }
1829
1830
1831
1832
1833 /**
1834 ******************************************************************************
1835 * @brief GFX write label. / Write string with defined color
1836 * @author heinrichs weikamp gmbh
1837 * @version V0.0.1
1838 * @date 07-July-2014
1839 ******************************************************************************
1840 *
1841 * @param hgfx: check gfx_engine.h.
1842 * @param color: 16bit Alpha+CLUT.
1843 * @retval None
1844 */
1845
1846 uint32_t GFX_write_label(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint8_t color)
1847 {
1848 return GFX_write_string_color(Font, hgfx, pText, 0, color);
1849 }
1850
1851
1852 /**
1853 ******************************************************************************
1854 * @brief GFX writeGfx_write_label_varstring. / Write string with all parameters and font color options
1855 * @author Peter Ryser
1856 * @version V0.0.1
1857 * @date 22-April-2014
1858 ******************************************************************************
1859 *
1860 * @param XleftGimpStyle:
1861 * @param XrightGimpStyle:
1862 * @param YtopGimpStyle:
1863 * @param color:
1864 * @param tFont:
1865 * @param text: text to be printed
1866 * @retval None
1867 */
1868
1869 void Gfx_write_label_var(GFX_DrawCfgScreen *screenInput, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, const tFont *Font, const uint8_t color, const char *text)
1870 {
1871
1872 GFX_DrawCfgWindow hgfx;
1873
1874 if(XrightGimpStyle > 799)
1875 XrightGimpStyle = 799;
1876 if(XleftGimpStyle >= XrightGimpStyle)
1877 XleftGimpStyle = 0;
1878 if(YtopGimpStyle > 479)
1879 YtopGimpStyle = 479;
1880 hgfx.Image = screenInput;
1881 hgfx.WindowNumberOfTextLines = 1;
1882 hgfx.WindowLineSpacing = 0;
1883 hgfx.WindowTab = 0;
1884 hgfx.WindowX0 = XleftGimpStyle;
1885 hgfx.WindowX1 = XrightGimpStyle;
1886 hgfx.WindowY1 = 479 - YtopGimpStyle;
1887 if(hgfx.WindowY1 < Font->height)
1888 hgfx.WindowY0 = 0;
1889 else
1890 hgfx.WindowY0 = hgfx.WindowY1 - Font->height;
1891
1892 GFX_write_label(Font, &hgfx, text, color);
1893 }
1894
1895 /**
1896 ******************************************************************************
1897 * @brief GFX write string. / Write string with all parameters and font options
1898 * @author heinrichs weikamp gmbh
1899 * @version V0.0.1
1900 * @date 22-April-2014
1901 ******************************************************************************
1902 *
1903 * @param hgfx: check gfx_engine.h.
1904 * @param color: 32bit ARGB8888.
1905 * @retval None
1906 */
1907
1908 uint16_t GFX_return_offset(const tFont *Font, char *pText, uint8_t position)
1909 {
1910 char character;
1911 uint16_t digit, i;
1912 uint8_t found;
1913 uint16_t distance;
1914
1915 if(position == 0)
1916 return 0;
1917
1918 distance = 0;
1919 for(digit = 0; digit < position; digit++)
1920 {
1921 character = pText[digit];
1922 if(character == 0)
1923 return 0;
1924
1925 found = 0;
1926 for(i=0;i<Font->length;i++)
1927 {
1928 if(Font->chars[i].code == character)
1929 {
1930 found = 1;
1931 break;
1932 }
1933 }
1934 if(found)
1935 {
1936 distance += (uint16_t)(Font->chars[i].image->width);
1937 if(Font == &FontT144)
1938 distance += 3;
1939 else
1940 if(Font == &FontT105)
1941 distance += 2;
1942 }
1943 }
1944 return distance;
1945
1946 /* FEHLT:
1947 if(*pText < ' ')
1948 if((*pText) & 0x80)
1949
1950 if(((tFont *)settings.font == &FontT105) && settings.dualFont && ((*pText == '.') || (*pText == ':')))
1951 settings.font = (uint32_t)&FontT54;
1952 */
1953 }
1954
1955 void GFX_clean_line(GFX_DrawCfgWindow* hgfx, uint32_t line_number)
1956 {
1957 uint16_t height;
1958 uint32_t pDestination, i, j;
1959 uint16_t left, width, bottom, nextlineStep;
1960
1961 bottom = hgfx->WindowY0;
1962
1963 if(hgfx->WindowNumberOfTextLines && line_number && (line_number <= hgfx->WindowNumberOfTextLines))
1964 {
1965 bottom += hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number);
1966 height = hgfx->WindowLineSpacing;
1967 }
1968 else
1969 {
1970 height = 1 + hgfx->WindowY1 - bottom;
1971 }
1972
1973 pDestination = (uint32_t)hgfx->Image->FBStartAdress;
1974
1975 left = hgfx->WindowX0;
1976 width = 1 + hgfx->WindowX1 - left;
1977 nextlineStep = hgfx->Image->ImageHeight - height;
1978 nextlineStep *= 2;
1979 pDestination += 2 * bottom;
1980 pDestination += 2 * hgfx->Image->ImageHeight * left;
1981
1982 for(j = width; j > 0; j--)
1983 {
1984 for(i = height; i > 0; i--)
1985 {
1986 *(__IO uint16_t*)pDestination = 0;
1987 pDestination += 2;
1988 }
1989 pDestination += nextlineStep;
1990 }
1991 }
1992
1993
1994 void GFX_clean_area(GFX_DrawCfgScreen *tMscreen, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, uint16_t YBottomGimpStyle)
1995 {
1996 uint16_t height;
1997 uint32_t pDestination, i, j;
1998 int32_t left, width, bottom, nextlineStep;
1999
2000 bottom = tMscreen->ImageHeight - YBottomGimpStyle;
2001 height = 1 + YBottomGimpStyle - YtopGimpStyle;
2002
2003 if(bottom < 0)
2004 bottom = 0;
2005 if(height > tMscreen->ImageHeight)
2006 height = tMscreen->ImageHeight;
2007
2008 pDestination = tMscreen->FBStartAdress;
2009
2010 left = XleftGimpStyle;
2011 width = 1 + XrightGimpStyle - left;
2012 if(width < 1)
2013 width = 1;
2014
2015 if(width > tMscreen->ImageWidth)
2016 width = tMscreen->ImageWidth;
2017
2018 nextlineStep = tMscreen->ImageHeight - height;
2019 nextlineStep *= 2;
2020 pDestination += 2 * bottom;
2021 pDestination += 2 * tMscreen->ImageHeight * left;
2022
2023 for(j = width; j > 0; j--)
2024 {
2025 for(i = height; i > 0; i--)
2026 {
2027 *(__IO uint16_t*)pDestination = 0;
2028 pDestination += 2;
2029 }
2030 pDestination += nextlineStep;
2031 }
2032 }
2033
2034
2035 uint32_t GFX_write_string(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint32_t line_number)
2036 {
2037 return GFX_write_string_color(Font, hgfx, pText, line_number, 0);
2038 }
2039
2040 uint32_t GFX_write_string_color(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint32_t line_number, uint8_t color)
2041 {
2042 if(hgfx->Image->FBStartAdress < FBGlobalStart)
2043 return 0;
2044
2045 GFX_CfgWriteString settings;
2046 uint32_t newXdelta;
2047 uint8_t minimal = 0;
2048 // uint32_t try_again;
2049
2050 if(hgfx->WindowNumberOfTextLines && line_number && (line_number <= hgfx->WindowNumberOfTextLines))
2051 {
2052 settings.Ydelta = hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number);
2053 }
2054 else
2055 {
2056 settings.Ydelta = 0;
2057 }
2058 settings.font = (uint32_t)Font;
2059 settings.Xdelta = 0;
2060 settings.color = color;
2061 settings.invert = 0;
2062 settings.resize = 0;
2063 settings.dualFont = 0;
2064 settings.spaceMode = 0;
2065 settings.singleSpaceWithSizeOfNextChar = 0;
2066 settings.useTinyFont = 0;
2067 settings.TinyFontExtraYdelta = 0;
2068 settings.TinyFont = (uint32_t)Font;
2069 settings.doubleSize = 0;
2070
2071 if((*pText) == TXT_MINIMAL) // for customtext and anything with Sonderzeichen
2072 minimal = 1;
2073 else
2074 minimal = 0;
2075
2076 if(Font == &FontT144)
2077 settings.TinyFont = (uint32_t)&FontT84;
2078 else
2079 if(Font == &FontT105)
2080 settings.TinyFont = (uint32_t)&FontT54;
2081 else
2082 if(Font == &FontT54)
2083 {
2084 settings.TinyFont = (uint32_t)&FontT48;
2085 settings.TinyFontExtraYdelta = -9;
2086 }
2087 else
2088 if(Font == &FontT48)
2089 {
2090 settings.TinyFont = (uint32_t)&FontT24;
2091 settings.TinyFontExtraYdelta = 6;
2092 }
2093 else
2094 if(Font == &FontT42)
2095 {
2096 settings.TinyFont = (uint32_t)&FontT24;
2097 settings.TinyFontExtraYdelta = 2;
2098 }
2099
2100 settings.actualFont = (tFont *)settings.font;
2101
2102 while ((*pText != 0) && (settings.Xdelta != 0x0000FFFF))// und fehlend: Abfrage window / image size
2103 {
2104 // try_again = 0;
2105
2106 if((*pText == '\177') && !minimal)
2107 {
2108 if(settings.singleSpaceWithSizeOfNextChar)
2109 {
2110 settings.singleSpaceWithSizeOfNextChar = 0;
2111 pText++;
2112 settings.Xdelta += *pText;
2113 }
2114 else
2115 settings.singleSpaceWithSizeOfNextChar = 1;
2116 }
2117 else
2118 if(*pText < ' ')
2119 {
2120 /* Xdelta -inline- changes */
2121 if((*pText == '\t') && !minimal)
2122 settings.Xdelta = hgfx->WindowTab - hgfx->WindowX0;
2123 else
2124 if(*pText == '\r') // carriage return, no newline
2125 settings.Xdelta = 0;
2126 else
2127 if((*pText == '\001') && !minimal) // center
2128 settings.Xdelta = GFX_write__Modify_Xdelta__Centered(&settings, hgfx, pText+1);
2129 else
2130 if((*pText == '\002') && !minimal) // right
2131 settings.Xdelta = GFX_write__Modify_Xdelta__RightAlign(&settings, hgfx, pText+1);
2132 else
2133 if((*pText == '\003') && !minimal) // doubleSize
2134 settings.doubleSize = 1;
2135 else
2136 /* Xdelta -up/down changes */
2137 if((*pText == '\f') && !minimal) // form feed = top align
2138 {
2139 if((hgfx->WindowY1 - hgfx->WindowY0) >= ((tFont *)settings.font)->height)
2140 {
2141 settings.Ydelta = hgfx->WindowY1 - hgfx->WindowY0;
2142 settings.Ydelta -= ((tFont *)settings.font)->height;
2143 }
2144 }
2145 else
2146 if(*pText == '\n') // newline, no carriage return
2147 {
2148 if(hgfx->WindowNumberOfTextLines && (line_number < hgfx->WindowNumberOfTextLines))
2149 {
2150 line_number++;
2151 settings.Ydelta = hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number);
2152 }
2153 }
2154 else
2155 /* Font style changes */
2156 if(*pText == '\a')
2157 settings.invert = 1;
2158 else
2159 if((*pText == '\016') && !minimal)
2160 {
2161 if(settings.dualFont == 0)
2162 settings.dualFont = 1;
2163 else
2164 settings.actualFont = (tFont *)settings.TinyFont;
2165 }
2166 else
2167 if((*pText == '\017') && !minimal)
2168 {
2169 settings.dualFont = 0;
2170 settings.actualFont = (tFont *)settings.font;
2171 }
2172 else
2173 if((*pText == '\005') && !minimal)
2174 {
2175 newXdelta = GFX_write_char(hgfx, &settings, 'a', (tFont *)&Awe48);
2176 settings.Xdelta = newXdelta;
2177 }
2178 else
2179 if((*pText == '\006') && !minimal)
2180 {
2181 newXdelta = GFX_write_char(hgfx, &settings, 'b', (tFont *)&Awe48);
2182 settings.Xdelta = newXdelta;
2183 }
2184 else
2185 if((*pText >= '\020') && (*pText <= '\032') && !minimal)
2186 settings.color = *pText - '\020';
2187 else
2188 if((*pText == '\034') && !minimal)
2189 settings.spaceMode = 1;
2190 else
2191 if((*pText == '\035') && !minimal)
2192 settings.spaceMode = 0;
2193 }
2194 else
2195 if(((*pText) == TXT_2BYTE) && !minimal)
2196 {
2197 pText++;
2198 settings.Xdelta = GFX_write_substring(&settings, hgfx, (uint8_t)TXT_2BYTE, (int8_t)*pText);
2199 }
2200 else
2201 if(((*pText) & 0x80) && !minimal)
2202 settings.Xdelta = GFX_write_substring(&settings, hgfx, (uint8_t)*pText, 0);
2203 else
2204 if(!settings.invert && (*pText == ' '))
2205 {
2206 if(settings.spaceMode == 0)
2207 settings.Xdelta += ((tFont *)settings.font)->spacesize;
2208 else
2209 settings.Xdelta += ((tFont *)settings.font)->spacesize2Monospaced;
2210 }
2211 else
2212 if((settings.spaceMode == 1) && (*pText == ' '))
2213 settings.Xdelta += ((tFont *)settings.font)->spacesize2Monospaced;
2214 else
2215 {
2216 if(((tFont *)settings.font == &FontT144) && ((*pText == '.') || (*pText == ':')))
2217 settings.actualFont = (tFont *)settings.TinyFont;
2218 else
2219 if(((tFont *)settings.font == &FontT105) && settings.dualFont && ((*pText == '.') || (*pText == ':')))
2220 settings.actualFont = (tFont *)settings.TinyFont;
2221
2222 if(settings.actualFont == (tFont *)settings.TinyFont)
2223 settings.Ydelta += settings.TinyFontExtraYdelta;
2224
2225 newXdelta = GFX_write_char(hgfx, &settings, *(uint8_t *)pText, settings.actualFont);
2226 settings.Xdelta = newXdelta;
2227
2228 if(settings.actualFont == (tFont *)settings.TinyFont)
2229 settings.Ydelta -= settings.TinyFontExtraYdelta;
2230 }
2231 if(pText != 0) /* for TXT_2BYTE */
2232 pText++;
2233 }
2234 return settings.Ydelta;
2235 }
2236
2237 /* Private functions ---------------------------------------------------------*/
2238 /******************************************************************************
2239 Static Function
2240 *******************************************************************************/
2241
2242 /**
2243 ******************************************************************************
2244 * @brief GFX write substring. / Write string without parameters
2245 * @author heinrichs weikamp gmbh
2246 * @version V0.0.1
2247 * @date 22-April-2014
2248 ******************************************************************************
2249 *
2250 * @param hgfx: check gfx_engine.h.
2251 * @param color: 32bit ARGB8888.
2252 * @retval None
2253 */
2254
2255 static uint32_t GFX_write_substring(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, uint8_t textId, int8_t nextCharFor2Byte)
2256 {
2257 uint8_t i, j;
2258 uint32_t found;
2259 uint32_t pText;
2260 uint8_t gfx_selected_language;
2261 #ifndef BOOTLOADER_STANDALONE
2262 SSettings *pSettings;
2263 pSettings = settingsGetPointer();
2264 gfx_selected_language = pSettings->selected_language;
2265 if(gfx_selected_language >= LANGUAGE_END)
2266 #endif
2267 gfx_selected_language = 0;
2268 // -----------------------------
2269 if(textId != (uint8_t)TXT_2BYTE)
2270 {
2271 found = 0;
2272 j = 0;
2273 for(i=(uint8_t)TXT_Language;i<(uint8_t)TXT_END;i++)
2274 {
2275 if(text_array[j].code == textId)
2276 {
2277 found = 1;
2278 break;
2279 }
2280 j++;
2281 }
2282 if(!found)
2283 return cfg->Xdelta;
2284 // -----------------------------
2285 pText = (uint32_t)text_array[j].text[gfx_selected_language];
2286 if(!pText)
2287 pText = (uint32_t)text_array[j].text[0];
2288 else
2289 if(*(char*)pText == 0)
2290 pText = (uint32_t)text_array[j].text[0];
2291 }
2292 // -----------------------------
2293 else
2294 {
2295 if(!nextCharFor2Byte)
2296 return cfg->Xdelta;
2297
2298 found = 0;
2299 for(j=0;j<(uint8_t)TXT2BYTE_END-(uint8_t)TXT2BYTE_START;j++)
2300 {
2301 if((uint8_t)text_array2[j].code == (uint8_t)nextCharFor2Byte)
2302 {
2303 found = 1;
2304 break;
2305 }
2306 }
2307 if(!found)
2308 return cfg->Xdelta;
2309 // -----------------------------
2310 pText = (uint32_t)text_array2[j].text[gfx_selected_language];
2311 if(!pText)
2312 pText = (uint32_t)text_array2[j].text[0];
2313 else
2314 if(*(char*)pText == 0)
2315 pText = (uint32_t)text_array2[j].text[0];
2316 }
2317 // -----------------------------
2318
2319 if(cfg->actualFont == (tFont *)cfg->TinyFont)
2320 cfg->Ydelta += cfg->TinyFontExtraYdelta;
2321
2322 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size
2323 {
2324 if(*(char*)pText == '\t')
2325 cfg->Xdelta = hgfx->WindowTab - hgfx->WindowX0;
2326 else
2327 if(*(char*)pText == ' ')
2328 cfg->Xdelta += ((tFont *)cfg->actualFont)->spacesize;
2329 else
2330 cfg->Xdelta = GFX_write_char(hgfx, cfg, *(uint8_t *)pText, (tFont *)cfg->actualFont);
2331
2332 pText++;
2333 }
2334
2335 if(cfg->actualFont == (tFont *)cfg->TinyFont)
2336 cfg->Ydelta -= cfg->TinyFontExtraYdelta;
2337
2338 return cfg->Xdelta;
2339 }
2340
2341
2342 /**
2343 ******************************************************************************
2344 * @brief GFX write char. / Write non-inverted, non-colored with entire 8 bit range
2345 * @author heinrichs weikamp gmbh
2346 * @version V0.0.1
2347 * @date 22-April-2014
2348 ******************************************************************************
2349 *
2350 * @param hgfx: check gfx_engine.h.
2351 * @param Ydelta: input
2352 * @param character: character
2353 * @param *Font: pointer to font to be used for this char
2354 * @retval Ydelta: 0x0000FFFF if not successful or char_truncated
2355 */
2356
2357 static uint32_t GFX_write_char_doubleSize(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font)
2358 {
2359 uint32_t i, j;
2360 uint32_t width, height;
2361 uint32_t found;
2362 uint32_t pDestination;
2363 uint32_t pDestinationColor;
2364 uint32_t pSource;
2365 uint32_t OffsetDestination;
2366 uint32_t width_left;
2367 uint32_t height_left;
2368 uint32_t char_truncated_WidthFlag;
2369 uint32_t char_truncated_Height;
2370 uint8_t fill;
2371 uint32_t widthFont, heightFont;
2372 uint32_t nextLine;
2373
2374
2375 if(hgfx->Image->ImageWidth <= (hgfx->WindowX0 + cfg->Xdelta))
2376 return 0x0000FFFF;
2377
2378 // -----------------------------
2379 found = 0;
2380 for(i=0;i<Font->length;i++)
2381 {
2382 if(Font->chars[i].code == character)
2383 {
2384 found = 1;
2385 break;
2386 }
2387 }
2388 if(!found)
2389 return cfg->Xdelta;
2390
2391 pSource = ((uint32_t)Font->chars[i].image->data);
2392 pDestination = 1 + (uint32_t)hgfx->Image->FBStartAdress;
2393
2394 heightFont = Font->chars[i].image->height;
2395 widthFont = Font->chars[i].image->width;
2396
2397 height = heightFont*2;
2398 width = widthFont*2;
2399
2400 OffsetDestination = 2 * (hgfx->Image->ImageHeight - height);
2401
2402 pDestination += (hgfx->WindowX0 + cfg->Xdelta) * hgfx->Image->ImageHeight * 2;
2403 pDestination += (hgfx->WindowY0 + cfg->Ydelta) * 2;
2404 nextLine = hgfx->Image->ImageHeight * 2;
2405
2406 // -----------------------------
2407 char_truncated_WidthFlag = 0;
2408 width_left = hgfx->Image->ImageWidth - (hgfx->WindowX0 + cfg->Xdelta);
2409 if(width_left < width)
2410 {
2411 char_truncated_WidthFlag = 1;
2412 width = width_left;
2413 widthFont = width/2;
2414 }
2415 // -----------------------------
2416 char_truncated_Height = 0;
2417 height_left = hgfx->Image->ImageHeight - (hgfx->WindowY0 + cfg->Ydelta);
2418 if(height_left < height)
2419 {
2420 char_truncated_Height = height - height_left;
2421 if((char_truncated_Height & 1) != 0)
2422 {
2423 height_left -= 1;
2424 char_truncated_Height += 1;
2425 }
2426 height = height_left;
2427 heightFont = height/2;
2428 }
2429 OffsetDestination += 2 * char_truncated_Height;
2430 // -----------------------------
2431 if(height == 0)
2432 return 0x0000FFFF;
2433 // -----------------------------
2434
2435 if((cfg->color > 0) )
2436 {
2437 pDestinationColor = pDestination - 1;
2438
2439 for(i = width; i > 0; i--)
2440 {
2441 for (j = height; j > 0; j--)
2442 {
2443 *(__IO uint32_t*)pDestinationColor = cfg->color;
2444 pDestinationColor += 2;
2445 }
2446 pDestinationColor += OffsetDestination;
2447 }
2448 }
2449
2450 if(cfg->singleSpaceWithSizeOfNextChar)
2451 {
2452 cfg->singleSpaceWithSizeOfNextChar = 0;
2453
2454 if(cfg->invert)
2455 fill = 0xFF;
2456 else
2457 fill = 0;
2458
2459 height /= 2;
2460 for(i = width; i > 0; i--)
2461 {
2462 for (j = height; j > 0; j--)
2463 {
2464 *(__IO uint8_t*)pDestination = fill;
2465 pDestination += 2;
2466 *(__IO uint8_t*)pDestination = fill;
2467 pDestination += 2;
2468 }
2469 pDestination += OffsetDestination;
2470 }
2471 }
2472 else
2473 if(cfg->invert)
2474 {
2475 if((heightFont & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */
2476 {
2477 heightFont /= 4;
2478 for(i = widthFont; i > 0; i--)
2479 {
2480 if(*(uint8_t*)pSource != 0x01)
2481 {
2482 for (j = heightFont; j > 0; j--)
2483 {
2484 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2485 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2486 pDestination += 2;
2487 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2488 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2489 pSource++;
2490 pDestination += 2;
2491
2492 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2493 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2494 pDestination += 2;
2495 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2496 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2497 pSource++;
2498 pDestination += 2;
2499
2500 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2501 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2502 pDestination += 2;
2503 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2504 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2505 pSource++;
2506 pDestination += 2;
2507
2508 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2509 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2510 pDestination += 2;
2511 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2512 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2513 pSource++;
2514 pDestination += 2;
2515 }
2516 pSource += char_truncated_Height;
2517 }
2518 else
2519 {
2520 pSource++;
2521 for (j = height; j > 0; j--)
2522 {
2523 *(__IO uint8_t*)pDestination = 0xFF;
2524 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2525 pDestination += 2;
2526 *(__IO uint8_t*)pDestination = 0xFF;
2527 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2528 pDestination += 2;
2529 *(__IO uint8_t*)pDestination = 0xFF;
2530 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2531 pDestination += 2;
2532 *(__IO uint8_t*)pDestination = 0xFF;
2533 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2534 pDestination += 2;
2535 *(__IO uint8_t*)pDestination = 0xFF;
2536 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2537 pDestination += 2;
2538 *(__IO uint8_t*)pDestination = 0xFF;
2539 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2540 pDestination += 2;
2541 *(__IO uint8_t*)pDestination = 0xFF;
2542 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2543 pDestination += 2;
2544 *(__IO uint8_t*)pDestination = 0xFF;
2545 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2546 pDestination += 2;
2547 }
2548 }
2549 pDestination += OffsetDestination + nextLine;
2550 }
2551 }
2552 else
2553 {
2554 heightFont /= 2;
2555 for(i = widthFont; i > 0; i--)
2556 {
2557 if(*(uint8_t*)pSource != 0x01)
2558 {
2559 for (j = heightFont; j > 0; j--)
2560 {
2561 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2562 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2563 pDestination += 2;
2564 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2565 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2566 pSource++;
2567 pDestination += 2;
2568
2569 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2570 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2571 pDestination += 2;
2572 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2573 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF - *(uint8_t*)pSource;
2574 pSource++;
2575 pDestination += 2;
2576 }
2577 pSource += char_truncated_Height;
2578 }
2579 else
2580 {
2581 pSource++;
2582 for (j = heightFont; j > 0; j--)
2583 {
2584 *(__IO uint8_t*)pDestination = 0xFF;
2585 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2586 pDestination += 2;
2587 *(__IO uint8_t*)pDestination = 0xFF;
2588 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2589 pDestination += 2;
2590 *(__IO uint8_t*)pDestination = 0xFF;
2591 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2592 pDestination += 2;
2593 *(__IO uint8_t*)pDestination = 0xFF;
2594 *(__IO uint8_t*)(pDestination + nextLine) = 0xFF;
2595 pDestination += 2;
2596 }
2597 }
2598 pDestination += OffsetDestination + nextLine;
2599 }
2600 }
2601 }
2602 else
2603 {
2604 if((heightFont & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */
2605 {
2606 heightFont /= 4;
2607 for(i = widthFont; i > 0; i--)
2608 {
2609 if(*(uint8_t*)pSource != 0x01)
2610 {
2611 for (j = heightFont; j > 0; j--)
2612 {
2613 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2614 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2615 pDestination += 2;
2616 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2617 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2618 pSource++;
2619 pDestination += 2;
2620
2621 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2622 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2623 pDestination += 2;
2624 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2625 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2626 pSource++;
2627 pDestination += 2;
2628
2629 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2630 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2631 pDestination += 2;
2632 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2633 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2634 pSource++;
2635 pDestination += 2;
2636
2637 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2638 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2639 pDestination += 2;
2640 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2641 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2642 pSource++;
2643 pDestination += 2;
2644 }
2645 pSource += char_truncated_Height;
2646 }
2647 else
2648 {
2649 pSource++;
2650 pDestination += 2 * height;
2651 }
2652 pDestination += OffsetDestination + nextLine;
2653 }
2654 }
2655 else
2656 {
2657 heightFont /= 2;
2658 for(i = widthFont; i > 0; i--)
2659 {
2660 if(*(uint8_t*)pSource != 0x01)
2661 {
2662 for (j = heightFont; j > 0; j--)
2663 {
2664 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2665 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2666 pDestination += 2;
2667 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2668 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2669 pSource++;
2670 pDestination += 2;
2671
2672 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2673 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2674 pDestination += 2;
2675 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2676 *(__IO uint8_t*)(pDestination + nextLine) = *(uint8_t*)pSource;
2677 pSource++;
2678 pDestination += 2;
2679 }
2680 pSource += char_truncated_Height;
2681 }
2682 else
2683 {
2684 pSource++;
2685 pDestination += 2 * height;
2686 }
2687 pDestination += OffsetDestination + nextLine;
2688 }
2689 }
2690 }
2691
2692 // -----------------------------
2693
2694 if(Font == &FontT144)
2695 width += 6;
2696 else
2697 if(Font == &FontT105)
2698 width += 4;
2699
2700 // -----------------------------
2701
2702 if(char_truncated_WidthFlag)
2703 return 0x0000FFFF;
2704 else
2705 return cfg->Xdelta + width;
2706
2707 }
2708
2709
2710 /**
2711 ******************************************************************************
2712 * @brief GFX write char. / Write non-inverted, non-colored with entire 8 bit range
2713 * @author heinrichs weikamp gmbh
2714 * @version V0.0.1
2715 * @date 22-April-2014
2716 ******************************************************************************
2717 *
2718 * @param hgfx: check gfx_engine.h.
2719 * @param Ydelta: input
2720 * @param character: character
2721 * @param *Font: pointer to font to be used for this char
2722 * @retval Ydelta: 0x0000FFFF if not successful or char_truncated
2723 */
2724
2725 static uint32_t GFX_write_char(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font)
2726 {
2727 if(cfg->doubleSize)
2728 {
2729 return GFX_write_char_doubleSize(hgfx, cfg, character, Font);
2730 }
2731
2732 uint32_t i, j;
2733 uint32_t width, height;
2734 uint32_t found;
2735 uint32_t pDestination;
2736 uint32_t pDestinationColor;
2737 uint32_t pSource;
2738 uint32_t OffsetDestination;
2739 uint32_t width_left;
2740 uint32_t height_left;
2741 uint32_t char_truncated_WidthFlag;
2742 uint32_t char_truncated_Height;
2743 uint8_t fill;
2744
2745 if(hgfx->Image->ImageWidth <= (hgfx->WindowX0 + cfg->Xdelta))
2746 return 0x0000FFFF;
2747
2748 // -----------------------------
2749 found = 0;
2750 for(i=0;i<Font->length;i++)
2751 {
2752 if(Font->chars[i].code == character)
2753 {
2754 found = 1;
2755 break;
2756 }
2757 }
2758 if(!found)
2759 return cfg->Xdelta;
2760 // -----------------------------
2761 /*
2762 if(Font == &Font144)
2763 cfg->Xdelta += 3;
2764 else
2765 if(Font == &Font84)
2766 cfg->Xdelta += 2;
2767 */
2768 // -----------------------------
2769
2770
2771 pSource = ((uint32_t)Font->chars[i].image->data);
2772 pDestination = 1 + (uint32_t)hgfx->Image->FBStartAdress;
2773
2774 height = Font->chars[i].image->height;
2775 width = Font->chars[i].image->width;
2776
2777 OffsetDestination = 2 * (hgfx->Image->ImageHeight - height);
2778
2779 pDestination += (hgfx->WindowX0 + cfg->Xdelta) * hgfx->Image->ImageHeight * 2;
2780 pDestination += (hgfx->WindowY0 + cfg->Ydelta) * 2;
2781
2782
2783
2784 // -----------------------------
2785 char_truncated_WidthFlag = 0;
2786 width_left = hgfx->Image->ImageWidth - (hgfx->WindowX0 + cfg->Xdelta);
2787 if(width_left < width)
2788 {
2789 char_truncated_WidthFlag = 1;
2790 width = width_left;
2791 }
2792 // -----------------------------
2793 char_truncated_Height = 0;
2794 height_left = hgfx->Image->ImageHeight - (hgfx->WindowY0 + cfg->Ydelta);
2795 if(height_left < height)
2796 {
2797 char_truncated_Height = height - height_left;
2798 if((char_truncated_Height & 1) != 0)
2799 {
2800 height_left -= 1;
2801 char_truncated_Height += 1;
2802 }
2803 height = height_left;
2804 }
2805 OffsetDestination += 2 * char_truncated_Height;
2806 // -----------------------------
2807 if(height == 0)
2808 return 0x0000FFFF;
2809 // -----------------------------
2810
2811 if((cfg->color > 0) )//&& (cfg->color < 6))
2812 {
2813 pDestinationColor = pDestination - 1;
2814
2815 for(i = width; i > 0; i--)
2816 {
2817 for (j = height; j > 0; j--)
2818 {
2819 *(__IO uint32_t*)pDestinationColor = cfg->color;//ColorLUT[cfg->color - 1];
2820 pDestinationColor += 2;
2821 }
2822 pDestinationColor += OffsetDestination;
2823 }
2824 }
2825
2826 if(cfg->singleSpaceWithSizeOfNextChar)
2827 {
2828 cfg->singleSpaceWithSizeOfNextChar = 0;
2829
2830 if(cfg->invert)
2831 fill = 0xFF;
2832 else
2833 fill = 0;
2834
2835 height /= 2;
2836 for(i = width; i > 0; i--)
2837 {
2838 for (j = height; j > 0; j--)
2839 {
2840 *(__IO uint8_t*)pDestination = fill;
2841 pDestination += 2;
2842 *(__IO uint8_t*)pDestination = fill;
2843 pDestination += 2;
2844 }
2845 pDestination += OffsetDestination;
2846 }
2847 }
2848 else
2849 if(cfg->invert)
2850 {
2851 if((height & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */
2852 {
2853 height /= 4;
2854 for(i = width; i > 0; i--)
2855 {
2856 if(*(uint8_t*)pSource != 0x01)
2857 {
2858 for (j = height; j > 0; j--)
2859 {
2860 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2861 pSource++;
2862 pDestination += 2;
2863 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2864 pSource++;
2865 pDestination += 2;
2866 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2867 pSource++;
2868 pDestination += 2;
2869 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2870 pSource++;
2871 pDestination += 2;
2872 }
2873 pSource += char_truncated_Height;
2874 }
2875 else
2876 {
2877 pSource++;
2878 for (j = height; j > 0; j--)
2879 {
2880 *(__IO uint8_t*)pDestination = 0xFF;
2881 pDestination += 2;
2882 *(__IO uint8_t*)pDestination = 0xFF;
2883 pDestination += 2;
2884 *(__IO uint8_t*)pDestination = 0xFF;
2885 pDestination += 2;
2886 *(__IO uint8_t*)pDestination = 0xFF;
2887 pDestination += 2;
2888 }
2889 }
2890 pDestination += OffsetDestination;
2891 }
2892 }
2893 else
2894 {
2895 height /= 2;
2896 for(i = width; i > 0; i--)
2897 {
2898 if(*(uint8_t*)pSource != 0x01)
2899 {
2900 for (j = height; j > 0; j--)
2901 {
2902 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2903 pSource++;
2904 pDestination += 2;
2905 *(__IO uint8_t*)pDestination = 0xFF - *(uint8_t*)pSource;
2906 pSource++;
2907 pDestination += 2;
2908 }
2909 pSource += char_truncated_Height;
2910 }
2911 else
2912 {
2913 pSource++;
2914 for (j = height; j > 0; j--)
2915 {
2916 *(__IO uint8_t*)pDestination = 0xFF;
2917 pDestination += 2;
2918 *(__IO uint8_t*)pDestination = 0xFF;
2919 pDestination += 2;
2920 }
2921 }
2922 pDestination += OffsetDestination;
2923 }
2924 }
2925 }
2926 else
2927 {
2928 if((height & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */
2929 {
2930 height /= 4;
2931 for(i = width; i > 0; i--)
2932 {
2933 if(*(uint8_t*)pSource != 0x01)
2934 {
2935 for (j = height; j > 0; j--)
2936 {
2937 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2938 pSource++;
2939 pDestination += 2;
2940 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2941 pSource++;
2942 pDestination += 2;
2943 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2944 pSource++;
2945 pDestination += 2;
2946 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2947 pSource++;
2948 pDestination += 2;
2949 }
2950 pSource += char_truncated_Height;
2951 }
2952 else
2953 {
2954 pSource++;
2955 pDestination += 2 * height * 4;
2956 }
2957 pDestination += OffsetDestination;
2958 }
2959 }
2960 else
2961 {
2962 height /= 2;
2963 for(i = width; i > 0; i--)
2964 {
2965 if(*(uint8_t*)pSource != 0x01)
2966 {
2967 for (j = height; j > 0; j--)
2968 {
2969 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2970 pSource++;
2971 pDestination += 2;
2972 *(__IO uint8_t*)pDestination = *(uint8_t*)pSource;
2973 pSource++;
2974 pDestination += 2;
2975 }
2976 pSource += char_truncated_Height;
2977 }
2978 else
2979 {
2980 pSource++;
2981 pDestination += 2 * height * 2;
2982 }
2983 pDestination += OffsetDestination;
2984 }
2985 }
2986 }
2987
2988 // -----------------------------
2989
2990 if(Font == &FontT144)
2991 width += 3;
2992 else
2993 if(Font == &FontT105)
2994 width += 2;
2995 /*
2996 else
2997 if(Font == &Font144)
2998 width += 3;
2999 else
3000 if(Font == &Font84)
3001 width += 1;
3002 */
3003 // -----------------------------
3004
3005 if(char_truncated_WidthFlag)
3006 return 0x0000FFFF;
3007 else
3008 return cfg->Xdelta + width;
3009 }
3010
3011
3012 /**
3013 ******************************************************************************
3014 * @brief GFX write Modify helper for center and right align.
3015 * @author heinrichs weikamp gmbh
3016 * @version V0.0.1
3017 * @date 17-March-2015
3018 ******************************************************************************
3019 *
3020 * @param *cText: output
3021 * @param *pTextInput: input
3022 * @param gfx_selected_language: gfx_selected_language
3023 * @retval counter and *cText content
3024 */
3025 int8_t GFX_write__Modify_helper(char *cText, const char *pTextInput, uint8_t gfx_selected_language)
3026 {
3027 uint32_t pText, backup;
3028 uint8_t textId;
3029 int8_t counter;
3030 uint32_t found;
3031 uint32_t j;
3032
3033 pText = (uint32_t)pTextInput;
3034 counter = 0;
3035 while((counter < 100) && (*(char*)pText != 0) && (*(char*)pText != '\r'))
3036 {
3037 if((*(char*)pText) == TXT_2BYTE)
3038 {
3039 backup = pText;
3040
3041 found = 0;
3042 j = 0;
3043 textId = (int8_t)*(char*)(pText + 1);
3044 if(textId != 0)
3045 {
3046 for(j=0;j<(uint8_t)TXT2BYTE_END-(uint8_t)TXT2BYTE_START;j++)
3047 {
3048 if((uint8_t)text_array2[j].code == (uint8_t)textId)
3049 {
3050 found = 1;
3051 break;
3052 }
3053 }
3054 if(found)
3055 {
3056 pText = (uint32_t)text_array2[j].text[gfx_selected_language];
3057 if(!pText)
3058 pText = (uint32_t)text_array2[j].text[0];
3059 else
3060 if(*(char*)pText == 0)
3061 pText = (uint32_t)text_array2[j].text[0];
3062
3063 while((counter < 100) && (*(char*)pText != 0))
3064 cText[counter++] = *(char*)pText++;
3065 }
3066 pText = backup + 2;
3067 }
3068 else
3069 pText = 0;
3070 }
3071 if((*(char*)pText) & 0x80)
3072 {
3073 backup = pText;
3074
3075 found = 0;
3076 j = 0;
3077 textId = (uint8_t)*(char*)pText;
3078 for(uint8_t ii=(uint8_t)TXT_Language;ii<(uint8_t)TXT_END;ii++)
3079 {
3080 if(text_array[j].code == textId)
3081 {
3082 found = 1;
3083 break;
3084 }
3085 j++;
3086 }
3087 if(found)
3088 {
3089 pText = (uint32_t)text_array[j].text[gfx_selected_language];
3090 if(!pText)
3091 pText = (uint32_t)text_array[j].text[0];
3092 else
3093 if(*(char*)pText == 0)
3094 pText = (uint32_t)text_array[j].text[0];
3095
3096 while((counter < 100) && (*(char*)pText != 0))
3097 cText[counter++] = *(char*)pText++;
3098 }
3099 pText = backup + 1;
3100 }
3101 else
3102 {
3103 cText[counter++] = *(char*)pText++;
3104 }
3105 }
3106 cText[counter] = 0;
3107 return counter;
3108 }
3109
3110
3111 /**
3112 ******************************************************************************
3113 * @brief GFX write Modify Ydelta for align. / calc Ydelta for start
3114 * @author heinrichs weikamp gmbh
3115 * @version V0.0.1
3116 * @date 22-April-2014
3117 ******************************************************************************
3118 *
3119 * @param *hgfx: check gfx_engine.h.
3120 * @param *cfg: Ydelta, Font
3121 * @param *pText: character
3122 * @retval Ydelta: 0 if text has to start left ( and probably does not fit)
3123 */
3124
3125 uint32_t GFX_write__Modify_Xdelta__Centered(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput)
3126 {
3127 char cText[101];
3128 uint32_t result;
3129 uint32_t Xsum;
3130 uint32_t i, j;
3131 uint8_t gfx_selected_language;
3132 uint32_t pText;
3133
3134 #ifndef BOOTLOADER_STANDALONE
3135 SSettings *pSettings;
3136 pSettings = settingsGetPointer();
3137 gfx_selected_language = pSettings->selected_language;
3138 if(gfx_selected_language >= LANGUAGE_END)
3139 #endif
3140 gfx_selected_language = 0;
3141 // -----------------------------
3142
3143 GFX_write__Modify_helper(cText,pTextInput,gfx_selected_language);
3144
3145 pText = (uint32_t)&cText[0];
3146 Xsum = 0;
3147 j = 0;
3148 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size
3149 {
3150 for(i=0;i<((tFont *)cfg->font)->length;i++)
3151 {
3152 if(((tFont *)cfg->font)->chars[i].code == *(char*)pText)
3153 {
3154 Xsum += ((tFont *)cfg->font)->chars[i].image->width;
3155 break;
3156 }
3157 }
3158 pText++;
3159 j++;
3160 if(((tFont *)cfg->font == &FontT144) && (*(char*)pText != 0))
3161 Xsum += 3;
3162 else
3163 if(((tFont *)cfg->font == &FontT105) && (*(char*)pText != 0))
3164 Xsum += 2;
3165 }
3166 pText -= j;
3167
3168 if(cfg->doubleSize)
3169 Xsum *= 2;
3170
3171 result = hgfx->WindowX1 - hgfx->WindowX0;
3172 if(Xsum < result)
3173 {
3174 result -= Xsum;
3175 result /= 2;
3176 }
3177 else
3178 result = 0;
3179 return result;
3180 }
3181
3182
3183 uint32_t GFX_write__Modify_Xdelta__RightAlign(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput)
3184 {
3185 char cText[101];
3186 uint32_t result;
3187 uint32_t Xsum;
3188 uint32_t i, j;
3189 tFont *font;
3190 uint8_t gfx_selected_language;
3191 uint32_t pText;
3192 uint8_t setToTinyFont = 0;
3193
3194 #ifndef BOOTLOADER_STANDALONE
3195 SSettings *pSettings;
3196 pSettings = settingsGetPointer();
3197 gfx_selected_language = pSettings->selected_language;
3198 if(gfx_selected_language >= LANGUAGE_END)
3199 #endif
3200 gfx_selected_language = 0;
3201 // -----------------------------
3202
3203 GFX_write__Modify_helper(cText,pTextInput,gfx_selected_language);
3204 pText = (uint32_t)&cText[0];
3205
3206 // -----------------------------
3207
3208 setToTinyFont = 0;
3209 font = (tFont *)cfg->font;
3210 Xsum = 0;
3211 j = 0;
3212
3213 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size
3214 {
3215 if((font == &FontT144) && (*(char*)pText == '.'))
3216 {
3217 font = (tFont *)&FontT84;
3218 }
3219 else
3220 if((font == &FontT105) && (*(char*)pText == '\16')) // two times to start tiny font
3221 {
3222 if(!setToTinyFont)
3223 setToTinyFont = 1;
3224 else
3225 font = (tFont *)&FontT54;
3226 }
3227 else
3228 if((font == &FontT105) && cfg->dualFont && ((*(char*)pText == '.') || (*(char*)pText == ':')))
3229 {
3230 font = (tFont *)&FontT54;
3231 }
3232
3233 if(*(char*)pText == ' ')
3234 {
3235 Xsum += font->spacesize;
3236 }
3237 else
3238 {
3239 for(i=0;i<font->length;i++)
3240 {
3241 if(font->chars[i].code == *(char*)pText)
3242 {
3243 Xsum += font->chars[i].image->width;
3244 break;
3245 }
3246 }
3247 }
3248 pText++;
3249 j++;
3250 if((font == &FontT144) && (*(char*)pText != 0))
3251 Xsum += 3;
3252 else
3253 if((font == &FontT105) && (*(char*)pText != 0))
3254 Xsum += 2;
3255 }
3256 pText -= j;
3257
3258 if(cfg->doubleSize)
3259 Xsum *= 2;
3260
3261 result = hgfx->WindowX1 - hgfx->WindowX0 - 1;
3262 if(Xsum < result)
3263 result -= Xsum;
3264 else
3265 result = 0;
3266
3267 return result;
3268 }
3269
3270
3271
3272 void GFX_LTDC_Init(void)
3273 {
3274 /*
3275 HSYNC=10 (9+1)
3276 HBP=10 (19-10+1)
3277 ActiveW=480 (499-10-10+1)
3278 HFP=8 (507-480-10-10+1)
3279
3280 VSYNC=2 (1+1)
3281 VBP=2 (3-2+1)
3282 ActiveH=800 (803-2-2+1)
3283 VFP=2 (805-800-2-2+1)
3284 */
3285
3286 /* Timing configuration */
3287 /* Horizontal synchronization width = Hsync - 1 */
3288 LtdcHandle.Init.HorizontalSync = 9;
3289 /* Vertical synchronization height = Vsync - 1 */
3290 LtdcHandle.Init.VerticalSync = 1;
3291 /* Accumulated horizontal back porch = Hsync + HBP - 1 */
3292 LtdcHandle.Init.AccumulatedHBP = 19;
3293 /* Accumulated vertical back porch = Vsync + VBP - 1 */
3294 LtdcHandle.Init.AccumulatedVBP = 3;
3295 /* Accumulated active width = Hsync + HBP + Active Width - 1 */
3296 LtdcHandle.Init.AccumulatedActiveW = 499;//500;//499;
3297 /* Accumulated active height = Vsync + VBP + Active Heigh - 1 */
3298 LtdcHandle.Init.AccumulatedActiveH = 803;
3299 /* Total width = Hsync + HBP + Active Width + HFP - 1 */
3300 LtdcHandle.Init.TotalWidth = 507;//508;//507;
3301 /* Total height = Vsync + VBP + Active Heigh + VFP - 1 */
3302 LtdcHandle.Init.TotalHeigh = 805;
3303
3304 /* Configure R,G,B component values for LCD background color */
3305 LtdcHandle.Init.Backcolor.Red= 0;
3306 LtdcHandle.Init.Backcolor.Blue= 0;
3307 LtdcHandle.Init.Backcolor.Green= 0;
3308
3309 /* LCD clock configuration */
3310 /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
3311 /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */
3312 /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */
3313 /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */
3314
3315 /* done in main.c SystemClockConfig
3316
3317 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
3318 PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;
3319 PeriphClkInitStruct.PLLSAI.PLLSAIR = 4;
3320 PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8;
3321 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
3322 */
3323 /* Polarity */
3324 LtdcHandle.Init.HSPolarity = LTDC_HSPOLARITY_AL;
3325 LtdcHandle.Init.VSPolarity = LTDC_VSPOLARITY_AL;
3326 LtdcHandle.Init.DEPolarity = LTDC_DEPOLARITY_AL;
3327 LtdcHandle.Init.PCPolarity = LTDC_PCPOLARITY_IIPC;//LTDC_PCPOLARITY_IPC;
3328
3329 LtdcHandle.Instance = LTDC;
3330
3331 /* Configure the LTDC */
3332 if(HAL_LTDC_Init(&LtdcHandle) != HAL_OK) // auch init der GPIO Pins
3333 {
3334 /* Initialization Error */
3335 GFX_Error_Handler();
3336 }
3337 }
3338
3339 void GFX_VGA_LTDC_Init_test(void)
3340 {
3341
3342 LtdcHandle.Init.HorizontalSync = 48;
3343 /* Vertical synchronization height = Vsync - 1 */
3344 LtdcHandle.Init.VerticalSync = 3;
3345 /* Accumulated horizontal back porch = Hsync + HBP - 1 */
3346 LtdcHandle.Init.AccumulatedHBP = 48 + 40 - 1;
3347 /* Accumulated vertical back porch = Vsync + VBP - 1 */
3348 LtdcHandle.Init.AccumulatedVBP = 3 + 29 - 1;
3349 /* Accumulated active width = Hsync + HBP + Active Width - 1 */
3350 LtdcHandle.Init.AccumulatedActiveW = 800 + 48 + 40 - 1;//499;//500;//499;
3351 /* Accumulated active height = Vsync + VBP + Active Heigh - 1 */
3352 LtdcHandle.Init.AccumulatedActiveH = 480 + 3 + 29 - 1;
3353 /* Total width = Hsync + HBP + Active Width + HFP - 1 */
3354 LtdcHandle.Init.TotalWidth = 800 + 48 + 40 - 1 + 40;//508;//507;
3355 /* Total height = Vsync + VBP + Active Heigh + VFP - 1 */
3356 LtdcHandle.Init.TotalHeigh = 480 + 3 + 29 - 1 + 13;
3357
3358 /* Configure R,G,B component values for LCD background color */
3359 LtdcHandle.Init.Backcolor.Red= 0;
3360 LtdcHandle.Init.Backcolor.Blue= 0;
3361 LtdcHandle.Init.Backcolor.Green= 0;
3362
3363 /* LCD clock configuration */
3364 /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
3365 /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */
3366 /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */
3367 /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */
3368
3369 /* done in main.c SystemClockConfig
3370
3371 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
3372 PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;
3373 PeriphClkInitStruct.PLLSAI.PLLSAIR = 4;
3374 PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8;
3375 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
3376 */
3377 /* Polarity */
3378 LtdcHandle.Init.HSPolarity = LTDC_HSPOLARITY_AL;
3379 LtdcHandle.Init.VSPolarity = LTDC_VSPOLARITY_AL;
3380 LtdcHandle.Init.DEPolarity = LTDC_DEPOLARITY_AL;
3381 LtdcHandle.Init.PCPolarity = LTDC_PCPOLARITY_IPC;//LTDC_PCPOLARITY_IPC;
3382
3383 LtdcHandle.Instance = LTDC;
3384
3385 /* Configure the LTDC */
3386 if(HAL_LTDC_Init(&LtdcHandle) != HAL_OK) // auch init der GPIO Pins
3387 {
3388 /* Initialization Error */
3389 GFX_Error_Handler();
3390 }
3391 }
3392
3393
3394 void GFX_VGA_LTDC_Init_org(void)
3395 {
3396
3397 LtdcHandle.Init.HorizontalSync = 96;
3398 /* Vertical synchronization height = Vsync - 1 */
3399 LtdcHandle.Init.VerticalSync = 2;
3400 /* Accumulated horizontal back porch = Hsync + HBP - 1 */
3401 LtdcHandle.Init.AccumulatedHBP = 96 + 48;
3402 /* Accumulated vertical back porch = Vsync + VBP - 1 */
3403 LtdcHandle.Init.AccumulatedVBP = 2 + 35;
3404 /* Accumulated active width = Hsync + HBP + Active Width - 1 */
3405 LtdcHandle.Init.AccumulatedActiveW = 96 + 48 + 800;//499;//500;//499;
3406 /* Accumulated active height = Vsync + VBP + Active Heigh - 1 */
3407 LtdcHandle.Init.AccumulatedActiveH = 2 + 35 + 480;
3408 /* Total width = Hsync + HBP + Active Width + HFP - 1 */
3409 LtdcHandle.Init.TotalWidth = 96 + 48 + 800 + 12;//508;//507;
3410 /* Total height = Vsync + VBP + Active Heigh + VFP - 1 */
3411 LtdcHandle.Init.TotalHeigh = 2 + 35 + 480 + 12;
3412
3413 /* Configure R,G,B component values for LCD background color */
3414 LtdcHandle.Init.Backcolor.Red= 0;
3415 LtdcHandle.Init.Backcolor.Blue= 0;
3416 LtdcHandle.Init.Backcolor.Green= 0;
3417
3418 /* LCD clock configuration */
3419 /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
3420 /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */
3421 /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */
3422 /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */
3423
3424 /* done in main.c SystemClockConfig
3425
3426 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
3427 PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;
3428 PeriphClkInitStruct.PLLSAI.PLLSAIR = 4;
3429 PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8;
3430 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
3431 */
3432 /* Polarity */
3433 LtdcHandle.Init.HSPolarity = LTDC_HSPOLARITY_AL;
3434 LtdcHandle.Init.VSPolarity = LTDC_VSPOLARITY_AH;
3435 LtdcHandle.Init.DEPolarity = LTDC_DEPOLARITY_AL;
3436 LtdcHandle.Init.PCPolarity = LTDC_PCPOLARITY_IPC;//LTDC_PCPOLARITY_IPC;
3437
3438 LtdcHandle.Instance = LTDC;
3439
3440 /* Configure the LTDC */
3441 if(HAL_LTDC_Init(&LtdcHandle) != HAL_OK) // auch init der GPIO Pins
3442 {
3443 /* Initialization Error */
3444 GFX_Error_Handler();
3445 }
3446 }
3447
3448 void GFX_VGA_LTDC_Init(void)
3449 //void GFX_VGA_LTDC_Init_640x480(void)
3450 {
3451
3452 LtdcHandle.Init.HorizontalSync = 96;
3453 /* Vertical synchronization height = Vsync - 1 */
3454 LtdcHandle.Init.VerticalSync = 2;
3455 /* Accumulated horizontal back porch = Hsync + HBP - 1 */
3456 LtdcHandle.Init.AccumulatedHBP = 96 + 48;
3457 /* Accumulated vertical back porch = Vsync + VBP - 1 */
3458 LtdcHandle.Init.AccumulatedVBP = 2 + 35;
3459 /* Accumulated active width = Hsync + HBP + Active Width - 1 */
3460 LtdcHandle.Init.AccumulatedActiveW = 96 + 48 + 640;//499;//500;//499;
3461 /* Accumulated active height = Vsync + VBP + Active Heigh - 1 */
3462 LtdcHandle.Init.AccumulatedActiveH = 2 + 35 + 480;
3463 /* Total width = Hsync + HBP + Active Width + HFP - 1 */
3464 LtdcHandle.Init.TotalWidth = 96 + 48 + 640 + 12;//508;//507;
3465 /* Total height = Vsync + VBP + Active Heigh + VFP - 1 */
3466 LtdcHandle.Init.TotalHeigh = 2 + 35 + 480 + 12;
3467
3468 /* Configure R,G,B component values for LCD background color */
3469 LtdcHandle.Init.Backcolor.Red= 0;
3470 LtdcHandle.Init.Backcolor.Blue= 0;
3471 LtdcHandle.Init.Backcolor.Green= 0;
3472
3473 /* LCD clock configuration */
3474 /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */
3475 /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */
3476 /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */
3477 /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */
3478
3479 /* done in main.c SystemClockConfig
3480
3481 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
3482 PeriphClkInitStruct.PLLSAI.PLLSAIN = 192;
3483 PeriphClkInitStruct.PLLSAI.PLLSAIR = 4;
3484 PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8;
3485 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
3486 */
3487 /* Polarity */
3488 LtdcHandle.Init.HSPolarity = LTDC_HSPOLARITY_AL;
3489 LtdcHandle.Init.VSPolarity = LTDC_VSPOLARITY_AH;
3490 LtdcHandle.Init.DEPolarity = LTDC_DEPOLARITY_AL;
3491 LtdcHandle.Init.PCPolarity = LTDC_PCPOLARITY_IPC;//LTDC_PCPOLARITY_IPC;
3492
3493 LtdcHandle.Instance = LTDC;
3494
3495 /* Configure the LTDC */
3496 if(HAL_LTDC_Init(&LtdcHandle) != HAL_OK) // auch init der GPIO Pins
3497 {
3498 /* Initialization Error */
3499 GFX_Error_Handler();
3500 }
3501 }
3502
3503
3504 void GFX_LTDC_LayerDefaultInit(uint16_t LayerIndex, uint32_t FB_Address)
3505 {
3506 LTDC_LayerCfgTypeDef Layercfg;
3507
3508 /* Layer Init */
3509 Layercfg.WindowX0 = 0;
3510 Layercfg.WindowX1 = 480;
3511 Layercfg.WindowY0 = 0;
3512 Layercfg.WindowY1 = 800;
3513 Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_AL88;//LTDC_PIXEL_FORMAT_ARGB8888;
3514 Layercfg.FBStartAdress = FB_Address;
3515 Layercfg.Alpha = 255;
3516 Layercfg.Alpha0 = 0;
3517 Layercfg.Backcolor.Blue = 0;
3518 Layercfg.Backcolor.Green = 0;
3519 Layercfg.Backcolor.Red = 0;
3520 Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
3521 Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
3522 Layercfg.ImageWidth = 480;
3523 Layercfg.ImageHeight = 800;
3524
3525 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, LayerIndex);
3526 HAL_LTDC_ConfigLayer(&LtdcHandle, &Layercfg, LayerIndex);
3527 HAL_LTDC_EnableCLUT(&LtdcHandle, LayerIndex);
3528 }
3529
3530 void GFX_VGA_LTDC_LayerDefaultInit(uint16_t LayerIndex, uint32_t FB_Address)
3531 {
3532 LTDC_LayerCfgTypeDef Layercfg;
3533
3534 /* Layer Init */
3535 Layercfg.WindowX0 = 0;
3536 Layercfg.WindowX1 = 640;
3537 Layercfg.WindowY0 = 0;
3538 Layercfg.WindowY1 = 480;
3539 Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_AL88;//LTDC_PIXEL_FORMAT_ARGB8888;
3540 Layercfg.FBStartAdress = FB_Address;
3541 Layercfg.Alpha = 255;
3542 Layercfg.Alpha0 = 0;
3543 Layercfg.Backcolor.Blue = 0;
3544 Layercfg.Backcolor.Green = 0;
3545 Layercfg.Backcolor.Red = 0;
3546 Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
3547 Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
3548 Layercfg.ImageWidth = 640;
3549 Layercfg.ImageHeight = 480;
3550
3551 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, LayerIndex);
3552 HAL_LTDC_ConfigLayer(&LtdcHandle, &Layercfg, LayerIndex);
3553 HAL_LTDC_EnableCLUT(&LtdcHandle, LayerIndex);
3554 }
3555
3556 void GFX_LTDC_LayerTESTInit(uint16_t LayerIndex, uint32_t FB_Address)
3557 {
3558 LTDC_LayerCfgTypeDef Layercfg;
3559
3560 /* Layer Init */
3561 Layercfg.WindowX0 = 0;
3562 Layercfg.WindowX1 = 390;
3563 Layercfg.WindowY0 = 0;
3564 Layercfg.WindowY1 = 800;
3565 Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_AL88;//LTDC_PIXEL_FORMAT_ARGB8888;
3566 Layercfg.FBStartAdress = FB_Address;
3567 Layercfg.Alpha = 255;
3568 Layercfg.Alpha0 = 255;
3569 Layercfg.Backcolor.Blue = 0;
3570 Layercfg.Backcolor.Green = 0;
3571 Layercfg.Backcolor.Red = 200;
3572 Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
3573 Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
3574 Layercfg.ImageWidth = 480;
3575 Layercfg.ImageHeight = 800;
3576
3577 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, LayerIndex);
3578 HAL_LTDC_ConfigLayer(&LtdcHandle, &Layercfg, LayerIndex);
3579 HAL_LTDC_EnableCLUT(&LtdcHandle, LayerIndex);
3580 }
3581
3582
3583 uint32_t GFX_doubleBufferOne(void)
3584 {
3585 return SDRAM_DOUBLE_BUFFER_ONE;
3586 }
3587
3588
3589 uint32_t GFX_doubleBufferTwo(void)
3590 {
3591 return SDRAM_DOUBLE_BUFFER_TWO;
3592 }
3593
3594 /*
3595 void doubleBufferClear(uint32_t pDestination)
3596 {
3597 for(uint32_t i = 2*200*480; i > 0; i--)
3598 {
3599 *(__IO uint16_t*)pDestination = 0;
3600 pDestination += 2;
3601 *(__IO uint16_t*)pDestination = 0;
3602 pDestination += 2;
3603 *(__IO uint16_t*)pDestination = 0;
3604 pDestination += 2;
3605 *(__IO uint16_t*)pDestination = 0;
3606 pDestination += 2;
3607 }
3608 }
3609
3610
3611 void GFX_doubleBufferClearOne(void)
3612 {
3613 doubleBufferClear(SDRAM_DOUBLE_BUFFER_ONE);
3614 }
3615
3616
3617 void GFX_doubleBufferClearTwo(void)
3618 {
3619 doubleBufferClear(SDRAM_DOUBLE_BUFFER_TWO);
3620 }
3621 */
3622
3623 uint32_t getFrameByNumber(uint8_t ZeroToMaxFrames)
3624 {
3625 if(ZeroToMaxFrames >= MAXFRAMES)
3626 return 0;
3627 else
3628 return frame[ZeroToMaxFrames].StartAddress;
3629 }
3630
3631 uint32_t getFrame(uint8_t callerId)
3632 {
3633 uint8_t i;
3634
3635 i = 0;
3636 while((i < MAXFRAMES) && (frame[i].status != CLEAR))
3637 i++;
3638
3639 if((i < MAXFRAMES) && (frame[i].status == CLEAR))
3640 {
3641 frame[i].status = BLOCKED;
3642 frame[i].caller = callerId;
3643 return frame[i].StartAddress;
3644 }
3645
3646 i = 0;
3647 while((i < MAXFRAMES) && (frame[i].status != RELEASED))
3648 i++;
3649
3650 if((i < MAXFRAMES) && (frame[i].status == RELEASED))
3651 {
3652 GFX_clear_frame_immediately(frame[i].StartAddress);
3653 frame[i].status = BLOCKED;
3654 return frame[i].StartAddress;
3655 }
3656 return 0;
3657 }
3658
3659
3660 void GFX_forceReleaseFramesWithId(uint8_t callerId)
3661 {
3662 for(int i=0; i<MAXFRAMES; i++)
3663 if((frame[i].caller == callerId) && (frame[i].status == BLOCKED))
3664 frame[i].status = RELEASED;
3665 }
3666
3667
3668 void releaseAllFramesExcept(uint8_t callerId, uint32_t frameStartAddress)
3669 {
3670 for(int i=0; i<MAXFRAMES; i++)
3671 if((frame[i].caller == callerId) && (frame[i].status == BLOCKED) && (frame[i].StartAddress != frameStartAddress))
3672 frame[i].status = RELEASED;
3673 }
3674
3675
3676 uint8_t releaseFrame(uint8_t callerId, uint32_t frameStartAddress)
3677 {
3678 static uint8_t countErrorCalls = 0;
3679
3680 if(frameStartAddress < FBGlobalStart)
3681 return 2;
3682
3683
3684 uint8_t i;
3685
3686 i = 0;
3687 while((i < MAXFRAMES) && (frame[i].StartAddress != frameStartAddress))
3688 i++;
3689
3690 if((i < MAXFRAMES) && (frame[i].StartAddress == frameStartAddress))
3691 {
3692 if(frame[i].caller == callerId)
3693 {
3694 frame[i].status = RELEASED;
3695 return 1;
3696 }
3697 else
3698 countErrorCalls++;
3699 }
3700 return 0;
3701 }
3702
3703
3704 uint16_t blockedFramesCount(void)
3705 {
3706 uint16_t count = MAXFRAMES;
3707
3708 for(int i = 0;i<MAXFRAMES;i++)
3709 if(frame[i].status == BLOCKED)
3710 count--;
3711
3712 return count;
3713 }
3714
3715
3716 uint8_t getFrameCount(uint8_t frameId)
3717 {
3718 if(frameId < (MAXFRAMECOUNTER - 3))
3719 return frameCounter[frameId];
3720 else
3721 return frameCounter[MAXFRAMECOUNTER - 2];
3722 }
3723
3724
3725 void housekeepingFrame(void)
3726 {
3727 static uint8_t countLogClear = 0;
3728
3729 if(DMA2D_at_work != 255)
3730 return;
3731
3732 /* new for debug hw 151202 */
3733 for(int i=1;i<MAXFRAMECOUNTER;i++)
3734 {
3735 frameCounter[i] = 0;
3736 }
3737 for(int i=1;i<MAXFRAMES;i++)
3738 {
3739 if(frame[i].status == BLOCKED)
3740 {
3741 if(frame[i].caller < (MAXFRAMECOUNTER - 2))
3742 frameCounter[frame[i].caller]++;
3743 else
3744 frameCounter[MAXFRAMECOUNTER-3]++;
3745 }
3746 else
3747 if(frame[i].status == RELEASED)
3748 frameCounter[MAXFRAMECOUNTER-2]++;
3749 else
3750 frameCounter[MAXFRAMECOUNTER-1]++;
3751 }
3752
3753
3754 uint8_t i;
3755
3756 i = 0;
3757 while((i < MAXFRAMES) && ((frame[i].status != RELEASED) || (frame[i].StartAddress == GFX_get_pActualFrameTop()) || (frame[i].StartAddress == GFX_get_pActualFrameBottom())))
3758 i++;
3759
3760 if((i < MAXFRAMES) && (frame[i].status == RELEASED))
3761 {
3762 if(frame[i].caller == 15)
3763 countLogClear++;
3764 GFX_clear_frame_dma2d(i);
3765 }
3766 }
3767
3768
3769 static void GFX_Dma2d_TransferComplete(DMA2D_HandleTypeDef* Dma2dHandle)
3770 {
3771 if(DMA2D_at_work < MAXFRAMES)
3772 frame[DMA2D_at_work].status = CLEAR;
3773
3774 DMA2D_at_work = 255;
3775 }
3776
3777
3778 static void GFX_Dma2d_TransferError(DMA2D_HandleTypeDef* Dma2dHandle)
3779 {
3780
3781 }
3782
3783 static void GFX_Error_Handler(void)
3784 {
3785 /* Turn LED3 on */
3786 // BSP_LED_On(LED3);
3787 while(1)
3788 {
3789 }
3790 }
3791
3792 void write_content_simple(GFX_DrawCfgScreen *tMscreen, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, const tFont *Font, const char *text, uint8_t color)
3793 {
3794 GFX_DrawCfgWindow hgfx;
3795
3796 if(XrightGimpStyle > 799)
3797 XrightGimpStyle = 799;
3798 if(XleftGimpStyle >= XrightGimpStyle)
3799 XleftGimpStyle = 0;
3800 if(YtopGimpStyle > 479)
3801 YtopGimpStyle = 479;
3802 hgfx.Image = tMscreen;
3803 hgfx.WindowNumberOfTextLines = 1;
3804 hgfx.WindowLineSpacing = 0;
3805 hgfx.WindowTab = 0;
3806 hgfx.WindowX0 = XleftGimpStyle;
3807 hgfx.WindowX1 = XrightGimpStyle;
3808 hgfx.WindowY1 = 479 - YtopGimpStyle;
3809 if(hgfx.WindowY1 < Font->height)
3810 hgfx.WindowY0 = 0;
3811 else
3812 hgfx.WindowY0 = hgfx.WindowY1 - Font->height;
3813
3814 GFX_write_string_color(Font, &hgfx, text, 0, color);
3815 }
3816
3817
3818 void gfx_write_topline_simple(GFX_DrawCfgScreen *tMscreen, const char *text, uint8_t color)
3819 {
3820 GFX_DrawCfgWindow hgfx;
3821 const tFont *Font = &FontT48;
3822
3823 hgfx.Image = tMscreen;
3824 hgfx.WindowNumberOfTextLines = 1;
3825 hgfx.WindowLineSpacing = 0;
3826 hgfx.WindowTab = 0;
3827 hgfx.WindowX0 = 20;
3828 hgfx.WindowX1 = 779;
3829 hgfx.WindowY1 = 479;
3830 hgfx.WindowY0 = hgfx.WindowY1 - Font->height;
3831
3832 GFX_write_label(Font, &hgfx, text, color);
3833
3834 }
3835
3836
3837 void gfx_write_page_number(GFX_DrawCfgScreen *tMscreen, uint8_t page, uint8_t total, uint8_t color)
3838 {
3839 GFX_DrawCfgWindow hgfx;
3840 const tFont *Font = &FontT48;
3841 char text[7];
3842 uint8_t i, secondDigitPage, secondDigitTotal;
3843
3844 hgfx.Image = tMscreen;
3845 hgfx.WindowNumberOfTextLines = 1;
3846 hgfx.WindowLineSpacing = 0;
3847 hgfx.WindowTab = 0;
3848 hgfx.WindowX1 = 779;
3849 hgfx.WindowX0 = hgfx.WindowX1 - (25*5);
3850 hgfx.WindowY1 = 479;
3851 hgfx.WindowY0 = hgfx.WindowY1 - Font->height;
3852
3853 if(page > 99)
3854 page = 99;
3855 if(total > 99)
3856 total = 99;
3857
3858 i = 0;
3859 text[i++] = '\002';
3860
3861 secondDigitPage = page / 10;
3862 page -= secondDigitPage * 10;
3863
3864 secondDigitTotal = total / 10;
3865 total -= secondDigitTotal * 10;
3866
3867 if(secondDigitPage)
3868 text[i++] = '0' + secondDigitPage;
3869 text[i++] = '0' + page;
3870
3871 text[i++] = '/';
3872
3873 if(secondDigitTotal)
3874 text[i++] = '0' + secondDigitTotal;
3875 text[i++] = '0' + total;
3876
3877 text[i] = 0;
3878
3879 GFX_clear_window_immediately(&hgfx);
3880 GFX_write_label(Font, &hgfx, text, color);
3881 }
3882
3883
3884 uint8_t gfx_number_to_string(uint8_t max_digits, _Bool fill, char *pText, uint32_t input)
3885 {
3886 uint8_t digits[10];
3887 uint32_t number, divider;
3888 int first;
3889 uint8_t out;
3890
3891 number = input;
3892 first = 0;
3893 divider = 1000000000;
3894 for(int i=9;i>=0;i--)
3895 {
3896 digits[i] = (uint8_t)(number / divider);
3897 number -= digits[i] * divider;
3898 divider /= 10;
3899 if((first == 0) && (digits[i] != 0))
3900 first = i;
3901 }
3902
3903 if((first + 1) > max_digits)
3904 {
3905 for(int i = 0; i<max_digits; i++)
3906 pText[i] = '9';
3907 out = max_digits;
3908 }
3909 else if(fill)
3910 {
3911 int i = 0;
3912 for(int k = max_digits; k>0; k--)
3913 pText[i++] = digits[k -1] + '0';
3914 out = max_digits;
3915 }
3916 else
3917 {
3918 int i = 0;
3919 for(int k = first; k>=0; k--)
3920 pText[i++] = digits[k] + '0';
3921 out = i;
3922 }
3923
3924 return out;
3925 }
3926
3927
3928 /* output is
3929 * 0->
3930 * |
3931 * v
3932 *
3933 * input is
3934 *
3935 * ->
3936 * A
3937 * |
3938 * 0
3939 */
3940 void GFX_screenshot(void)
3941 {
3942 uint32_t pSource = GFX_get_pActualFrameTop();
3943 uint32_t pSourceBottom =GFX_get_pActualFrameBottom();
3944 uint32_t pBottomNew = getFrame(99);
3945 uint32_t pDestination = GFX_doubleBufferOne();
3946 uint32_t sourceNow;
3947
3948
3949 uint32_t bot_leftStart = FrameHandler.actualBottom.leftStart; // x0 z.B. 0
3950 uint32_t bot_bottomStart = FrameHandler.actualBottom.bottomStart; // y0 z.B. 25
3951 uint32_t bot_width = FrameHandler.actualBottom.width; // 800
3952 uint32_t bot_height = FrameHandler.actualBottom.height; // 390
3953
3954 struct split
3955 {
3956 uint8_t blue;
3957 uint8_t green;
3958 uint8_t red;
3959 uint8_t alpha;
3960 };
3961
3962 union inout_u
3963 {
3964 uint32_t in;
3965 struct split out;
3966 };
3967
3968 union inout_u value;
3969
3970 /* test
3971 uint32_t pSourceTemp = pSource + (2*479);
3972 for (int j = 0xFFFF; j > 0x00FF; j -= 0x0100)
3973 {
3974 *(__IO uint16_t*)pSourceTemp = j;
3975 pSourceTemp += 480*2;
3976 }
3977 */
3978 // Top Layer
3979 const unsigned width = 800, height = 480;
3980 const uint32_t heightX2 = height*2;
3981
3982 for(unsigned y = 0; y < height; y++)
3983 {
3984 sourceNow = pSource + 2 * ((height - 1) - y);
3985 for(unsigned x = 0; x < width; x++)
3986 {
3987 // sourceNow += 2 * height * x + 2 * (height - 1 - y);
3988 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)];
3989 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1);
3990
3991 *(__IO uint8_t*)(pDestination++) = value.out.red;
3992 *(__IO uint8_t*)(pDestination++) = value.out.green;
3993 *(__IO uint8_t*)(pDestination++) = value.out.blue;
3994 *(__IO uint8_t*)(pDestination++) = value.out.alpha;
3995 sourceNow += heightX2;
3996 }
3997 }
3998
3999 // Bottom Layer
4000 // build newBottom
4001 pSource = pSourceBottom;
4002 for(unsigned x = bot_leftStart; x < bot_leftStart+bot_width; x++)
4003 {
4004 for(unsigned y = bot_bottomStart; y < bot_bottomStart+bot_height; y++)
4005 {
4006 pDestination = pBottomNew + (2 * y);
4007 pDestination += heightX2 * x;
4008 *(__IO uint16_t*)(pDestination) = *(__IO uint16_t*)(pSource);
4009 pSource += 2;
4010 }
4011 }
4012
4013 // output Bottom Layer
4014 pSource = pBottomNew;
4015 pDestination = GFX_doubleBufferTwo();
4016
4017 for(unsigned y = 0; y < height; y++)
4018 {
4019 sourceNow = pSource + 2 * ((height - 1) - y);
4020 for(unsigned x = 0; x < width; x++)
4021 {
4022 // sourceNow = pSource + 2 * height * x + 2 * (height - 1 - y);
4023 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)];
4024 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1);
4025
4026 *(__IO uint8_t*)(pDestination++) = value.out.red;
4027 *(__IO uint8_t*)(pDestination++) = value.out.green;
4028 *(__IO uint8_t*)(pDestination++) = value.out.blue;
4029 *(__IO uint8_t*)(pDestination++) = value.out.alpha;
4030 sourceNow += heightX2;
4031 }
4032 }
4033 releaseFrame(99,pBottomNew);
4034 /*
4035 // das kommt dazu!
4036 unsigned yEnd = 480 - FrameHandler.actualBottom.bottomStart;
4037 unsigned yStart = yEnd - FrameHandler.actualBottom.height;
4038
4039 if(yStart > 0)
4040 {
4041 for(unsigned y = 0; y < yStart; y++)
4042 for(unsigned x = 0; x < width; x++)
4043 {
4044 *(__IO uint8_t*)(pDestination++) = 0;
4045 *(__IO uint8_t*)(pDestination++) = 0;
4046 *(__IO uint8_t*)(pDestination++) = 0;
4047 *(__IO uint8_t*)(pDestination++) = 0;
4048 }
4049 }
4050 for(unsigned y = yStart; y < yEnd; y++)
4051 for(unsigned x = 0; x < width; x++)
4052 {
4053 sourceNow = pSource + 2 * height * x + 2 * (height - 1 - y);
4054 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)];
4055 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1);
4056
4057 *(__IO uint8_t*)(pDestination++) = value.out.red;
4058 *(__IO uint8_t*)(pDestination++) = value.out.green;
4059 *(__IO uint8_t*)(pDestination++) = value.out.blue;
4060 *(__IO uint8_t*)(pDestination++) = value.out.alpha;
4061 }
4062 if(yEnd < 480)
4063 {
4064 for(unsigned y = yEnd; y < 480; y++)
4065 for(unsigned x = 0; x < width; x++)
4066 {
4067 *(__IO uint8_t*)(pDestination++) = 0;
4068 *(__IO uint8_t*)(pDestination++) = 0;
4069 *(__IO uint8_t*)(pDestination++) = 0;
4070 *(__IO uint8_t*)(pDestination++) = 0;
4071 }
4072 }
4073 */
4074 }