EFM32 Gecko Software Documentation  efm32g-doc-4.2.1
segmentlcd.c
Go to the documentation of this file.
1 /**************************************************************************/
17 #include <stdio.h>
18 #include <string.h>
19 #include <stdlib.h>
20 #include <stdbool.h>
21 #include "em_device.h"
22 #include "em_cmu.h"
23 #include "em_gpio.h"
24 
25 #include "segmentlcd.h"
26 
27 /**************************************************************************/
49 typedef struct
50 {
51  uint8_t com[14];
52  uint8_t bit[14];
53 } CHAR_TypeDef;
54 
55 
56 /**************************************************************************/
59 typedef struct
60 {
61  uint8_t com[7];
62  uint8_t bit[7];
64 
65 /**************************************************************************/
68 typedef struct
69 {
70  uint8_t com[5];
71  uint8_t bit[5];
72 } EM_TypeDef;
73 
74 /**************************************************************************/
77 typedef struct
78 {
79  uint8_t com[8];
80  uint8_t bit[8];
82 
83 /**************************************************************************/
86 typedef struct
87 {
88  uint8_t com[4];
89  uint8_t bit[4];
91 
92 /**************************************************************************/
95 typedef struct
96 {
97  CHAR_TypeDef Text[7];
98  NUMBER_TypeDef Number[4];
102 } MCU_DISPLAY;
103 
104 /**************************************************************************/
107 static const MCU_DISPLAY EFM_Display = EFM_DISPLAY_DEF;
108 
109 
110 /**************************************************************************/
116 static const uint16_t EFM_Alphabet[] = {
117  0x0000, /* space */
118  0x1100, /* ! */
119  0x0280, /* " */
120  0x0000, /* # */
121  0x0000, /* $ */
122  0x0602, /* % */
123  0x0000, /* & */
124  0x0020, /* ' */
125  0x0039, /* ( */
126  0x000f, /* ) */
127  0x0000, /* * */
128  0x1540, /* + */
129  0x2000, /* , */
130  0x0440, /* - */
131  0x1000, /* . */
132  0x2200, /* / */
133 
134  0x003f, /* 0 */
135  0x0006, /* 1 */
136  0x045b, /* 2 */
137  0x044f, /* 3 */
138  0x0466, /* 4 */
139  0x046d, /* 5 */
140  0x047d, /* 6 */
141  0x0007, /* 7 */
142  0x047f, /* 8 */
143  0x046f, /* 9 */
144 
145  0x0000, /* : */
146  0x0000, /* ; */
147  0x0a00, /* < */
148  0x0000, /* = */
149  0x2080, /* > */
150  0x0000, /* ? */
151  0xffff, /* @ */
152 
153  0x0477, /* A */
154  0x0a79, /* B */
155  0x0039, /* C */
156  0x20b0, /* D */
157  0x0079, /* E */
158  0x0071, /* F */
159  0x047d, /* G */
160  0x0476, /* H */
161  0x0006, /* I */
162  0x000e, /* J */
163  0x0a70, /* K */
164  0x0038, /* L */
165  0x02b6, /* M */
166  0x08b6, /* N */
167  0x003f, /* O */
168  0x0473, /* P */
169  0x083f, /* Q */
170  0x0c73, /* R */
171  0x046d, /* S */
172  0x1101, /* T */
173  0x003e, /* U */
174  0x2230, /* V */
175  0x2836, /* W */
176  0x2a80, /* X */
177  0x046e, /* Y */
178  0x2209, /* Z */
179 
180  0x0039, /* [ */
181  0x0880, /* backslash */
182  0x000f, /* ] */
183  0x0001, /* ^ */
184  0x0008, /* _ */
185  0x0100, /* ` */
186 
187  0x1058, /* a */
188  0x047c, /* b */
189  0x0058, /* c */
190  0x045e, /* d */
191  0x2058, /* e */
192  0x0471, /* f */
193  0x0c0c, /* g */
194  0x0474, /* h */
195  0x0004, /* i */
196  0x000e, /* j */
197  0x0c70, /* k */
198  0x0038, /* l */
199  0x1454, /* m */
200  0x0454, /* n */
201  0x045c, /* o */
202  0x0473, /* p */
203  0x0467, /* q */
204  0x0450, /* r */
205  0x0c08, /* s */
206  0x0078, /* t */
207  0x001c, /* u */
208  0x2010, /* v */
209  0x2814, /* w */
210  0x2a80, /* x */
211  0x080c, /* y */
212  0x2048, /* z */
213 
214  0x0000,
215 };
216 
217 /**************************************************************************/
222 static const uint16_t EFM_Numbers[] = {
223  0x003f, /* 0 */
224  0x0006, /* 1 */
225  0x005b, /* 2 */
226  0x004f, /* 3 */
227  0x0066, /* 4 */
228  0x006d, /* 5 */
229  0x007d, /* 6 */
230  0x0007, /* 7 */
231  0x007f, /* 8 */
232  0x006f, /* 9 */
233  0x0077, /* A */
234  0x007c, /* b */
235  0x0039, /* C */
236  0x005e, /* d */
237  0x0079, /* E */
238  0x0071, /* F */
239  0x0040 /* - */
240 };
241 
243 /* sign is last element of the table */
244 static const uint16_t signIndex = sizeof(EFM_Numbers)/sizeof(uint16_t) - 1 ;
245 
246 static const LCD_Init_TypeDef lcdInit = LCD_INIT_DEF;
250 /**************************************************************************/
254 {
255  /* Turn on low segments */
256  LCD_ALL_SEGMENTS_OFF();
257 }
258 
259 
260 /**************************************************************************/
264 {
265  LCD_ALL_SEGMENTS_ON();
266 }
267 
268 
269 /**************************************************************************/
273 {
274  LCD_ALPHA_NUMBER_OFF();
275  return;
276 }
277 
278 
279 /**************************************************************************/
284 void SegmentLCD_ARing(int anum, int on)
285 {
286  uint32_t com, bit;
287 
288  com = EFM_Display.ARing.com[anum];
289  bit = EFM_Display.ARing.bit[anum];
290 
291  if (on)
292  {
293  LCD_SegmentSet(com, bit, true);
294  }
295  else
296  {
297  LCD_SegmentSet(com, bit, false);
298  }
299 }
300 
301 
302 /**************************************************************************/
306 void SegmentLCD_Battery(int batteryLevel)
307 {
308  uint32_t com, bit;
309  int i, on;
310 
311  for (i = 0; i < 4; i++)
312  {
313  if (i < batteryLevel)
314  {
315  on = 1;
316  }
317  else
318  {
319  on = 0;
320  }
321  com = EFM_Display.Battery.com[i];
322  bit = EFM_Display.Battery.bit[i];
323 
324  if (on)
325  {
326  LCD_SegmentSet(com, bit, true);
327  }
328  else
329  {
330  LCD_SegmentSet(com, bit, false);
331  }
332  }
333 }
334 
335 
336 /**************************************************************************/
340 {
341  /* Disable LCD */
342  LCD_Enable(false);
343 
344  /* Make sure CTRL register has been updated */
346 
347  /* Turn off LCD clock */
349 
350  /* Turn off voltage boost if enabled */
351  CMU->LCDCTRL = 0;
352 }
353 
354 
355 /**************************************************************************/
360 void SegmentLCD_EnergyMode(int em, int on)
361 {
362  uint32_t com, bit;
363 
364  com = EFM_Display.EMode.com[em];
365  bit = EFM_Display.EMode.bit[em];
366 
367  if (on)
368  {
369  LCD_SegmentSet(com, bit, true);
370  }
371  else
372  {
373  LCD_SegmentSet(com, bit, false);
374  }
375 }
376 
377 
378 /**************************************************************************/
382 void SegmentLCD_Init(bool useBoost)
383 {
384 
385  /* Ensure LE modules are accessible */
387 
388  /* Enable LFRCO as LFACLK in CMU (will also enable oscillator if not enabled) */
390 
391  /* LCD Controller Prescaler */
392  CMU_ClockDivSet(cmuClock_LCDpre, LCD_CMU_CLK_PRE);
393 
394  /* Frame Rate */
395  CMU_LCDClkFDIVSet(LCD_CMU_CLK_DIV);
396 
397  /* Enable clock to LCD module */
399 
400  LCD_DISPLAY_ENABLE();
401 
402  /* Disable interrupts */
403  LCD_IntDisable(0xFFFFFFFF);
404 
405  /* Initialize and enable LCD controller */
406  LCD_Init(&lcdInit);
407 
408  /* Enable all display segments */
409  LCD_SEGMENTS_ENABLE();
410 
411  /* Enable boost if necessary */
412  if (useBoost)
413  {
414  LCD_VBoostSet(LCD_BOOST_LEVEL);
416  CMU->LCDCTRL |= CMU_LCDCTRL_VBOOSTEN;
417  }
418 
419  /* Turn all segments off */
421 
422  LCD_SyncBusyDelay(0xFFFFFFFF);
423 }
424 
425 
426 /**************************************************************************/
432 void SegmentLCD_LowerHex( uint32_t num )
433 {
434  int i;
435  char str[7];
436  uint32_t nibble;
437 
438  SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 0);
439 
440  for ( i=6; i>=0; i-- )
441  {
442  nibble = num & 0xF;
443 
444  if ( nibble < 10 )
445  str[i] = nibble + '0';
446  else if ( nibble == 11 )
447  str[i] = 'b';
448  else if ( nibble == 13 )
449  str[i] = 'd';
450  else
451  str[i] = (nibble - 10) + 'A';
452 
453  num >>= 4;
454  }
455 
456  SegmentLCD_Write(str);
457 }
458 
459 /**************************************************************************/
463 void SegmentLCD_LowerNumber( int num )
464 {
465  int i;
466  char str[7];
467 
468  SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 0);
469 
470  if ( ( num > 9999999 ) || ( num < -9999999 ) )
471  {
472  SegmentLCD_Write("Ovrflow");
473  return;
474  }
475 
476  if ( num < 0 )
477  {
478  SegmentLCD_Symbol(LCD_SYMBOL_MINUS, 1);
479  num = -num;
480  }
481 
482  for ( i=6; i>=0; i-- )
483  {
484  if ( ( i < 6 ) && ( num == 0 ) )
485  {
486  str[i] = ' ';
487  }
488  else
489  {
490  str[i] = (num % 10) + '0';
491  num /= 10;
492  }
493  }
494 
495  SegmentLCD_Write(str);
496 }
497 
498 
499 /**************************************************************************/
503 void SegmentLCD_Number(int value)
504 {
505  int i, com, bit, digit, div, neg;
506  uint16_t bitpattern;
507  uint16_t num;
508 
509  /* Parameter consistancy check */
510  if (value >= 9999)
511  {
512  value = 9999;
513  }
514  if (value <= -1000)
515  {
516  value = -999;
517  }
518  if (value < 0)
519  {
520  value = abs(value);
521  neg = 1;
522  }
523  else
524  {
525  neg = 0;
526  }
527 
528  /* If an update is in progress we must block, or there might be tearing */
529  LCD_SyncBusyDelay(0xFFFFFFFF);
530 
531  /* Freeze updates to avoid partial refresh of display */
532  LCD_FreezeEnable(true);
533 
534  /* Turn off all number LCD segments */
536 
537  /* Extract useful digits */
538  div = 1;
539  for (digit = 0; digit < 4; digit++)
540  {
541  num = (value / div) % 10;
542  if ((neg == 1) && (digit == 3)) num = signIndex;
543  /* Get number layout of display */
544  bitpattern = EFM_Numbers[num];
545  for (i = 0; i < 7; i++)
546  {
547  bit = EFM_Display.Number[digit].bit[i];
548  com = EFM_Display.Number[digit].com[i];
549  if (bitpattern & (1 << i))
550  {
551  LCD_SegmentSet(com, bit, true);
552  }
553  }
554  div = div * 10;
555  }
556  /* Sync LCD registers to LE domain */
557  LCD_FreezeEnable(false);
558 }
559 
560 
561 /**************************************************************************/
565 {
566  /* Turn off all number segments */
567  LCD_NUMBER_OFF();
568  return;
569 }
570 
571 
572 /**************************************************************************/
577 void SegmentLCD_Symbol(lcdSymbol s, int on)
578 {
579  int com = 0;
580  int bit = 0;
581 
582  switch (s)
583  {
584  case LCD_SYMBOL_GECKO:
585  com = LCD_SYMBOL_GECKO_COM;
586  bit = LCD_SYMBOL_GECKO_SEG;
587  break;
588  case LCD_SYMBOL_ANT:
589  com = LCD_SYMBOL_ANT_COM;
590  bit = LCD_SYMBOL_ANT_SEG;
591  break;
592  case LCD_SYMBOL_PAD0:
593  com = LCD_SYMBOL_PAD0_COM;
594  bit = LCD_SYMBOL_PAD0_SEG;
595  break;
596  case LCD_SYMBOL_PAD1:
597  com = LCD_SYMBOL_PAD1_COM;
598  bit = LCD_SYMBOL_PAD1_SEG;
599  break;
600  case LCD_SYMBOL_EFM32:
601  com = LCD_SYMBOL_EFM32_COM;
602  bit = LCD_SYMBOL_EFM32_SEG;
603  break;
604  case LCD_SYMBOL_MINUS:
605  com = LCD_SYMBOL_MINUS_COM;
606  bit = LCD_SYMBOL_MINUS_SEG;
607  break;
608  case LCD_SYMBOL_COL3:
609  com = LCD_SYMBOL_COL3_COM;
610  bit = LCD_SYMBOL_COL3_SEG;
611  break;
612  case LCD_SYMBOL_COL5:
613  com = LCD_SYMBOL_COL5_COM;
614  bit = LCD_SYMBOL_COL5_SEG;
615  break;
616  case LCD_SYMBOL_COL10:
617  com = LCD_SYMBOL_COL10_COM;
618  bit = LCD_SYMBOL_COL10_SEG;
619  break;
620 #ifdef LCD_SYMBOL_DEGC_SEG
621  case LCD_SYMBOL_DEGC:
622  com = LCD_SYMBOL_DEGC_COM;
623  bit = LCD_SYMBOL_DEGC_SEG;
624  break;
625 #endif
626 #ifdef LCD_SYMBOL_DEGF_SEG
627  case LCD_SYMBOL_DEGF:
628  com = LCD_SYMBOL_DEGF_COM;
629  bit = LCD_SYMBOL_DEGF_SEG;
630  break;
631 #endif
632 #ifdef LCD_SYMBOL_DP2_SEG
633  case LCD_SYMBOL_DP2:
634  com = LCD_SYMBOL_DP2_COM;
635  bit = LCD_SYMBOL_DP2_SEG;
636  break;
637 #endif
638 #ifdef LCD_SYMBOL_DP3_SEG
639  case LCD_SYMBOL_DP3:
640  com = LCD_SYMBOL_DP3_COM;
641  bit = LCD_SYMBOL_DP3_SEG;
642  break;
643 #endif
644 #ifdef LCD_SYMBOL_DP4_SEG
645  case LCD_SYMBOL_DP4:
646  com = LCD_SYMBOL_DP4_COM;
647  bit = LCD_SYMBOL_DP4_SEG;
648  break;
649 #endif
650 #ifdef LCD_SYMBOL_DP5_SEG
651  case LCD_SYMBOL_DP5:
652  com = LCD_SYMBOL_DP5_COM;
653  bit = LCD_SYMBOL_DP5_SEG;
654  break;
655 #endif
656  case LCD_SYMBOL_DP6:
657  com = LCD_SYMBOL_DP6_COM;
658  bit = LCD_SYMBOL_DP6_SEG;
659  break;
660  case LCD_SYMBOL_DP10:
661  com = LCD_SYMBOL_DP10_COM;
662  bit = LCD_SYMBOL_DP10_SEG;
663  break;
664 #ifdef LCD_SYMBOL_AM_SEG
665  case LCD_SYMBOL_AM:
666  com = LCD_SYMBOL_AM_COM;
667  bit = LCD_SYMBOL_AM_SEG;
668  break;
669 #endif
670 #ifdef LCD_SYMBOL_PM_SEG
671  case LCD_SYMBOL_PM:
672  com = LCD_SYMBOL_PM_COM;
673  bit = LCD_SYMBOL_PM_SEG;
674  break;
675 #endif
676 #ifdef LCD_SYMBOL_MICROAMP_SEG
677  case LCD_SYMBOL_MICROAMP:
678  com = LCD_SYMBOL_MICROAMP_COM;
679  bit = LCD_SYMBOL_MICROAMP_SEG;
680  break;
681 #endif
682 #ifdef LCD_SYMBOL_MILLIAMP_SEG
683  case LCD_SYMBOL_MILLIAMP:
684  com = LCD_SYMBOL_MILLIAMP_COM;
685  bit = LCD_SYMBOL_MILLIAMP_SEG;
686  break;
687 #endif
688 
689  }
690  if (on)
691  {
692  LCD_SegmentSet(com, bit, true);
693  }
694  else
695  {
696  LCD_SegmentSet(com, bit, false);
697  }
698 }
699 
700 
701 /**************************************************************************/
705 void SegmentLCD_UnsignedHex(uint16_t value)
706 {
707  int num, i, com, bit, digit;
708  uint16_t bitpattern;
709 
710  /* Parameter consistancy check */
711  if (value >= 0xffff)
712  {
713  value = 0xffff;
714  }
715 
716  /* If an update is in progress we must block, or there might be tearing */
717  LCD_SyncBusyDelay(0xFFFFFFFF);
718 
719  /* Freeze updates to avoid partial refresh of display */
720  LCD_FreezeEnable(true);
721 
722  /* Turn off all number LCD segments */
724 
725  for (digit = 0; digit < 4; digit++)
726  {
727  num = (value >> (4 * digit)) & 0x0f;
728  bitpattern = EFM_Numbers[num];
729  for (i = 0; i < 7; i++)
730  {
731  bit = EFM_Display.Number[digit].bit[i];
732  com = EFM_Display.Number[digit].com[i];
733  if (bitpattern & (1 << i))
734  {
735  LCD_SegmentSet(com, bit, true);
736  }
737  }
738  }
739 
740  /* Sync LCD registers to LE domain */
741  LCD_FreezeEnable(false);
742 }
743 
744 
745 /**************************************************************************/
749 void SegmentLCD_Write(char *string)
750 {
751  int data, length, index;
752  uint16_t bitfield;
753  uint32_t com, bit;
754  int i;
755 
756  length = strlen(string);
757  index = 0;
758 
759  /* If an update is in progress we must block, or there might be tearing */
760  LCD_SyncBusyDelay(0xFFFFFFFF);
761 
762  /* Freeze LCD to avoid partial updates */
763  LCD_FreezeEnable(true);
764 
765  /* Turn all segments off */
767 
768  /* Fill out all characters on display */
769  for (index = 0; index < 7; index++)
770  {
771  if (index < length)
772  {
773  data = (int) *string;
774  }
775  else /* Padding with space */
776  {
777  data = 0x20; /* SPACE */
778  }
779  /* Defined letters currently starts at "SPACE" - ASCII 0x20; */
780  data = data - 0x20;
781  /* Get font for this letter */
782  bitfield = EFM_Alphabet[data];
783 
784  for (i = 0; i < 14; i++)
785  {
786  bit = EFM_Display.Text[index].bit[i];
787  com = EFM_Display.Text[index].com[i];
788 
789  if (bitfield & (1 << i))
790  {
791  /* Turn on segment */
792  LCD_SegmentSet(com, bit, true);
793  }
794  }
795  string++;
796  }
797  /* Enable update */
798  LCD_FreezeEnable(false);
799 }
EM_TypeDef EMode
Definition: segmentlcd.c:99
Clock management unit (CMU) API.
void CMU_ClockSelectSet(CMU_Clock_TypeDef clock, CMU_Select_TypeDef ref)
Select reference clock/oscillator used for a clock branch.
Definition: em_cmu.c:2406
Defines prototype for all segments in display.
Definition: segmentlcd.c:95
static const uint16_t EFM_Alphabet[]
Defines higlighted segments for the alphabet, starting from "blank" (SPACE) Uses bit pattern as defin...
Definition: segmentlcd.c:116
void SegmentLCD_LowerNumber(int num)
Write number on lower alphanumeric part of Segment LCD display.
Definition: segmentlcd.c:463
void LCD_VBoostSet(LCD_VBoostLevel_TypeDef vboost)
Configure voltage booster.
Definition: em_lcd.c:605
Defines segment COM and BIT fields numeric display.
Definition: segmentlcd.c:59
Defines segment COM and BIT fields for Energy Modes on display.
Definition: segmentlcd.c:68
static const MCU_DISPLAY EFM_Display
Working instance of LCD display.
Definition: segmentlcd.c:107
Defines each text symbol's segment in terms of COM and BIT numbers, in a way that we can enumerate ea...
Definition: segmentlcd.c:49
void SegmentLCD_Write(char *string)
Write text on LCD display.
Definition: segmentlcd.c:749
#define LCD_SYNCBUSY_CTRL
Definition: efm32g_lcd.h:395
uint8_t bit[7]
Definition: segmentlcd.c:62
CMSIS Cortex-M Peripheral Access Layer for Silicon Laboratories microcontroller devices.
void SegmentLCD_Symbol(lcdSymbol s, int on)
Light up or shut off various symbols on Segment LCD.
Definition: segmentlcd.c:577
void SegmentLCD_NumberOff(void)
Turn all segments on numeric digits in display off.
Definition: segmentlcd.c:564
void LCD_SegmentSet(int com, int bit, bool enable)
Turn on or clear a segment.
Definition: em_lcd.c:260
void LCD_VLCDSelect(LCD_VLCDSel_TypeDef vlcd)
Select source for VLCD.
Definition: em_lcd.c:107
void SegmentLCD_AllOff(void)
Disable all segments.
Definition: segmentlcd.c:253
EFM32 Segment LCD Display driver, header file.
void SegmentLCD_AllOn(void)
Enable all segments.
Definition: segmentlcd.c:263
uint8_t com[7]
Definition: segmentlcd.c:61
#define CMU_LCDCTRL_VBOOSTEN
Definition: efm32g_cmu.h:974
void SegmentLCD_EnergyMode(int em, int on)
Light up or shut off Energy Mode indicator.
Definition: segmentlcd.c:360
General Purpose IO (GPIO) peripheral API.
uint8_t bit[4]
Definition: segmentlcd.c:89
void SegmentLCD_ARing(int anum, int on)
Light up or shut off Ring of Indicators.
Definition: segmentlcd.c:284
void SegmentLCD_AlphaNumberOff(void)
Turn all segments on alpha characters in display off.
Definition: segmentlcd.c:272
uint8_t com[8]
Definition: segmentlcd.c:79
void CMU_ClockEnable(CMU_Clock_TypeDef clock, bool enable)
Enable/disable a clock.
Definition: em_cmu.c:1369
void CMU_LCDClkFDIVSet(uint32_t div)
Set the LCD framerate divisor (FDIV) setting.
Definition: em_cmu.c:3318
BATTERY_TypeDef Battery
Definition: segmentlcd.c:101
uint8_t bit[5]
Definition: segmentlcd.c:71
void SegmentLCD_LowerHex(uint32_t num)
Write a hexadecimal number on lower alphanumeric part of Segment LCD display.
Definition: segmentlcd.c:432
static const uint16_t EFM_Numbers[]
Defines higlighted segments for the numeric display.
Definition: segmentlcd.c:222
uint8_t bit[8]
Definition: segmentlcd.c:80
#define CMU
__STATIC_INLINE void LCD_FreezeEnable(bool enable)
When set, LCD registers will not be updated until cleared,.
Definition: em_lcd.h:435
Defines segment COM and BIT fields for A-wheel (suited for Anim)
Definition: segmentlcd.c:86
void SegmentLCD_Battery(int batteryLevel)
Light up or shut off Battery Indicator.
Definition: segmentlcd.c:306
void SegmentLCD_Number(int value)
Write number on numeric part on Segment LCD display.
Definition: segmentlcd.c:503
uint8_t com[4]
Definition: segmentlcd.c:88
void SegmentLCD_Init(bool useBoost)
Segment LCD Initialization routine for EFM32 STK display.
Definition: segmentlcd.c:382
ARING_TypeDef ARing
Definition: segmentlcd.c:100
uint8_t com[5]
Definition: segmentlcd.c:70
uint8_t bit[14]
Definition: segmentlcd.c:52
void SegmentLCD_UnsignedHex(uint16_t value)
Write hexadecimal number on numeric part on Segment LCD display.
Definition: segmentlcd.c:705
__STATIC_INLINE void LCD_SyncBusyDelay(uint32_t flags)
Polls LCD SYNCBUSY flags, until flag has been cleared.
Definition: em_lcd.h:468
__STATIC_INLINE void LCD_IntDisable(uint32_t flags)
Disable LCD interrupts.
Definition: em_lcd.h:559
CHAR_TypeDef Text[7]
Definition: segmentlcd.c:97
void SegmentLCD_Disable(void)
Disables LCD controller.
Definition: segmentlcd.c:339
__STATIC_INLINE void LCD_Enable(bool enable)
Enable or disable LCD controller.
Definition: em_lcd.h:308
void LCD_Init(const LCD_Init_TypeDef *lcdInit)
Initalize Liquid Crystal Display (LCD) controller.
Definition: em_lcd.c:62
void CMU_ClockDivSet(CMU_Clock_TypeDef clock, CMU_ClkDiv_TypeDef div)
Set clock divisor/prescaler.
Definition: em_cmu.c:1141
uint8_t com[14]
Definition: segmentlcd.c:51
NUMBER_TypeDef Number[4]
Definition: segmentlcd.c:98
Defines segment COM and BIT fields for A-wheel (suited for Anim)
Definition: segmentlcd.c:77