├── LICENSE ├── README.md ├── character_display_big_font__upir.xlsx ├── font_previews ├── bigdigit__angled_bold_preview.png ├── bigdigit__angled_preview.png ├── bigdigit__blocks_crossed_preview.png ├── bigdigit__blocks_cut_preview.png ├── bigdigit__blocks_preview.png ├── bigdigit__classic_bold_preview.png ├── bigdigit__classic_preview.png ├── bigdigit__classic_serif_preview.png ├── bigdigit__dashed_bold_preview.png ├── bigdigit__dashed_preview.png ├── bigdigit__dots_big_preview.png ├── bigdigit__dots_small_preview.png ├── bigdigit__real_bold_preview.png ├── bigdigit__real_preview.png ├── bigdigit__rounded_bold_preview.png ├── bigdigit__rounded_preview.png ├── bigdigit__skewed_bold_preview.png ├── bigdigit__skewed_preview.png ├── bigdigit__square_five_preview.png ├── bigdigit__square_four_preview.png ├── bigdigit__square_three_preview.png ├── bigdigit__square_two_preview.png ├── bigdigit__tron_bold_preview.png ├── bigdigit__tron_preview.png └── readme.md └── small_16x2_display_big_digits__upir.ino /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 upir 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # small display BIG DIGITS project 2 | Big digits (2x2 cells) for character displays. 3 | 4 | **YOUTUBE VIDEO: https://youtu.be/SXSujfeN_QI** 5 | 6 | 7 | **WOKWI PROJECT: https://wokwi.com/projects/361242685904461825** 8 | 9 | 10 | ![THUMB_small_display_big_digits](https://user-images.githubusercontent.com/117754156/230304734-3f563254-66ea-4ea5-9017-b031ce49402b.jpg) 11 | 12 | Small animation: 13 | 14 | 15 | ![small_display_big_digits_anim](https://user-images.githubusercontent.com/117754156/230313284-92f02e45-cf21-48fd-9ea0-a0181b40c4f1.gif) 16 | 17 | 18 | 19 | 20 | 21 | My other videos with 16x2 character display: 22 | - Arduino Gauge in 11 Minutes - https://youtu.be/upE17NHrdPc 23 | - Smooth Arduino 16x2 Gauge - https://youtu.be/cx9CoGqpsfg 24 | - DIY Battery Indicator - https://youtu.be/Mq0WBPKGRew 25 | - 1 DISPLAY 3 SENSORS - https://youtu.be/lj_7UmM0EPY 26 | 27 | Links from the video: 28 | - 16x2 OLED Character Display IIC - https://s.click.aliexpress.com/e/_DBft6KH 29 | - Arduino UNO - https://s.click.aliexpress.com/e/_AXDw1h 30 | - Arduino breadboard prototyping shield - https://s.click.aliexpress.com/e/_ApbCwx 31 | - 16x2 displays with IIC - https://s.click.aliexpress.com/e/_9Hl3JV 32 | - 16x2 display with RGB backlight - https://s.click.aliexpress.com/e/_9wgpeb 33 | - character creator - https://tusindfryd.github.io/screenduino/ 34 | - custom characters simplest project - https://wokwi.com/projects/294395602645549578 35 | - Someone else creating something similar: https://www.alpenglowindustries.com/blog/the-big-numbers-go-marching-2x2#/ 36 | 37 | 38 | 39 | 40 | Screenshots from the video: 41 | 42 | ![CAMTASIA_small_display_big_digits (Time 0_00_01;04)](https://user-images.githubusercontent.com/117754156/230296814-431984c4-70a9-4c85-a35e-9e12020a47b1.jpg) 43 | ![CAMTASIA_small_display_big_digits (Time 0_00_08;04)](https://user-images.githubusercontent.com/117754156/230296829-0aea22ec-64da-4251-bfc0-5bbacfc92c3e.jpg) 44 | ![CAMTASIA_small_display_big_digits (Time 0_00_17;16)](https://user-images.githubusercontent.com/117754156/230296852-f2654d20-46c9-471b-84f7-3033ca376734.jpg) 45 | ![CAMTASIA_small_display_big_digits (Time 0_00_24;13)](https://user-images.githubusercontent.com/117754156/230296867-9a6999c5-d503-4a1d-a505-0b05387d5361.jpg) 46 | ![CAMTASIA_small_display_big_digits (Time 0_00_30;18)](https://user-images.githubusercontent.com/117754156/230296892-04793e57-1157-4b97-944d-2ef2b764676b.jpg) 47 | ![CAMTASIA_small_display_big_digits (Time 0_00_40;05)](https://user-images.githubusercontent.com/117754156/230296911-985aed56-3bde-4f8b-a658-dbfd6d884a94.jpg) 48 | ![CAMTASIA_small_display_big_digits (Time 0_00_44;26)](https://user-images.githubusercontent.com/117754156/230296928-1390b6fb-e01b-468e-9fe1-d71ae0e3fa9e.jpg) 49 | ![CAMTASIA_small_display_big_digits (Time 0_00_47;03)](https://user-images.githubusercontent.com/117754156/230296938-0639bf5d-7af5-45c3-b8d6-a790aa52849b.jpg) 50 | ![CAMTASIA_small_display_big_digits (Time 0_02_20;20)](https://user-images.githubusercontent.com/117754156/230296953-4d1d8aa7-e744-40b0-9538-fed0d2e8fc30.jpg) 51 | ![CAMTASIA_small_display_big_digits (Time 0_02_45;19)](https://user-images.githubusercontent.com/117754156/230296967-427a79da-4c53-43b4-bec8-73c393ea5488.jpg) 52 | ![CAMTASIA_small_display_big_digits (Time 0_03_20;07)](https://user-images.githubusercontent.com/117754156/230296972-ec01e0e7-a4ee-4e0c-a0dd-12909377e6c9.jpg) 53 | ![CAMTASIA_small_display_big_digits (Time 0_03_43;07)](https://user-images.githubusercontent.com/117754156/230296983-43744456-bb58-4ef2-938b-2d15e8c8ec66.jpg) 54 | ![CAMTASIA_small_display_big_digits (Time 0_04_16;03)](https://user-images.githubusercontent.com/117754156/230297000-adb1c92b-6031-4678-b75a-919bf3d18da5.jpg) 55 | ![CAMTASIA_small_display_big_digits (Time 0_04_26;15)](https://user-images.githubusercontent.com/117754156/230297013-feaf630a-8787-4639-8413-88c5c9b17a03.jpg) 56 | ![CAMTASIA_small_display_big_digits (Time 0_05_28;00)](https://user-images.githubusercontent.com/117754156/230297022-3bdefbfd-26f5-4234-94ec-7e383275c56b.jpg) 57 | ![CAMTASIA_small_display_big_digits (Time 0_05_41;06)](https://user-images.githubusercontent.com/117754156/230297035-1c547716-3a3f-4de0-800a-e1af9ff6d1fa.jpg) 58 | ![CAMTASIA_small_display_big_digits (Time 0_05_48;07)](https://user-images.githubusercontent.com/117754156/230297039-b43b18de-709d-42e9-95f1-3ba87a23e998.jpg) 59 | ![CAMTASIA_small_display_big_digits (Time 0_06_13;01)](https://user-images.githubusercontent.com/117754156/230297053-ec0dc7f5-4ef1-4807-b1f2-a4b963abefbc.jpg) 60 | ![CAMTASIA_small_display_big_digits (Time 0_06_23;11)](https://user-images.githubusercontent.com/117754156/230297068-c4a38b85-e047-44c2-b6f3-3be200846a89.jpg) 61 | ![CAMTASIA_small_display_big_digits (Time 0_06_27;27)](https://user-images.githubusercontent.com/117754156/230297079-e658c2c8-b056-4931-901e-7915f0e82f68.jpg) 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | Previews: 72 | 73 | ![bigdigit__angled_bold_preview](https://user-images.githubusercontent.com/117754156/229797191-1ee53348-3114-4c99-897b-280f9455144a.png) 74 | 75 | 76 | ![bigdigit__angled_preview](https://user-images.githubusercontent.com/117754156/229797195-3d741a74-d5f2-456c-aa38-d7b610106069.png) 77 | 78 | 79 | ![bigdigit__blocks_crossed_preview](https://user-images.githubusercontent.com/117754156/229797198-fac76240-c2ae-4298-bb6b-ed93cb9ab916.png) 80 | 81 | 82 | ![bigdigit__blocks_cut_preview](https://user-images.githubusercontent.com/117754156/229797200-1c316acb-6daf-4b54-96e8-bbc355deb719.png) 83 | 84 | 85 | ![bigdigit__blocks_preview](https://user-images.githubusercontent.com/117754156/229797204-27f7fcb6-1601-4aae-83f0-45834c099a9b.png) 86 | 87 | 88 | ![bigdigit__classic_bold_preview](https://user-images.githubusercontent.com/117754156/229797207-2a33ec24-f668-4145-ade2-d8356f4b7019.png) 89 | 90 | 91 | ![bigdigit__classic_preview](https://user-images.githubusercontent.com/117754156/229797209-f002db57-03e5-4942-bbb1-1374aa876395.png) 92 | 93 | 94 | ![bigdigit__classic_serif_preview](https://user-images.githubusercontent.com/117754156/229797214-24715b29-2e13-4708-b4f7-c77b2842dcfa.png) 95 | 96 | 97 | ![bigdigit__dashed_bold_preview](https://user-images.githubusercontent.com/117754156/229797215-a7938414-53e4-4254-a1d3-bdcc61061c3b.png) 98 | 99 | 100 | ![bigdigit__dashed_preview](https://user-images.githubusercontent.com/117754156/229797219-599f9bd4-7470-488c-bba9-ba2db38972aa.png) 101 | 102 | 103 | ![bigdigit__dots_big_preview](https://user-images.githubusercontent.com/117754156/229797221-53404768-6613-41e5-9ab5-47f508151dbf.png) 104 | 105 | 106 | ![bigdigit__dots_small_preview](https://user-images.githubusercontent.com/117754156/229797224-691f558e-631f-4635-a47e-c5e3d538f0a4.png) 107 | 108 | 109 | ![bigdigit__real_bold_preview](https://user-images.githubusercontent.com/117754156/229797226-6424616f-edf2-4883-92fe-7b5fc0a3f894.png) 110 | 111 | 112 | ![bigdigit__real_preview](https://user-images.githubusercontent.com/117754156/229797228-1f8843ed-ebdd-4ddc-98f7-7009c8a8762a.png) 113 | 114 | 115 | ![bigdigit__rounded_bold_preview](https://user-images.githubusercontent.com/117754156/229797230-1ada5a6c-c259-451b-8e7e-cd508aade6fc.png) 116 | 117 | 118 | ![bigdigit__rounded_preview](https://user-images.githubusercontent.com/117754156/229797233-425db743-6274-469d-b92f-5f18df3def1f.png) 119 | 120 | 121 | ![bigdigit__skewed_bold_preview](https://user-images.githubusercontent.com/117754156/229797235-61665935-a2e7-4a85-a211-fd266ac34f25.png) 122 | 123 | 124 | ![bigdigit__skewed_preview](https://user-images.githubusercontent.com/117754156/229797239-9864a62e-36ea-40da-b2e9-a46144495c01.png) 125 | 126 | 127 | ![bigdigit__square_five_preview](https://user-images.githubusercontent.com/117754156/229797242-c561aff5-13f7-45c2-a19f-9f639362822c.png) 128 | 129 | 130 | ![bigdigit__square_four_preview](https://user-images.githubusercontent.com/117754156/229797244-c38ad7a7-0113-4b9d-8568-77dbea49660d.png) 131 | 132 | 133 | ![bigdigit__square_three_preview](https://user-images.githubusercontent.com/117754156/229797246-4ef8b4bc-28b1-40cd-95e7-8ae85ea7d778.png) 134 | 135 | 136 | ![bigdigit__square_two_preview](https://user-images.githubusercontent.com/117754156/229797247-b31fb5b6-2350-4855-a4cf-b9c74eda33fb.png) 137 | 138 | 139 | ![bigdigit__tron_bold_preview](https://user-images.githubusercontent.com/117754156/229797250-00541532-1c57-4666-840e-ce649f36782a.png) 140 | 141 | 142 | ![bigdigit__tron_preview](https://user-images.githubusercontent.com/117754156/229797255-e938fcc0-9433-402e-8a34-412bc11cbbd8.png) 143 | -------------------------------------------------------------------------------- /character_display_big_font__upir.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/character_display_big_font__upir.xlsx -------------------------------------------------------------------------------- /font_previews/bigdigit__angled_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__angled_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__angled_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__angled_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__blocks_crossed_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__blocks_crossed_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__blocks_cut_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__blocks_cut_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__blocks_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__blocks_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__classic_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__classic_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__classic_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__classic_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__classic_serif_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__classic_serif_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__dashed_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__dashed_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__dashed_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__dashed_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__dots_big_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__dots_big_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__dots_small_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__dots_small_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__real_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__real_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__real_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__real_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__rounded_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__rounded_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__rounded_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__rounded_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__skewed_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__skewed_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__skewed_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__skewed_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__square_five_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__square_five_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__square_four_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__square_four_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__square_three_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__square_three_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__square_two_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__square_two_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__tron_bold_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__tron_bold_preview.png -------------------------------------------------------------------------------- /font_previews/bigdigit__tron_preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/upiir/character_display_big_digits/162d1cf8a8bf6ae46a44f64d58102082eae164fc/font_previews/bigdigit__tron_preview.png -------------------------------------------------------------------------------- /font_previews/readme.md: -------------------------------------------------------------------------------- 1 | Individual previews 2 | -------------------------------------------------------------------------------- /small_16x2_display_big_digits__upir.ino: -------------------------------------------------------------------------------- 1 | // simple project using Arduino UNO and 16x2 character display to display BIG DIGITS 2 | // created by upir, 2023 3 | // youtube channel: https://www.youtube.com/upir_upir 4 | 5 | // FULL TUTORIAL: https://youtu.be/SXSujfeN_QI 6 | // Source files: https://github.com/upiir/character_display_big_digits 7 | 8 | // Links related to this project: 9 | // 16x2 OLED Character Display IIC - https://s.click.aliexpress.com/e/_DBft6KH 10 | // Arduino UNO - https://s.click.aliexpress.com/e/_AXDw1h 11 | // Arduino breadboard prototyping shield - https://s.click.aliexpress.com/e/_ApbCwx 12 | // 16x2 displays with IIC - https://s.click.aliexpress.com/e/_9Hl3JV 13 | // 16x2 display with RGB backlight - https://s.click.aliexpress.com/e/_9wgpeb 14 | // character creator - https://tusindfryd.github.io/screenduino/ 15 | // custom characters simplest project - https://wokwi.com/projects/294395602645549578 16 | // Character map: https://docs.wokwi.com/parts/wokwi-lcd1602#font 17 | 18 | 19 | // My other videos with 16x2 character display: 20 | // Arduino Gauge in 11 Minutes - https://youtu.be/upE17NHrdPc 21 | // Smooth Arduino 16x2 Gauge - https://youtu.be/cx9CoGqpsfg 22 | // DIY Battery Indicator - https://youtu.be/Mq0WBPKGRew 23 | // 1 DISPLAY 3 SENSORS - https://youtu.be/lj_7UmM0EPY 24 | 25 | 26 | 27 | 28 | 29 | #include // if you don´t have I2C version of the display, use LiquidCrystal.h library instead 30 | 31 | LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line display 32 | //LiquidCrystal_I2C lcd(0x3f,16,2); // set the LCD address to 0x3f for a 16 chars and 2 line display 33 | // if you don´t know the I2C address of the display, use I2C scanner first (https://playground.arduino.cc/Main/I2cScanner/) 34 | 35 | 36 | 37 | // most of the code below is generated from Excel, please see video / GitHub for details 38 | // ------------------------------------------------------------------------------------------------------ 39 | 40 | // current_font_digits is storing 4 parts for every digit, this array is only needed once in the sketch 41 | byte current_font_digits[10][4]; 42 | byte buffer[8]; 43 | 44 | // ------------------------------------------------------------------------------------------------------ 45 | // code below is auto generated from Excel spreadsheet 46 | 47 | 48 | // set eight special characters for the font: real - updated to be stored in program memory to save some space 49 | const byte real_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 50 | const byte real_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 51 | const byte real_02[8] PROGMEM = {B11100,B00010,B00010,B00001,B00001,B00010,B00010,B11100}; // bits for special character 3/8 52 | const byte real_03[8] PROGMEM = {B00111,B01000,B01000,B10000,B10000,B01000,B01000,B00111}; // bits for special character 4/8 53 | const byte real_04[8] PROGMEM = {B11100,B00100,B00100,B00100,B01000,B01000,B10000,B10000}; // bits for special character 5/8 54 | const byte real_05[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000}; // bits for special character 6/8 55 | const byte real_06[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B01000,B01000,B00111}; // bits for special character 7/8 56 | const byte real_07[8] PROGMEM = {B00011,B00100,B00100,B01000,B01000,B10000,B10000,B11111}; // bits for special character 8/8 57 | 58 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 59 | byte real_digits[10][4] = { {254,254,3,2}, { 254,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 7,1,254,5}, { 7,0,1,2}, { 7,0,6,2}, { 0,4,254,5}, { 3,2,3,2}, { 3,2,1,4 } }; 60 | 61 | // switch font = set special characters and populate current_font_digits with digits from the selected font 62 | void set_font_real () { 63 | for (int i=0; i<10; i++) { 64 | for (int j=0; j<4; j++) { 65 | current_font_digits[i][j] = real_digits[i][j]; 66 | } 67 | } 68 | memcpy_P(buffer,real_00, 8); 69 | lcd.createChar(0 , buffer); 70 | memcpy_P(buffer,real_01, 8); 71 | lcd.createChar(1 , buffer); 72 | memcpy_P(buffer,real_02, 8); 73 | lcd.createChar(2 , buffer); 74 | memcpy_P(buffer,real_03, 8); 75 | lcd.createChar(3 , buffer); 76 | memcpy_P(buffer,real_04, 8); 77 | lcd.createChar(4 , buffer); 78 | memcpy_P(buffer,real_05, 8); 79 | lcd.createChar(5 , buffer); 80 | memcpy_P(buffer,real_06, 8); 81 | lcd.createChar(6 , buffer); 82 | memcpy_P(buffer,real_07, 8); 83 | lcd.createChar(7 , buffer); 84 | } 85 | 86 | 87 | 88 | 89 | // set eight special characters for the font: real_bold - updated to be stored in program memory to save some space 90 | const byte real_bold_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 91 | const byte real_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 92 | const byte real_bold_02[8] PROGMEM = {B11100,B01110,B00110,B00111,B00111,B00110,B01110,B11100}; // bits for special character 3/8 93 | const byte real_bold_03[8] PROGMEM = {B00111,B01110,B01100,B11100,B11100,B01100,B01110,B00111}; // bits for special character 4/8 94 | const byte real_bold_04[8] PROGMEM = {B11110,B00110,B00110,B00110,B01100,B01100,B11000,B11000}; // bits for special character 5/8 95 | const byte real_bold_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 96 | const byte real_bold_06[8] PROGMEM = {B11000,B11000,B11000,B11000,B11100,B01100,B01110,B00111}; // bits for special character 7/8 97 | const byte real_bold_07[8] PROGMEM = {B00011,B00110,B00110,B01100,B01100,B11000,B11000,B11111}; // bits for special character 8/8 98 | 99 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 100 | byte real_bold_digits[10][4] = { {254,254,3,2}, { 254,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 7,1,254,5}, { 7,0,1,2}, { 7,0,6,2}, { 0,4,254,5}, { 3,2,3,2}, { 3,2,1,4 } }; 101 | 102 | // switch font = set special characters and populate current_font_digits with digits from the selected font 103 | void set_font_real_bold () { 104 | for (int i=0; i<10; i++) { 105 | for (int j=0; j<4; j++) { 106 | current_font_digits[i][j] = real_bold_digits[i][j]; 107 | } 108 | } 109 | memcpy_P(buffer,real_bold_00, 8); 110 | lcd.createChar(0 , buffer); 111 | memcpy_P(buffer,real_bold_01, 8); 112 | lcd.createChar(1 , buffer); 113 | memcpy_P(buffer,real_bold_02, 8); 114 | lcd.createChar(2 , buffer); 115 | memcpy_P(buffer,real_bold_03, 8); 116 | lcd.createChar(3 , buffer); 117 | memcpy_P(buffer,real_bold_04, 8); 118 | lcd.createChar(4 , buffer); 119 | memcpy_P(buffer,real_bold_05, 8); 120 | lcd.createChar(5 , buffer); 121 | memcpy_P(buffer,real_bold_06, 8); 122 | lcd.createChar(6 , buffer); 123 | memcpy_P(buffer,real_bold_07, 8); 124 | lcd.createChar(7 , buffer); 125 | } 126 | 127 | 128 | 129 | 130 | // set eight special characters for the font: rounded - updated to be stored in program memory to save some space 131 | const byte rounded_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 132 | const byte rounded_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 133 | const byte rounded_02[8] PROGMEM = {B11100,B00010,B00001,B00001,B00001,B00001,B00010,B11100}; // bits for special character 3/8 134 | const byte rounded_03[8] PROGMEM = {B00111,B01000,B10000,B10000,B10000,B10000,B01000,B00111}; // bits for special character 4/8 135 | const byte rounded_04[8] PROGMEM = {B00000,B00000,B00000,B10000,B10000,B10000,B10000,B11111}; // bits for special character 5/8 136 | const byte rounded_05[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000}; // bits for special character 6/8 137 | const byte rounded_06[8] PROGMEM = {B00001,B00010,B00100,B01000,B00000,B00000,B00000,B00000}; // bits for special character 7/8 138 | const byte rounded_07[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B01000,B00100,B00011}; // bits for special character 8/8 139 | 140 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 141 | byte rounded_digits[10][4] = { {254,254,3,2}, { 6,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 7,4,254,5}, { 3,0,1,2}, { 3,0,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,1,2 } }; 142 | 143 | // switch font = set special characters and populate current_font_digits with digits from the selected font 144 | void set_font_rounded () { 145 | for (int i=0; i<10; i++) { 146 | for (int j=0; j<4; j++) { 147 | current_font_digits[i][j] = rounded_digits[i][j]; 148 | } 149 | } 150 | memcpy_P(buffer,rounded_00, 8); 151 | lcd.createChar(0 , buffer); 152 | memcpy_P(buffer,rounded_01, 8); 153 | lcd.createChar(1 , buffer); 154 | memcpy_P(buffer,rounded_02, 8); 155 | lcd.createChar(2 , buffer); 156 | memcpy_P(buffer,rounded_03, 8); 157 | lcd.createChar(3 , buffer); 158 | memcpy_P(buffer,rounded_04, 8); 159 | lcd.createChar(4 , buffer); 160 | memcpy_P(buffer,rounded_05, 8); 161 | lcd.createChar(5 , buffer); 162 | memcpy_P(buffer,rounded_06, 8); 163 | lcd.createChar(6 , buffer); 164 | memcpy_P(buffer,rounded_07, 8); 165 | lcd.createChar(7 , buffer); 166 | } 167 | 168 | 169 | 170 | 171 | // set eight special characters for the font: rounded_bold - updated to be stored in program memory to save some space 172 | const byte rounded_bold_00[8] PROGMEM = {B11111,B11111,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 173 | const byte rounded_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11111,B11111}; // bits for special character 2/8 174 | const byte rounded_bold_02[8] PROGMEM = {B11100,B11110,B00111,B00011,B00011,B00111,B11110,B11100}; // bits for special character 3/8 175 | const byte rounded_bold_03[8] PROGMEM = {B00111,B01111,B11100,B11000,B11000,B11100,B01111,B00111}; // bits for special character 4/8 176 | const byte rounded_bold_04[8] PROGMEM = {B00000,B00000,B00000,B11000,B11000,B11000,B11111,B11111}; // bits for special character 5/8 177 | const byte rounded_bold_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 178 | const byte rounded_bold_06[8] PROGMEM = {B00011,B00111,B01110,B01100,B00000,B00000,B00000,B00000}; // bits for special character 7/8 179 | const byte rounded_bold_07[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B01100,B00111,B00011}; // bits for special character 8/8 180 | 181 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 182 | byte rounded_bold_digits[10][4] = { {254,254,3,2}, { 6,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 7,4,254,5}, { 3,0,1,2}, { 3,0,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,1,2 } }; 183 | 184 | // switch font = set special characters and populate current_font_digits with digits from the selected font 185 | void set_font_rounded_bold () { 186 | for (int i=0; i<10; i++) { 187 | for (int j=0; j<4; j++) { 188 | current_font_digits[i][j] = rounded_bold_digits[i][j]; 189 | } 190 | } 191 | memcpy_P(buffer,rounded_bold_00, 8); 192 | lcd.createChar(0 , buffer); 193 | memcpy_P(buffer,rounded_bold_01, 8); 194 | lcd.createChar(1 , buffer); 195 | memcpy_P(buffer,rounded_bold_02, 8); 196 | lcd.createChar(2 , buffer); 197 | memcpy_P(buffer,rounded_bold_03, 8); 198 | lcd.createChar(3 , buffer); 199 | memcpy_P(buffer,rounded_bold_04, 8); 200 | lcd.createChar(4 , buffer); 201 | memcpy_P(buffer,rounded_bold_05, 8); 202 | lcd.createChar(5 , buffer); 203 | memcpy_P(buffer,rounded_bold_06, 8); 204 | lcd.createChar(6 , buffer); 205 | memcpy_P(buffer,rounded_bold_07, 8); 206 | lcd.createChar(7 , buffer); 207 | } 208 | 209 | 210 | 211 | 212 | // set eight special characters for the font: skewed - updated to be stored in program memory to save some space 213 | const byte skewed_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 214 | const byte skewed_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 215 | const byte skewed_02[8] PROGMEM = {B11111,B00001,B00001,B00001,B00010,B00100,B01000,B10000}; // bits for special character 3/8 216 | const byte skewed_03[8] PROGMEM = {B00001,B00010,B00100,B01000,B10000,B10000,B10000,B11111}; // bits for special character 4/8 217 | const byte skewed_04[8] PROGMEM = {B11111,B10000,B10000,B10000,B10000,B10000,B10000,B11111}; // bits for special character 5/8 218 | const byte skewed_05[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000}; // bits for special character 6/8 219 | const byte skewed_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 220 | const byte skewed_07[8] PROGMEM = {B11111,B10000,B10000,B10000,B10000,B10000,B10000,B10000}; // bits for special character 8/8 221 | 222 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 223 | byte skewed_digits[10][4] = { {254,254,4,2}, { 254,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 3,1,254,5}, { 7,0,6,2}, { 7,0,4,2}, { 0,2,254,5}, { 4,2,4,2}, { 7,2,0,2 } }; 224 | 225 | // switch font = set special characters and populate current_font_digits with digits from the selected font 226 | void set_font_skewed () { 227 | for (int i=0; i<10; i++) { 228 | for (int j=0; j<4; j++) { 229 | current_font_digits[i][j] = skewed_digits[i][j]; 230 | } 231 | } 232 | memcpy_P(buffer,skewed_00, 8); 233 | lcd.createChar(0 , buffer); 234 | memcpy_P(buffer,skewed_01, 8); 235 | lcd.createChar(1 , buffer); 236 | memcpy_P(buffer,skewed_02, 8); 237 | lcd.createChar(2 , buffer); 238 | memcpy_P(buffer,skewed_03, 8); 239 | lcd.createChar(3 , buffer); 240 | memcpy_P(buffer,skewed_04, 8); 241 | lcd.createChar(4 , buffer); 242 | memcpy_P(buffer,skewed_05, 8); 243 | lcd.createChar(5 , buffer); 244 | memcpy_P(buffer,skewed_06, 8); 245 | lcd.createChar(6 , buffer); 246 | memcpy_P(buffer,skewed_07, 8); 247 | lcd.createChar(7 , buffer); 248 | } 249 | 250 | 251 | 252 | 253 | // set eight special characters for the font: skewed_bold - updated to be stored in program memory to save some space 254 | const byte skewed_bold_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 255 | const byte skewed_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 256 | const byte skewed_bold_02[8] PROGMEM = {B11111,B00011,B00011,B00011,B00010,B00100,B01000,B10000}; // bits for special character 3/8 257 | const byte skewed_bold_03[8] PROGMEM = {B00001,B00010,B00100,B01000,B11000,B11000,B11000,B11111}; // bits for special character 4/8 258 | const byte skewed_bold_04[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 5/8 259 | const byte skewed_bold_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 260 | const byte skewed_bold_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 261 | const byte skewed_bold_07[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 8/8 262 | 263 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 264 | byte skewed_bold_digits[10][4] = { {254,254,4,2}, { 254,5,254,5}, { 0,2,3,1}, { 0,2,1,2}, { 3,1,254,5}, { 7,0,6,2}, { 7,0,4,2}, { 0,2,254,5}, { 4,2,4,2}, { 7,2,0,2 } }; 265 | 266 | // switch font = set special characters and populate current_font_digits with digits from the selected font 267 | void set_font_skewed_bold () { 268 | for (int i=0; i<10; i++) { 269 | for (int j=0; j<4; j++) { 270 | current_font_digits[i][j] = skewed_bold_digits[i][j]; 271 | } 272 | } 273 | memcpy_P(buffer,skewed_bold_00, 8); 274 | lcd.createChar(0 , buffer); 275 | memcpy_P(buffer,skewed_bold_01, 8); 276 | lcd.createChar(1 , buffer); 277 | memcpy_P(buffer,skewed_bold_02, 8); 278 | lcd.createChar(2 , buffer); 279 | memcpy_P(buffer,skewed_bold_03, 8); 280 | lcd.createChar(3 , buffer); 281 | memcpy_P(buffer,skewed_bold_04, 8); 282 | lcd.createChar(4 , buffer); 283 | memcpy_P(buffer,skewed_bold_05, 8); 284 | lcd.createChar(5 , buffer); 285 | memcpy_P(buffer,skewed_bold_06, 8); 286 | lcd.createChar(6 , buffer); 287 | memcpy_P(buffer,skewed_bold_07, 8); 288 | lcd.createChar(7 , buffer); 289 | } 290 | 291 | 292 | 293 | 294 | // set eight special characters for the font: dots_small - updated to be stored in program memory to save some space 295 | const byte dots_small_00[8] PROGMEM = {B10101,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 296 | const byte dots_small_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B10101}; // bits for special character 2/8 297 | const byte dots_small_02[8] PROGMEM = {B10101,B00000,B00001,B00000,B00000,B00001,B00000,B10101}; // bits for special character 3/8 298 | const byte dots_small_03[8] PROGMEM = {B10101,B00000,B10000,B00000,B00000,B10000,B00000,B10101}; // bits for special character 4/8 299 | const byte dots_small_04[8] PROGMEM = {B10101,B00000,B10000,B00000,B00000,B10000,B00000,B10000}; // bits for special character 5/8 300 | const byte dots_small_05[8] PROGMEM = {B10000,B00000,B10000,B00000,B00000,B10000,B00000,B10000}; // bits for special character 6/8 301 | const byte dots_small_06[8] PROGMEM = {B10101,B00000,B00000,B00000,B00000,B00000,B00000,B10101}; // bits for special character 7/8 302 | const byte dots_small_07[8] PROGMEM = {B10000,B00000,B10000,B00000,B00000,B10000,B00000,B10101}; // bits for special character 8/8 303 | 304 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 305 | byte dots_small_digits[10][4] = { {4,5,7,5}, { 254,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 306 | 307 | // switch font = set special characters and populate current_font_digits with digits from the selected font 308 | void set_font_dots_small () { 309 | for (int i=0; i<10; i++) { 310 | for (int j=0; j<4; j++) { 311 | current_font_digits[i][j] = dots_small_digits[i][j]; 312 | } 313 | } 314 | memcpy_P(buffer,dots_small_00, 8); 315 | lcd.createChar(0 , buffer); 316 | memcpy_P(buffer,dots_small_01, 8); 317 | lcd.createChar(1 , buffer); 318 | memcpy_P(buffer,dots_small_02, 8); 319 | lcd.createChar(2 , buffer); 320 | memcpy_P(buffer,dots_small_03, 8); 321 | lcd.createChar(3 , buffer); 322 | memcpy_P(buffer,dots_small_04, 8); 323 | lcd.createChar(4 , buffer); 324 | memcpy_P(buffer,dots_small_05, 8); 325 | lcd.createChar(5 , buffer); 326 | memcpy_P(buffer,dots_small_06, 8); 327 | lcd.createChar(6 , buffer); 328 | memcpy_P(buffer,dots_small_07, 8); 329 | lcd.createChar(7 , buffer); 330 | } 331 | 332 | 333 | 334 | 335 | 336 | 337 | // set eight special characters for the font: dots_big - updated to be stored in program memory to save some space 338 | const byte dots_big_00[8] PROGMEM = {B11011,B11011,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 339 | const byte dots_big_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11011,B11011}; // bits for special character 2/8 340 | const byte dots_big_02[8] PROGMEM = {B11011,B11011,B00000,B00011,B00011,B00000,B11011,B11011}; // bits for special character 3/8 341 | const byte dots_big_03[8] PROGMEM = {B11011,B11011,B00000,B11000,B11000,B00000,B11011,B11011}; // bits for special character 4/8 342 | const byte dots_big_04[8] PROGMEM = {B11011,B11011,B00000,B11000,B11000,B00000,B11000,B11000}; // bits for special character 5/8 343 | const byte dots_big_05[8] PROGMEM = {B11000,B11000,B00000,B11000,B11000,B00000,B11000,B11000}; // bits for special character 6/8 344 | const byte dots_big_06[8] PROGMEM = {B11011,B11011,B00000,B00000,B00000,B00000,B11011,B11011}; // bits for special character 7/8 345 | const byte dots_big_07[8] PROGMEM = {B11000,B11000,B00000,B11000,B11000,B00000,B11011,B11011}; // bits for special character 8/8 346 | 347 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 348 | byte dots_big_digits[10][4] = { {4,5,7,5}, { 254,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 349 | 350 | // switch font = set special characters and populate current_font_digits with digits from the selected font 351 | void set_font_dots_big () { 352 | for (int i=0; i<10; i++) { 353 | for (int j=0; j<4; j++) { 354 | current_font_digits[i][j] = dots_big_digits[i][j]; 355 | } 356 | } 357 | memcpy_P(buffer,dots_big_00, 8); 358 | lcd.createChar(0 , buffer); 359 | memcpy_P(buffer,dots_big_01, 8); 360 | lcd.createChar(1 , buffer); 361 | memcpy_P(buffer,dots_big_02, 8); 362 | lcd.createChar(2 , buffer); 363 | memcpy_P(buffer,dots_big_03, 8); 364 | lcd.createChar(3 , buffer); 365 | memcpy_P(buffer,dots_big_04, 8); 366 | lcd.createChar(4 , buffer); 367 | memcpy_P(buffer,dots_big_05, 8); 368 | lcd.createChar(5 , buffer); 369 | memcpy_P(buffer,dots_big_06, 8); 370 | lcd.createChar(6 , buffer); 371 | memcpy_P(buffer,dots_big_07, 8); 372 | lcd.createChar(7 , buffer); 373 | } 374 | 375 | 376 | 377 | 378 | // set eight special characters for the font: dashed - updated to be stored in program memory to save some space 379 | const byte dashed_00[8] PROGMEM = {B11011,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 380 | const byte dashed_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11011}; // bits for special character 2/8 381 | const byte dashed_02[8] PROGMEM = {B11011,B00001,B00000,B00001,B00001,B00000,B00001,B11011}; // bits for special character 3/8 382 | const byte dashed_03[8] PROGMEM = {B11011,B10000,B00000,B10000,B10000,B00000,B10000,B11011}; // bits for special character 4/8 383 | const byte dashed_04[8] PROGMEM = {B11011,B10000,B00000,B10000,B10000,B00000,B10000,B10000}; // bits for special character 5/8 384 | const byte dashed_05[8] PROGMEM = {B10000,B10000,B00000,B10000,B10000,B00000,B10000,B10000}; // bits for special character 6/8 385 | const byte dashed_06[8] PROGMEM = {B11011,B00000,B00000,B00000,B00000,B00000,B00000,B11011}; // bits for special character 7/8 386 | const byte dashed_07[8] PROGMEM = {B10000,B10000,B00000,B10000,B10000,B00000,B10000,B11011}; // bits for special character 8/8 387 | 388 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 389 | byte dashed_digits[10][4] = { {4,5,7,5}, { 254,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 390 | 391 | // switch font = set special characters and populate current_font_digits with digits from the selected font 392 | void set_font_dashed () { 393 | for (int i=0; i<10; i++) { 394 | for (int j=0; j<4; j++) { 395 | current_font_digits[i][j] = dashed_digits[i][j]; 396 | } 397 | } 398 | memcpy_P(buffer,dashed_00, 8); 399 | lcd.createChar(0 , buffer); 400 | memcpy_P(buffer,dashed_01, 8); 401 | lcd.createChar(1 , buffer); 402 | memcpy_P(buffer,dashed_02, 8); 403 | lcd.createChar(2 , buffer); 404 | memcpy_P(buffer,dashed_03, 8); 405 | lcd.createChar(3 , buffer); 406 | memcpy_P(buffer,dashed_04, 8); 407 | lcd.createChar(4 , buffer); 408 | memcpy_P(buffer,dashed_05, 8); 409 | lcd.createChar(5 , buffer); 410 | memcpy_P(buffer,dashed_06, 8); 411 | lcd.createChar(6 , buffer); 412 | memcpy_P(buffer,dashed_07, 8); 413 | lcd.createChar(7 , buffer); 414 | } 415 | 416 | 417 | 418 | 419 | // set eight special characters for the font: dashed_bold - updated to be stored in program memory to save some space 420 | const byte dashed_bold_00[8] PROGMEM = {B11011,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 421 | const byte dashed_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11011}; // bits for special character 2/8 422 | const byte dashed_bold_02[8] PROGMEM = {B11011,B00011,B00000,B00011,B00011,B00000,B00011,B11011}; // bits for special character 3/8 423 | const byte dashed_bold_03[8] PROGMEM = {B11011,B11000,B00000,B11000,B11000,B00000,B11000,B11011}; // bits for special character 4/8 424 | const byte dashed_bold_04[8] PROGMEM = {B11011,B11000,B00000,B11000,B11000,B00000,B11000,B11000}; // bits for special character 5/8 425 | const byte dashed_bold_05[8] PROGMEM = {B11000,B11000,B00000,B11000,B11000,B00000,B11000,B11000}; // bits for special character 6/8 426 | const byte dashed_bold_06[8] PROGMEM = {B11011,B00000,B00000,B00000,B00000,B00000,B00000,B11011}; // bits for special character 7/8 427 | const byte dashed_bold_07[8] PROGMEM = {B11000,B11000,B00000,B11000,B11000,B00000,B11000,B11011}; // bits for special character 8/8 428 | 429 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 430 | byte dashed_bold_digits[10][4] = { {4,5,7,5}, { 254,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 431 | 432 | // switch font = set special characters and populate current_font_digits with digits from the selected font 433 | void set_font_dashed_bold () { 434 | for (int i=0; i<10; i++) { 435 | for (int j=0; j<4; j++) { 436 | current_font_digits[i][j] = dashed_bold_digits[i][j]; 437 | } 438 | } 439 | memcpy_P(buffer,dashed_bold_00, 8); 440 | lcd.createChar(0 , buffer); 441 | memcpy_P(buffer,dashed_bold_01, 8); 442 | lcd.createChar(1 , buffer); 443 | memcpy_P(buffer,dashed_bold_02, 8); 444 | lcd.createChar(2 , buffer); 445 | memcpy_P(buffer,dashed_bold_03, 8); 446 | lcd.createChar(3 , buffer); 447 | memcpy_P(buffer,dashed_bold_04, 8); 448 | lcd.createChar(4 , buffer); 449 | memcpy_P(buffer,dashed_bold_05, 8); 450 | lcd.createChar(5 , buffer); 451 | memcpy_P(buffer,dashed_bold_06, 8); 452 | lcd.createChar(6 , buffer); 453 | memcpy_P(buffer,dashed_bold_07, 8); 454 | lcd.createChar(7 , buffer); 455 | } 456 | 457 | 458 | 459 | 460 | // set eight special characters for the font: angled - updated to be stored in program memory to save some space 461 | const byte angled_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 462 | const byte angled_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 463 | const byte angled_02[8] PROGMEM = {B11111,B00001,B00001,B00001,B00001,B00001,B00001,B11111}; // bits for special character 3/8 464 | const byte angled_03[8] PROGMEM = {B11111,B10000,B10000,B10000,B10000,B10000,B10000,B11111}; // bits for special character 4/8 465 | const byte angled_04[8] PROGMEM = {B11111,B00001,B00001,B00001,B00001,B00001,B00001,B00001}; // bits for special character 5/8 466 | const byte angled_05[8] PROGMEM = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000}; // bits for special character 6/8 467 | const byte angled_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 468 | const byte angled_07[8] PROGMEM = {B00001,B00001,B00001,B00001,B00001,B00001,B00001,B11111}; // bits for special character 8/8 469 | 470 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 471 | byte angled_digits[10][4] = { {254,254,3,2}, { 254,5,254,5}, { 0,4,3,6}, { 0,4,1,2}, { 3,1,254,5}, { 3,0,1,2}, { 5,254,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,254,7 } }; 472 | 473 | // switch font = set special characters and populate current_font_digits with digits from the selected font 474 | void set_font_angled () { 475 | for (int i=0; i<10; i++) { 476 | for (int j=0; j<4; j++) { 477 | current_font_digits[i][j] = angled_digits[i][j]; 478 | } 479 | } 480 | memcpy_P(buffer,angled_00, 8); 481 | lcd.createChar(0 , buffer); 482 | memcpy_P(buffer,angled_01, 8); 483 | lcd.createChar(1 , buffer); 484 | memcpy_P(buffer,angled_02, 8); 485 | lcd.createChar(2 , buffer); 486 | memcpy_P(buffer,angled_03, 8); 487 | lcd.createChar(3 , buffer); 488 | memcpy_P(buffer,angled_04, 8); 489 | lcd.createChar(4 , buffer); 490 | memcpy_P(buffer,angled_05, 8); 491 | lcd.createChar(5 , buffer); 492 | memcpy_P(buffer,angled_06, 8); 493 | lcd.createChar(6 , buffer); 494 | memcpy_P(buffer,angled_07, 8); 495 | lcd.createChar(7 , buffer); 496 | } 497 | 498 | 499 | 500 | 501 | // set eight special characters for the font: angled_bold - updated to be stored in program memory to save some space 502 | const byte angled_bold_00[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 503 | const byte angled_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 2/8 504 | const byte angled_bold_02[8] PROGMEM = {B11111,B00011,B00011,B00011,B00011,B00011,B00011,B11111}; // bits for special character 3/8 505 | const byte angled_bold_03[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 4/8 506 | const byte angled_bold_04[8] PROGMEM = {B11111,B00011,B00011,B00011,B00011,B00011,B00011,B00011}; // bits for special character 5/8 507 | const byte angled_bold_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 508 | const byte angled_bold_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 509 | const byte angled_bold_07[8] PROGMEM = {B00011,B00011,B00011,B00011,B00011,B00011,B00011,B11111}; // bits for special character 8/8 510 | 511 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 512 | byte angled_bold_digits[10][4] = { {254,254,3,2}, { 254,5,254,5}, { 0,4,3,6}, { 0,4,1,2}, { 3,1,254,5}, { 3,0,1,2}, { 5,254,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,254,7 } }; 513 | 514 | // switch font = set special characters and populate current_font_digits with digits from the selected font 515 | void set_font_angled_bold () { 516 | for (int i=0; i<10; i++) { 517 | for (int j=0; j<4; j++) { 518 | current_font_digits[i][j] = angled_bold_digits[i][j]; 519 | } 520 | } 521 | memcpy_P(buffer,angled_bold_00, 8); 522 | lcd.createChar(0 , buffer); 523 | memcpy_P(buffer,angled_bold_01, 8); 524 | lcd.createChar(1 , buffer); 525 | memcpy_P(buffer,angled_bold_02, 8); 526 | lcd.createChar(2 , buffer); 527 | memcpy_P(buffer,angled_bold_03, 8); 528 | lcd.createChar(3 , buffer); 529 | memcpy_P(buffer,angled_bold_04, 8); 530 | lcd.createChar(4 , buffer); 531 | memcpy_P(buffer,angled_bold_05, 8); 532 | lcd.createChar(5 , buffer); 533 | memcpy_P(buffer,angled_bold_06, 8); 534 | lcd.createChar(6 , buffer); 535 | memcpy_P(buffer,angled_bold_07, 8); 536 | lcd.createChar(7 , buffer); 537 | } 538 | 539 | 540 | 541 | 542 | // set eight special characters for the font: blocks - updated to be stored in program memory to save some space 543 | const byte blocks_00[8] PROGMEM = {B11111,B11111,B11111,B11111,B00000,B00000,B00000,B00000}; // bits for special character 1/8 544 | const byte blocks_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B11111,B11111,B11111,B11111}; // bits for special character 2/8 545 | const byte blocks_02[8] PROGMEM = {B11111,B11111,B11111,B11111,B11111,B11111,B11111,B00000}; // bits for special character 3/8 546 | const byte blocks_03[8] PROGMEM = {B00000,B11111,B11111,B11111,B11111,B11111,B11111,B11111}; // bits for special character 4/8 547 | const byte blocks_04[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 5/8 548 | const byte blocks_05[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 6/8 549 | const byte blocks_06[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 7/8 550 | const byte blocks_07[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 8/8 551 | 552 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 553 | byte blocks_digits[10][4] = { {255,255,255,255}, { 254,255,254,255}, { 0,255,255,1}, { 0,255,1,255}, { 255,1,254,255}, { 255,0,1,255}, { 255,0,255,255}, { 0,255,254,255}, { 2,2,3,3}, { 255,255,1,255 } }; 554 | 555 | // switch font = set special characters and populate current_font_digits with digits from the selected font 556 | void set_font_blocks () { 557 | for (int i=0; i<10; i++) { 558 | for (int j=0; j<4; j++) { 559 | current_font_digits[i][j] = blocks_digits[i][j]; 560 | } 561 | } 562 | memcpy_P(buffer,blocks_00, 8); 563 | lcd.createChar(0 , buffer); 564 | memcpy_P(buffer,blocks_01, 8); 565 | lcd.createChar(1 , buffer); 566 | memcpy_P(buffer,blocks_02, 8); 567 | lcd.createChar(2 , buffer); 568 | memcpy_P(buffer,blocks_03, 8); 569 | lcd.createChar(3 , buffer); 570 | memcpy_P(buffer,blocks_04, 8); 571 | lcd.createChar(4 , buffer); 572 | memcpy_P(buffer,blocks_05, 8); 573 | lcd.createChar(5 , buffer); 574 | memcpy_P(buffer,blocks_06, 8); 575 | lcd.createChar(6 , buffer); 576 | memcpy_P(buffer,blocks_07, 8); 577 | lcd.createChar(7 , buffer); 578 | } 579 | 580 | 581 | 582 | 583 | // set eight special characters for the font: blocks_crossed - updated to be stored in program memory to save some space 584 | const byte blocks_crossed_00[8] PROGMEM = {B11111,B11111,B11111,B11111,B00000,B00000,B00000,B00000}; // bits for special character 1/8 585 | const byte blocks_crossed_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B11111,B11111,B11111,B11111}; // bits for special character 2/8 586 | const byte blocks_crossed_02[8] PROGMEM = {B11110,B11101,B11011,B10111,B01111,B11111,B11111,B11111}; // bits for special character 3/8 587 | const byte blocks_crossed_03[8] PROGMEM = {B11111,B11111,B11111,B11111,B11110,B11101,B11111,B11111}; // bits for special character 4/8 588 | const byte blocks_crossed_04[8] PROGMEM = {B11111,B11111,B10111,B01111,B11111,B11111,B11111,B11111}; // bits for special character 5/8 589 | const byte blocks_crossed_05[8] PROGMEM = {B11111,B11111,B11111,B11110,B11101,B11011,B10111,B01111}; // bits for special character 6/8 590 | const byte blocks_crossed_06[8] PROGMEM = {B11110,B11101,B11111,B11111,B11111,B11111,B11111,B11111}; // bits for special character 7/8 591 | const byte blocks_crossed_07[8] PROGMEM = {B11111,B11111,B11111,B11111,B11111,B11111,B10111,B01111}; // bits for special character 8/8 592 | 593 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 594 | byte blocks_crossed_digits[10][4] = { {255,7,6,255}, { 254,2,254,255}, { 0,255,2,1}, { 0,5,1,255}, { 2,1,254,255}, { 255,0,1,2}, { 255,0,3,4}, { 0,255,254,5}, { 3,4,3,4}, { 3,4,1,255 } }; 595 | 596 | // switch font = set special characters and populate current_font_digits with digits from the selected font 597 | void set_font_blocks_crossed () { 598 | for (int i=0; i<10; i++) { 599 | for (int j=0; j<4; j++) { 600 | current_font_digits[i][j] = blocks_crossed_digits[i][j]; 601 | } 602 | } 603 | memcpy_P(buffer,blocks_crossed_00, 8); 604 | lcd.createChar(0 , buffer); 605 | memcpy_P(buffer,blocks_crossed_01, 8); 606 | lcd.createChar(1 , buffer); 607 | memcpy_P(buffer,blocks_crossed_02, 8); 608 | lcd.createChar(2 , buffer); 609 | memcpy_P(buffer,blocks_crossed_03, 8); 610 | lcd.createChar(3 , buffer); 611 | memcpy_P(buffer,blocks_crossed_04, 8); 612 | lcd.createChar(4 , buffer); 613 | memcpy_P(buffer,blocks_crossed_05, 8); 614 | lcd.createChar(5 , buffer); 615 | memcpy_P(buffer,blocks_crossed_06, 8); 616 | lcd.createChar(6 , buffer); 617 | memcpy_P(buffer,blocks_crossed_07, 8); 618 | lcd.createChar(7 , buffer); 619 | } 620 | 621 | 622 | 623 | 624 | // set eight special characters for the font: blocks_cut - updated to be stored in program memory to save some space 625 | const byte blocks_cut_00[8] PROGMEM = {B11111,B11111,B11111,B11111,B00000,B00000,B00000,B00000}; // bits for special character 1/8 626 | const byte blocks_cut_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B11111,B11111,B11111,B11111}; // bits for special character 2/8 627 | const byte blocks_cut_02[8] PROGMEM = {B00001,B00011,B00111,B01111,B11111,B11111,B11111,B11111}; // bits for special character 3/8 628 | const byte blocks_cut_03[8] PROGMEM = {B11111,B11111,B11111,B11111,B01111,B00111,B00011,B00001}; // bits for special character 4/8 629 | const byte blocks_cut_04[8] PROGMEM = {B10000,B11000,B11100,B11110,B11111,B11111,B11111,B11111}; // bits for special character 5/8 630 | const byte blocks_cut_05[8] PROGMEM = {B11111,B11111,B11111,B11111,B11110,B11100,B11000,B10000}; // bits for special character 6/8 631 | const byte blocks_cut_06[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00001,B00011,B00111}; // bits for special character 7/8 632 | const byte blocks_cut_07[8] PROGMEM = {B11100,B11000,B10000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 8/8 633 | 634 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 635 | byte blocks_cut_digits[10][4] = { {2,255,255,5}, { 254,2,254,255}, { 0,5,2,1}, { 0,255,1,5}, { 2,1,254,255}, { 255,0,1,5}, { 2,7,255,5}, { 0,255,254,5}, { 255,5,2,255}, { 2,255,6,5 } }; 636 | 637 | // switch font = set special characters and populate current_font_digits with digits from the selected font 638 | void set_font_blocks_cut () { 639 | for (int i=0; i<10; i++) { 640 | for (int j=0; j<4; j++) { 641 | current_font_digits[i][j] = blocks_cut_digits[i][j]; 642 | } 643 | } 644 | memcpy_P(buffer,blocks_cut_00, 8); 645 | lcd.createChar(0 , buffer); 646 | memcpy_P(buffer,blocks_cut_01, 8); 647 | lcd.createChar(1 , buffer); 648 | memcpy_P(buffer,blocks_cut_02, 8); 649 | lcd.createChar(2 , buffer); 650 | memcpy_P(buffer,blocks_cut_03, 8); 651 | lcd.createChar(3 , buffer); 652 | memcpy_P(buffer,blocks_cut_04, 8); 653 | lcd.createChar(4 , buffer); 654 | memcpy_P(buffer,blocks_cut_05, 8); 655 | lcd.createChar(5 , buffer); 656 | memcpy_P(buffer,blocks_cut_06, 8); 657 | lcd.createChar(6 , buffer); 658 | memcpy_P(buffer,blocks_cut_07, 8); 659 | lcd.createChar(7 , buffer); 660 | } 661 | 662 | 663 | 664 | 665 | // set eight special characters for the font: classic - updated to be stored in program memory to save some space 666 | const byte classic_00[8] PROGMEM = {B11111,B11000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 667 | const byte classic_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11000,B11111}; // bits for special character 2/8 668 | const byte classic_02[8] PROGMEM = {B11111,B00011,B00011,B00011,B00011,B00011,B00011,B11111}; // bits for special character 3/8 669 | const byte classic_03[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 4/8 670 | const byte classic_04[8] PROGMEM = {B00001,B00010,B00100,B00000,B00000,B00000,B00000,B00000}; // bits for special character 5/8 671 | const byte classic_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 672 | const byte classic_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 673 | const byte classic_07[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 8/8 674 | 675 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 676 | byte classic_digits[10][4] = { {254,254,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 677 | 678 | // switch font = set special characters and populate current_font_digits with digits from the selected font 679 | void set_font_classic () { 680 | for (int i=0; i<10; i++) { 681 | for (int j=0; j<4; j++) { 682 | current_font_digits[i][j] = classic_digits[i][j]; 683 | } 684 | } 685 | memcpy_P(buffer,classic_00, 8); 686 | lcd.createChar(0 , buffer); 687 | memcpy_P(buffer,classic_01, 8); 688 | lcd.createChar(1 , buffer); 689 | memcpy_P(buffer,classic_02, 8); 690 | lcd.createChar(2 , buffer); 691 | memcpy_P(buffer,classic_03, 8); 692 | lcd.createChar(3 , buffer); 693 | memcpy_P(buffer,classic_04, 8); 694 | lcd.createChar(4 , buffer); 695 | memcpy_P(buffer,classic_05, 8); 696 | lcd.createChar(5 , buffer); 697 | memcpy_P(buffer,classic_06, 8); 698 | lcd.createChar(6 , buffer); 699 | memcpy_P(buffer,classic_07, 8); 700 | lcd.createChar(7 , buffer); 701 | } 702 | 703 | 704 | 705 | 706 | // set eight special characters for the font: classic_bold - updated to be stored in program memory to save some space 707 | const byte classic_bold_00[8] PROGMEM = {B11111,B11000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 708 | const byte classic_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11000,B11111}; // bits for special character 2/8 709 | const byte classic_bold_02[8] PROGMEM = {B11111,B00111,B00111,B00111,B00111,B00111,B00111,B11111}; // bits for special character 3/8 710 | const byte classic_bold_03[8] PROGMEM = {B11111,B11100,B11100,B11100,B11100,B11100,B11100,B11111}; // bits for special character 4/8 711 | const byte classic_bold_04[8] PROGMEM = {B00001,B00011,B00111,B00000,B00000,B00000,B00000,B00000}; // bits for special character 5/8 712 | const byte classic_bold_05[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100}; // bits for special character 6/8 713 | const byte classic_bold_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 714 | const byte classic_bold_07[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11111}; // bits for special character 8/8 715 | 716 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 717 | byte classic_bold_digits[10][4] = { {254,254,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 718 | 719 | // switch font = set special characters and populate current_font_digits with digits from the selected font 720 | void set_font_classic_bold () { 721 | for (int i=0; i<10; i++) { 722 | for (int j=0; j<4; j++) { 723 | current_font_digits[i][j] = classic_bold_digits[i][j]; 724 | } 725 | } 726 | memcpy_P(buffer,classic_bold_00, 8); 727 | lcd.createChar(0 , buffer); 728 | memcpy_P(buffer,classic_bold_01, 8); 729 | lcd.createChar(1 , buffer); 730 | memcpy_P(buffer,classic_bold_02, 8); 731 | lcd.createChar(2 , buffer); 732 | memcpy_P(buffer,classic_bold_03, 8); 733 | lcd.createChar(3 , buffer); 734 | memcpy_P(buffer,classic_bold_04, 8); 735 | lcd.createChar(4 , buffer); 736 | memcpy_P(buffer,classic_bold_05, 8); 737 | lcd.createChar(5 , buffer); 738 | memcpy_P(buffer,classic_bold_06, 8); 739 | lcd.createChar(6 , buffer); 740 | memcpy_P(buffer,classic_bold_07, 8); 741 | lcd.createChar(7 , buffer); 742 | } 743 | 744 | 745 | 746 | 747 | // set eight special characters for the font: classic_serif - updated to be stored in program memory to save some space 748 | const byte classic_serif_00[8] PROGMEM = {B11111,B11111,B11000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 749 | const byte classic_serif_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B11000,B11111,B11111}; // bits for special character 2/8 750 | const byte classic_serif_02[8] PROGMEM = {B11111,B00011,B00011,B00011,B00011,B00011,B00011,B11111}; // bits for special character 3/8 751 | const byte classic_serif_03[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 4/8 752 | const byte classic_serif_04[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B11111,B11111}; // bits for special character 5/8 753 | const byte classic_serif_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 754 | const byte classic_serif_06[8] PROGMEM = {B11111,B11111,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 755 | const byte classic_serif_07[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 8/8 756 | 757 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 758 | byte classic_serif_digits[10][4] = { {254,254,3,2}, { 254,5,254,5}, { 6,2,3,4}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,4,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,4,2 } }; 759 | 760 | // switch font = set special characters and populate current_font_digits with digits from the selected font 761 | void set_font_classic_serif () { 762 | for (int i=0; i<10; i++) { 763 | for (int j=0; j<4; j++) { 764 | current_font_digits[i][j] = classic_serif_digits[i][j]; 765 | } 766 | } 767 | memcpy_P(buffer,classic_serif_00, 8); 768 | lcd.createChar(0 , buffer); 769 | memcpy_P(buffer,classic_serif_01, 8); 770 | lcd.createChar(1 , buffer); 771 | memcpy_P(buffer,classic_serif_02, 8); 772 | lcd.createChar(2 , buffer); 773 | memcpy_P(buffer,classic_serif_03, 8); 774 | lcd.createChar(3 , buffer); 775 | memcpy_P(buffer,classic_serif_04, 8); 776 | lcd.createChar(4 , buffer); 777 | memcpy_P(buffer,classic_serif_05, 8); 778 | lcd.createChar(5 , buffer); 779 | memcpy_P(buffer,classic_serif_06, 8); 780 | lcd.createChar(6 , buffer); 781 | memcpy_P(buffer,classic_serif_07, 8); 782 | lcd.createChar(7 , buffer); 783 | } 784 | 785 | 786 | 787 | 788 | // set eight special characters for the font: tron - updated to be stored in program memory to save some space 789 | const byte tron_00[8] PROGMEM = {B11111,B11000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 790 | const byte tron_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11000,B11111}; // bits for special character 2/8 791 | const byte tron_02[8] PROGMEM = {B11111,B00011,B00011,B00011,B00011,B00011,B00011,B00011}; // bits for special character 3/8 792 | const byte tron_03[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 4/8 793 | const byte tron_04[8] PROGMEM = {B11111,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 5/8 794 | const byte tron_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 795 | const byte tron_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 796 | const byte tron_07[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11111}; // bits for special character 8/8 797 | 798 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 799 | byte tron_digits[10][4] = { {4,2,7,255}, { 254,5,254,5}, { 0,2,3,6}, { 0,2,1,255}, { 7,1,254,5}, { 3,6,1,255}, { 3,6,3,255}, { 0,2,254,5}, { 3,2,3,255}, { 3,2,254,2 } }; 800 | 801 | // switch font = set special characters and populate current_font_digits with digits from the selected font 802 | void set_font_tron () { 803 | for (int i=0; i<10; i++) { 804 | for (int j=0; j<4; j++) { 805 | current_font_digits[i][j] = tron_digits[i][j]; 806 | } 807 | } 808 | memcpy_P(buffer,tron_00, 8); 809 | lcd.createChar(0 , buffer); 810 | memcpy_P(buffer,tron_01, 8); 811 | lcd.createChar(1 , buffer); 812 | memcpy_P(buffer,tron_02, 8); 813 | lcd.createChar(2 , buffer); 814 | memcpy_P(buffer,tron_03, 8); 815 | lcd.createChar(3 , buffer); 816 | memcpy_P(buffer,tron_04, 8); 817 | lcd.createChar(4 , buffer); 818 | memcpy_P(buffer,tron_05, 8); 819 | lcd.createChar(5 , buffer); 820 | memcpy_P(buffer,tron_06, 8); 821 | lcd.createChar(6 , buffer); 822 | memcpy_P(buffer,tron_07, 8); 823 | lcd.createChar(7 , buffer); 824 | } 825 | 826 | 827 | 828 | 829 | // set eight special characters for the font: tron_bold - updated to be stored in program memory to save some space 830 | const byte tron_bold_00[8] PROGMEM = {B11111,B11000,B00000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 831 | const byte tron_bold_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B00000,B11000,B11111}; // bits for special character 2/8 832 | const byte tron_bold_02[8] PROGMEM = {B11111,B00111,B00111,B00111,B00111,B00111,B00111,B00111}; // bits for special character 3/8 833 | const byte tron_bold_03[8] PROGMEM = {B11111,B11100,B11100,B11100,B11100,B11100,B11100,B11111}; // bits for special character 4/8 834 | const byte tron_bold_04[8] PROGMEM = {B11111,B11100,B11100,B11100,B11100,B11100,B11100,B11100}; // bits for special character 5/8 835 | const byte tron_bold_05[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100}; // bits for special character 6/8 836 | const byte tron_bold_06[8] PROGMEM = {B11111,B00000,B00000,B00000,B00000,B00000,B00000,B11111}; // bits for special character 7/8 837 | const byte tron_bold_07[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11111}; // bits for special character 8/8 838 | 839 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 840 | byte tron_bold_digits[10][4] = { {4,2,7,255}, { 254,5,254,5}, { 0,2,3,6}, { 0,2,1,255}, { 7,1,254,5}, { 3,6,1,255}, { 3,6,3,255}, { 0,2,254,5}, { 3,2,3,255}, { 3,2,254,2 } }; 841 | 842 | // switch font = set special characters and populate current_font_digits with digits from the selected font 843 | void set_font_tron_bold () { 844 | for (int i=0; i<10; i++) { 845 | for (int j=0; j<4; j++) { 846 | current_font_digits[i][j] = tron_bold_digits[i][j]; 847 | } 848 | } 849 | memcpy_P(buffer,tron_bold_00, 8); 850 | lcd.createChar(0 , buffer); 851 | memcpy_P(buffer,tron_bold_01, 8); 852 | lcd.createChar(1 , buffer); 853 | memcpy_P(buffer,tron_bold_02, 8); 854 | lcd.createChar(2 , buffer); 855 | memcpy_P(buffer,tron_bold_03, 8); 856 | lcd.createChar(3 , buffer); 857 | memcpy_P(buffer,tron_bold_04, 8); 858 | lcd.createChar(4 , buffer); 859 | memcpy_P(buffer,tron_bold_05, 8); 860 | lcd.createChar(5 , buffer); 861 | memcpy_P(buffer,tron_bold_06, 8); 862 | lcd.createChar(6 , buffer); 863 | memcpy_P(buffer,tron_bold_07, 8); 864 | lcd.createChar(7 , buffer); 865 | } 866 | 867 | 868 | 869 | 870 | // set eight special characters for the font: square_two - updated to be stored in program memory to save some space 871 | const byte square_two_00[8] PROGMEM = {B11111,B11111,B11000,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 872 | const byte square_two_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B11000,B11111,B11111}; // bits for special character 2/8 873 | const byte square_two_02[8] PROGMEM = {B11111,B11111,B00011,B00011,B00011,B00011,B11111,B11111}; // bits for special character 3/8 874 | const byte square_two_03[8] PROGMEM = {B11111,B11111,B11000,B11000,B11000,B11000,B11111,B11111}; // bits for special character 4/8 875 | const byte square_two_04[8] PROGMEM = {B00001,B00011,B00111,B00000,B00000,B00000,B00000,B00000}; // bits for special character 5/8 876 | const byte square_two_05[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000}; // bits for special character 6/8 877 | const byte square_two_06[8] PROGMEM = {B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111}; // bits for special character 7/8 878 | const byte square_two_07[8] PROGMEM = {B11000,B11000,B11000,B11000,B11000,B11000,B11111,B11111}; // bits for special character 8/8 879 | 880 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 881 | byte square_two_digits[10][4] = { {254,254,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 882 | 883 | // switch font = set special characters and populate current_font_digits with digits from the selected font 884 | void set_font_square_two () { 885 | for (int i=0; i<10; i++) { 886 | for (int j=0; j<4; j++) { 887 | current_font_digits[i][j] = square_two_digits[i][j]; 888 | } 889 | } 890 | memcpy_P(buffer,square_two_00, 8); 891 | lcd.createChar(0 , buffer); 892 | memcpy_P(buffer,square_two_01, 8); 893 | lcd.createChar(1 , buffer); 894 | memcpy_P(buffer,square_two_02, 8); 895 | lcd.createChar(2 , buffer); 896 | memcpy_P(buffer,square_two_03, 8); 897 | lcd.createChar(3 , buffer); 898 | memcpy_P(buffer,square_two_04, 8); 899 | lcd.createChar(4 , buffer); 900 | memcpy_P(buffer,square_two_05, 8); 901 | lcd.createChar(5 , buffer); 902 | memcpy_P(buffer,square_two_06, 8); 903 | lcd.createChar(6 , buffer); 904 | memcpy_P(buffer,square_two_07, 8); 905 | lcd.createChar(7 , buffer); 906 | } 907 | 908 | 909 | 910 | 911 | // set eight special characters for the font: square_three - updated to be stored in program memory to save some space 912 | const byte square_three_00[8] PROGMEM = {B11111,B11111,B11100,B00000,B00000,B00000,B00000,B00000}; // bits for special character 1/8 913 | const byte square_three_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B00000,B11100,B11111,B11111}; // bits for special character 2/8 914 | const byte square_three_02[8] PROGMEM = {B11111,B11111,B00111,B00111,B00111,B00111,B11111,B11111}; // bits for special character 3/8 915 | const byte square_three_03[8] PROGMEM = {B11111,B11111,B11100,B11100,B11100,B11100,B11111,B11111}; // bits for special character 4/8 916 | const byte square_three_04[8] PROGMEM = {B00001,B00011,B00111,B01111,B00000,B00000,B00000,B00000}; // bits for special character 5/8 917 | const byte square_three_05[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100}; // bits for special character 6/8 918 | const byte square_three_06[8] PROGMEM = {B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111}; // bits for special character 7/8 919 | const byte square_three_07[8] PROGMEM = {B11100,B11100,B11100,B11100,B11100,B11100,B11111,B11111}; // bits for special character 8/8 920 | 921 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 922 | byte square_three_digits[10][4] = { {255,255,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 923 | 924 | // switch font = set special characters and populate current_font_digits with digits from the selected font 925 | void set_font_square_three () { 926 | for (int i=0; i<10; i++) { 927 | for (int j=0; j<4; j++) { 928 | current_font_digits[i][j] = square_three_digits[i][j]; 929 | } 930 | } 931 | memcpy_P(buffer,square_three_00, 8); 932 | lcd.createChar(0 , buffer); 933 | memcpy_P(buffer,square_three_01, 8); 934 | lcd.createChar(1 , buffer); 935 | memcpy_P(buffer,square_three_02, 8); 936 | lcd.createChar(2 , buffer); 937 | memcpy_P(buffer,square_three_03, 8); 938 | lcd.createChar(3 , buffer); 939 | memcpy_P(buffer,square_three_04, 8); 940 | lcd.createChar(4 , buffer); 941 | memcpy_P(buffer,square_three_05, 8); 942 | lcd.createChar(5 , buffer); 943 | memcpy_P(buffer,square_three_06, 8); 944 | lcd.createChar(6 , buffer); 945 | memcpy_P(buffer,square_three_07, 8); 946 | lcd.createChar(7 , buffer); 947 | } 948 | 949 | 950 | 951 | 952 | // set eight special characters for the font: square_four - updated to be stored in program memory to save some space 953 | const byte square_four_00[8] PROGMEM = {B11111,B11111,B11100,B11100,B00000,B00000,B00000,B00000}; // bits for special character 1/8 954 | const byte square_four_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B11100,B11100,B11111,B11111}; // bits for special character 2/8 955 | const byte square_four_02[8] PROGMEM = {B11111,B11111,B01111,B01111,B01111,B01111,B11111,B11111}; // bits for special character 3/8 956 | const byte square_four_03[8] PROGMEM = {B11111,B11111,B11110,B11110,B11110,B11110,B11111,B11111}; // bits for special character 4/8 957 | const byte square_four_04[8] PROGMEM = {B00001,B00011,B00111,B01111,B00000,B00000,B00000,B00000}; // bits for special character 5/8 958 | const byte square_four_05[8] PROGMEM = {B11110,B11110,B11110,B11110,B11110,B11110,B11110,B11110}; // bits for special character 6/8 959 | const byte square_four_06[8] PROGMEM = {B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111}; // bits for special character 7/8 960 | const byte square_four_07[8] PROGMEM = {B11110,B11110,B11110,B11110,B11110,B11110,B11111,B11111}; // bits for special character 8/8 961 | 962 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 963 | byte square_four_digits[10][4] = { {255,255,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 964 | 965 | // switch font = set special characters and populate current_font_digits with digits from the selected font 966 | void set_font_square_four () { 967 | for (int i=0; i<10; i++) { 968 | for (int j=0; j<4; j++) { 969 | current_font_digits[i][j] = square_four_digits[i][j]; 970 | } 971 | } 972 | memcpy_P(buffer,square_four_00, 8); 973 | lcd.createChar(0 , buffer); 974 | memcpy_P(buffer,square_four_01, 8); 975 | lcd.createChar(1 , buffer); 976 | memcpy_P(buffer,square_four_02, 8); 977 | lcd.createChar(2 , buffer); 978 | memcpy_P(buffer,square_four_03, 8); 979 | lcd.createChar(3 , buffer); 980 | memcpy_P(buffer,square_four_04, 8); 981 | lcd.createChar(4 , buffer); 982 | memcpy_P(buffer,square_four_05, 8); 983 | lcd.createChar(5 , buffer); 984 | memcpy_P(buffer,square_four_06, 8); 985 | lcd.createChar(6 , buffer); 986 | memcpy_P(buffer,square_four_07, 8); 987 | lcd.createChar(7 , buffer); 988 | } 989 | 990 | 991 | 992 | 993 | // set eight special characters for the font: square_five - updated to be stored in program memory to save some space 994 | const byte square_five_00[8] PROGMEM = {B11111,B11111,B11111,B11100,B00000,B00000,B00000,B00000}; // bits for special character 1/8 995 | const byte square_five_01[8] PROGMEM = {B00000,B00000,B00000,B00000,B11100,B11111,B11111,B11111}; // bits for special character 2/8 996 | const byte square_five_02[8] PROGMEM = {B11111,B11111,B11111,B01111,B01111,B11111,B11111,B11111}; // bits for special character 3/8 997 | const byte square_five_03[8] PROGMEM = {B11111,B11111,B11111,B11110,B11110,B11111,B11111,B11111}; // bits for special character 4/8 998 | const byte square_five_04[8] PROGMEM = {B00001,B00011,B00111,B01111,B01111,B00000,B00000,B00000}; // bits for special character 5/8 999 | const byte square_five_05[8] PROGMEM = {B11110,B11110,B11110,B11110,B11110,B11110,B11110,B11110}; // bits for special character 6/8 1000 | const byte square_five_06[8] PROGMEM = {B11111,B11111,B11111,B00000,B00000,B11111,B11111,B11111}; // bits for special character 7/8 1001 | const byte square_five_07[8] PROGMEM = {B11110,B11110,B11110,B11110,B11110,B11111,B11111,B11111}; // bits for special character 8/8 1002 | 1003 | // special character used for the individual digits, each digit is made from 4 special characters. Character 254 is empty, character 255 is fully filled rectangle 1004 | byte square_five_digits[10][4] = { {255,255,3,2}, { 4,5,254,5}, { 6,2,3,6}, { 0,2,1,2}, { 7,1,254,5}, { 3,6,6,2}, { 3,6,3,2}, { 0,2,254,5}, { 3,2,3,2}, { 3,2,6,2 } }; 1005 | 1006 | // switch font = set special characters and populate current_font_digits with digits from the selected font 1007 | void set_font_square_five () { 1008 | for (int i=0; i<10; i++) { 1009 | for (int j=0; j<4; j++) { 1010 | current_font_digits[i][j] = square_five_digits[i][j]; 1011 | } 1012 | } 1013 | memcpy_P(buffer,square_five_00, 8); 1014 | lcd.createChar(0 , buffer); 1015 | memcpy_P(buffer,square_five_01, 8); 1016 | lcd.createChar(1 , buffer); 1017 | memcpy_P(buffer,square_five_02, 8); 1018 | lcd.createChar(2 , buffer); 1019 | memcpy_P(buffer,square_five_03, 8); 1020 | lcd.createChar(3 , buffer); 1021 | memcpy_P(buffer,square_five_04, 8); 1022 | lcd.createChar(4 , buffer); 1023 | memcpy_P(buffer,square_five_05, 8); 1024 | lcd.createChar(5 , buffer); 1025 | memcpy_P(buffer,square_five_06, 8); 1026 | lcd.createChar(6 , buffer); 1027 | memcpy_P(buffer,square_five_07, 8); 1028 | lcd.createChar(7 , buffer); 1029 | } 1030 | 1031 | 1032 | 1033 | 1034 | // ------------------------------------------------------------------------------------------------------ 1035 | // end copy from Excel 1036 | 1037 | 1038 | 1039 | 1040 | // draw_big_digits is only needed once in the sketch 1041 | // this function draws a single digit on the xpos, ypos, taking 2x2 cells (using 4 special characters) 1042 | // before calling this function, make sure to set the font to populate the current_font_digits array and set special characters 1043 | void draw_big_digit(byte digit, byte xpos, byte ypos) { 1044 | lcd.setCursor(xpos,ypos); 1045 | lcd.write(current_font_digits[digit][0]); 1046 | lcd.write(current_font_digits[digit][1]); 1047 | lcd.setCursor(xpos,ypos+1); 1048 | lcd.write(current_font_digits[digit][2]); 1049 | lcd.write(current_font_digits[digit][3]); 1050 | } 1051 | // ------------------------------------------------------------------------------------------------------ 1052 | 1053 | 1054 | 1055 | void setup() { 1056 | lcd.init(); // initialize the 16x2 lcd module 1057 | lcd.backlight(); // enable backlight for the LCD module 1058 | } 1059 | 1060 | int counter; // counter to switch between the fonts 1061 | 1062 | 1063 | void loop() { 1064 | 1065 | // switching between fonts 1066 | // it´s done like this, because I thought that for a real project, you will only use perhaps one or two font styles and delete the rest 1067 | 1068 | counter++; 1069 | if (counter > 24) {counter=1;} 1070 | 1071 | lcd.clear(); // clear LCD before switching font 1072 | 1073 | // set one of the 24 provided fonts... 1074 | switch (counter) { 1075 | case 1: 1076 | set_font_real(); 1077 | break; 1078 | case 2: 1079 | set_font_real_bold(); 1080 | break; 1081 | case 3: 1082 | set_font_rounded(); 1083 | break; 1084 | case 4: 1085 | set_font_rounded_bold(); 1086 | break; 1087 | case 5: 1088 | set_font_skewed(); 1089 | break; 1090 | case 6: 1091 | set_font_skewed_bold(); 1092 | break; 1093 | case 7: 1094 | set_font_dots_small(); 1095 | break; 1096 | case 8: 1097 | set_font_dots_big(); 1098 | break; 1099 | case 9: 1100 | set_font_dashed(); 1101 | break; 1102 | case 10: 1103 | set_font_dashed_bold(); 1104 | break; 1105 | case 11: 1106 | set_font_angled(); 1107 | break; 1108 | case 12: 1109 | set_font_angled_bold(); 1110 | break; 1111 | case 13: 1112 | set_font_blocks(); 1113 | break; 1114 | case 14: 1115 | set_font_blocks_crossed(); 1116 | break; 1117 | case 15: 1118 | set_font_blocks_cut(); 1119 | break; 1120 | case 16: 1121 | set_font_classic(); 1122 | break; 1123 | case 17: 1124 | set_font_classic_bold(); 1125 | break; 1126 | case 18: 1127 | set_font_classic_serif(); 1128 | break; 1129 | case 19: 1130 | set_font_tron(); 1131 | break; 1132 | case 20: 1133 | set_font_tron_bold(); 1134 | break; 1135 | case 21: 1136 | set_font_square_two(); 1137 | break; 1138 | case 22: 1139 | set_font_square_three(); 1140 | break; 1141 | case 23: 1142 | set_font_square_four(); 1143 | break; 1144 | case 24: 1145 | set_font_square_five(); 1146 | break; 1147 | default: 1148 | // if nothing else matches, do the default 1149 | break; 1150 | } 1151 | 1152 | 1153 | // draw five digits, wait a second, draw another five digits, wait a second, switch font, repeat... 1154 | 1155 | draw_big_digit(0, 1, 0); // draw digit 0 1156 | draw_big_digit(1, 4, 0); // draw digit 1 1157 | draw_big_digit(2, 7, 0); // draw digit 2 1158 | draw_big_digit(3, 10, 0); // draw digit 3 1159 | draw_big_digit(4, 13, 0); // draw digit 4 1160 | 1161 | delay(1000); // wait one second 1162 | 1163 | draw_big_digit(5, 1, 0); // draw digit 5 1164 | draw_big_digit(6, 4, 0); // draw digit 6 1165 | draw_big_digit(7, 7, 0); // draw digit 7 1166 | draw_big_digit(8, 10, 0); // draw digit 8 1167 | draw_big_digit(9, 13, 0); // draw digit 9 1168 | 1169 | delay(1000); // wait one second 1170 | 1171 | 1172 | 1173 | } 1174 | --------------------------------------------------------------------------------