diff --git a/Boards/LilygoTdeck/Source/hal/TdeckDisplay.cpp b/Boards/LilygoTdeck/Source/hal/TdeckDisplay.cpp index 246b62f9..8910a233 100644 --- a/Boards/LilygoTdeck/Source/hal/TdeckDisplay.cpp +++ b/Boards/LilygoTdeck/Source/hal/TdeckDisplay.cpp @@ -87,7 +87,7 @@ bool TdeckDisplay::start() { const esp_lcd_panel_dev_config_t panel_config = { .reset_gpio_num = GPIO_NUM_NC, .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, - .data_endian = LCD_RGB_DATA_ENDIAN_BIG, + .data_endian = LCD_RGB_DATA_ENDIAN_LITTLE, .bits_per_pixel = TDECK_LCD_BITS_PER_PIXEL, .flags = { .reset_active_high = 0 @@ -148,7 +148,7 @@ bool TdeckDisplay::start() { .buff_dma = false, .buff_spiram = true, .sw_rotate = false, - .swap_bytes = true + .swap_bytes = false }, }; diff --git a/Boards/LilygoTdeck/Source/hal/TdeckPower.cpp b/Boards/LilygoTdeck/Source/hal/TdeckPower.cpp index ef8a0bba..834d074f 100644 --- a/Boards/LilygoTdeck/Source/hal/TdeckPower.cpp +++ b/Boards/LilygoTdeck/Source/hal/TdeckPower.cpp @@ -6,13 +6,9 @@ #define TAG "power" /** - * The ratio of the voltage divider is supposedly 2.0, but when we set that, the ADC reports a bit over 4.45V - * when charging the device. - * There was also supposedly a +0.11 sag compensation related to "display under-voltage" according to Meshtastic firmware. - * Either Meshtastic implemented it incorrectly OR there is simply a 5-10% deviation in accuracy. - * The latter is feasible as the selected resistors for the voltage divider might not have been matched appropriately. + * 2.0 ratio, but +.11 added as display voltage sag compensation. */ -#define ADC_MULTIPLIER 1.89f +#define ADC_MULTIPLIER 2.11 #define ADC_REF_VOLTAGE 3.3f #define BATTERY_VOLTAGE_MIN 3.2f diff --git a/Boards/YellowBoard/Source/hal/YellowDisplay.cpp b/Boards/YellowBoard/Source/hal/YellowDisplay.cpp index a93d97f3..17705773 100644 --- a/Boards/YellowBoard/Source/hal/YellowDisplay.cpp +++ b/Boards/YellowBoard/Source/hal/YellowDisplay.cpp @@ -72,8 +72,8 @@ bool YellowDisplay::start() { const esp_lcd_panel_dev_config_t panel_config = { .reset_gpio_num = GPIO_NUM_NC, - .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_BGR, - .data_endian = LCD_RGB_DATA_ENDIAN_BIG, + .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB, + .data_endian = LCD_RGB_DATA_ENDIAN_LITTLE, .bits_per_pixel = TWODOTFOUR_LCD_BITS_PER_PIXEL, .flags = { .reset_active_high = false @@ -123,7 +123,7 @@ bool YellowDisplay::start() { .buff_dma = true, .buff_spiram = false, .sw_rotate = false, - .swap_bytes = true + .swap_bytes = false } }; diff --git a/CMakeLists.txt b/CMakeLists.txt index d03fada9..4cb725c3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -30,6 +30,7 @@ if (DEFINED ENV{ESP_IDF_VERSION}) "Libraries/lv_screenshot" "Libraries/M5Unified" "Libraries/M5GFX" + "Libraries/QRCode" ) set(EXCLUDE_COMPONENTS "Simulator") @@ -54,6 +55,9 @@ if (DEFINED ENV{ESP_IDF_VERSION}) LVGL_CONFIG_FULL_PATH Libraries/lvgl_conf ABSOLUTE ) add_compile_definitions(LV_CONF_PATH=${LVGL_CONFIG_FULL_PATH}/lv_conf_kconfig.h) + idf_build_set_property(LINK_OPTIONS "-Wl,--wrap=esp_panic_handler" APPEND) + + add_compile_definitions(TT_VERSION="alpha1") else() message("Building for sim target") endif() @@ -75,6 +79,7 @@ if (NOT DEFINED ENV{ESP_IDF_VERSION}) set(FREERTOS_PORT GCC_POSIX CACHE STRING "") add_subdirectory(Libraries/FreeRTOS-Kernel) add_subdirectory(Libraries/lv_screenshot) + add_subdirectory(Libraries/QRCode) target_compile_definitions(freertos_kernel PUBLIC "projCOVERAGE_TEST=0") target_include_directories(freertos_kernel PUBLIC Boards/Simulator/Source # for FreeRTOSConfig.h diff --git a/COPYRIGHT.md b/COPYRIGHT.md index 6b582f37..a51d614a 100644 --- a/COPYRIGHT.md +++ b/COPYRIGHT.md @@ -18,7 +18,7 @@ License: [GPL v3.0](https://github.com/espressif/esp-idf/blob/master/LICENSE) ### Flipper Zero Firmware -Some of the code in this project has been adapted from the Flipper Zero firmware. +Some of the code in this project has originally been adapted from the Flipper Zero firmware. It was changed to fit the Tactility project. Website: https://github.com/flipperdevices/flipperzero-firmware/ @@ -31,6 +31,12 @@ Website: https://fonts.google.com/icons License: [Apache License, version 2.0](https://fonts.google.com/attribution) +### Google Material Design & Icons + +Website: https://fonts.google.com/icons + +License: Multiple (SIL Open Font License, Apache License, Ubuntu Font License): https://developers.google.com/fonts/faq + ### Other Components See `/components` for the respective projects and their licenses. diff --git a/Documentation/ideas.md b/Documentation/ideas.md index 49f7b27a..fdd37b89 100644 --- a/Documentation/ideas.md +++ b/Documentation/ideas.md @@ -1,6 +1,12 @@ # TODOs -- Crash logs stored on sdcard or elsewhere: perhaps show crash screen after recovering from crash (with QR code? https://github.com/ricmoo/QRCode) -- Logging +- Attach ELF data to wrapper app (as app data) (check that app state is "running"!) so you can run more than 1 external apps at a time. +- T-Deck: Clear screen before turning on blacklight +- Single wire audio +- Audio recording app +- Files app: file operations: rename, delete, copy, paste (long press?), create folder +- T-Deck: Use knob for UI selection +- Logging to disk/etc. +- Crash monitoring: Keep track of which system phase the app crashed in (e.g. which app in which state) - AppContext's onResult should pass the app id (or launch request id!) that was started, so we can differentiate between multiple types of apps being launched - Loader: Use Timer instead of Thread, and move API to `tt::app::` - Gpio: Use Timer instead of Thread @@ -14,7 +20,7 @@ - Show a warning screen if firmware encryption or secure boot are off when saving WiFi credentials. - Show a warning screen when a user plugs in the SD card on a device that only supports mounting at boot. - Check service/app id on registration to see if it is a duplicate id -- Fix screenshot app on ESP32: it currently blocks when allocating memory +- Fix screenshot app on ESP32: it currently blocks when allocating memory (its cmakelists.txt also needs a fix, see TODO in there) - Localisation of texts (load in boot app from sd?) - Portrait support for GPIO app - Explore LVGL9's FreeRTOS functionality @@ -27,6 +33,7 @@ - External app loading: Check version of Tactility and check ESP target hardware, to check for compatibility. - hal::Configuration: Replace CreateX fields with plain instances - T-Deck Power: capacity estimation uses linear voltage curve, but it should use some sort of battery discharge curve. +- Consider scanning SD card for external apps and auto-register them (in a temporary register?) # Core Ideas - Support for displays with different DPI. Consider the layer-based system like on Android. @@ -44,3 +51,4 @@ - IR transceiver app - GPS app - Investigate CSI https://stevenmhernandez.github.io/ESP32-CSI-Tool/ +- Compile unix tools to ELF apps? diff --git a/Libraries/QRCode/.gitignore b/Libraries/QRCode/.gitignore new file mode 100644 index 00000000..e43b0f98 --- /dev/null +++ b/Libraries/QRCode/.gitignore @@ -0,0 +1 @@ +.DS_Store diff --git a/Libraries/QRCode/CMakeLists.txt b/Libraries/QRCode/CMakeLists.txt new file mode 100644 index 00000000..1ae269c9 --- /dev/null +++ b/Libraries/QRCode/CMakeLists.txt @@ -0,0 +1,30 @@ +cmake_minimum_required(VERSION 3.20) + +if (DEFINED ENV{ESP_IDF_VERSION}) + file(GLOB_RECURSE SOURCE_FILES src/*.c) + + idf_component_register( + SRCS ${SOURCE_FILES} + INCLUDE_DIRS "src/" + ) + + add_definitions(-DESP_PLATFORM) + + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PUBLIC -Wno-unknown-pragmas) + endif() +else() + file(GLOB SOURCES "src/*.c") + file(GLOB HEADERS "src/*.h") + + add_library(QRCode STATIC) + + target_sources(QRCode + PRIVATE ${SOURCES} + PUBLIC ${HEADERS} + ) + + target_include_directories(QRCode + PUBLIC src + ) +endif() diff --git a/Libraries/QRCode/LICENSE.txt b/Libraries/QRCode/LICENSE.txt new file mode 100644 index 00000000..d59dd4da --- /dev/null +++ b/Libraries/QRCode/LICENSE.txt @@ -0,0 +1,26 @@ +The MIT License (MIT) + +This library is written and maintained by Richard Moore. +Major parts were derived from Project Nayuki's library. + +Copyright (c) 2017 Richard Moore (https://github.com/ricmoo/QRCode) +Copyright (c) 2017 Project Nayuki (https://www.nayuki.io/page/qr-code-generator-library) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/Libraries/QRCode/README.md b/Libraries/QRCode/README.md new file mode 100644 index 00000000..3fc59d0a --- /dev/null +++ b/Libraries/QRCode/README.md @@ -0,0 +1,677 @@ +QRCode +====== + +A simple library for generating [QR codes](https://en.wikipedia.org/wiki/QR_code) in C, +optimized for processing and memory constrained systems. + +**Features:** + +- Stack-based (no heap necessary; but you can use heap if you want) +- Low-memory foot print (relatively) +- Compile-time stripping of unecessary logic and constants +- MIT License; do with this as you please + + +Installing +---------- + +To install this library, download and save it to your Arduino libraries directory. + +Rename the directory to QRCode (if downloaded from GitHub, the filename may be +qrcode-master; library names may not contain the hyphen, so it must be renamed) + + +API +--- + +**Generate a QR Code** + +```c +// The structure to manage the QR code +QRCode qrcode; + +// Allocate a chunk of memory to store the QR code +uint8_t qrcodeBytes[qrcode_getBufferSize()]; + +qrcode_initText(&qrcode, qrcodeBytes, 3, ECC_LOW, "HELLO WORLD"); +``` + +**Draw a QR Code** + +How a QR code is used will vary greatly from project to project. For example: + +- Display on an OLED screen (128x64 nicely supports 2 side-by-side version 3 QR codes) +- Print as a bitmap on a thermal printer +- Store as a BMP (or with a some extra work, possibly a PNG) on an SD card + +The following example prints a QR code to the Serial Monitor (it likely will +not be scannable, but is just for demonstration purposes). + +```c +for (uint8 y = 0; y < qrcode.size; y++) { + for (uint8 x = 0; x < qrcode.size; x++) { + if (qrcode_getModule(&qrcode, x, y) { + Serial.print("**"); + } else { + Serial.print(" "); + } + } + Serial.print("\n"); +} +``` + + +What is Version, Error Correction and Mode? +------------------------------------------- + +A QR code is composed of many little squares, called **modules**, which represent +encoded data, with additional error correction (allowing partially damaged QR +codes to still be read). + +The **version** of a QR code is a number between 1 and 40 (inclusive), which indicates +the size of the QR code. The width and height of a QR code are always equal (it is +square) and are equal to `4 * version + 17`. + +The level of **error correction** is a number between 0 and 3 (inclusive), or can be +one of the symbolic names ECC_LOW, ECC_MEDIUM, ECC_QUARTILE and ECC_HIGH. Higher +levels of error correction sacrifice data capacity, but allow a larger portion of +the QR code to be damaged or unreadable. + +The **mode** of a QR code is determined by the data being encoded. Each mode is encoded +internally using a compact representation, so lower modes can contain more data. + +- **NUMERIC:** numbers (`0-9`) +- **ALPHANUMERIC:** uppercase letters (`A-Z`), numbers (`0-9`), the space (` `), dollar sign (`$`), percent sign (`%`), asterisk (`*`), plus (`+`), minus (`-`), decimal point (`.`), slash (`/`) and colon (`:`). +- **BYTE:** any character + + +Data Capacities +--------------- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VersionSizeError CorrectionMode
NumericAlphanumericByte
121 x 21LOW412517
MEDIUM342014
QUARTILE271611
HIGH17107
225 x 25LOW774732
MEDIUM633826
QUARTILE482920
HIGH342014
329 x 29LOW1277753
MEDIUM1016142
QUARTILE774732
HIGH583524
433 x 33LOW18711478
MEDIUM1499062
QUARTILE1116746
HIGH825034
537 x 37LOW255154106
MEDIUM20212284
QUARTILE1448760
HIGH1066444
641 x 41LOW322195134
MEDIUM255154106
QUARTILE17810874
HIGH1398458
745 x 45LOW370224154
MEDIUM293178122
QUARTILE20712586
HIGH1549364
849 x 49LOW461279192
MEDIUM365221152
QUARTILE259157108
HIGH20212284
953 x 53LOW552335230
MEDIUM432262180
QUARTILE312189130
HIGH23514398
1057 x 57LOW652395271
MEDIUM513311213
QUARTILE364221151
HIGH288174119
1161 x 61LOW772468321
MEDIUM604366251
QUARTILE427259177
HIGH331200137
1265 x 65LOW883535367
MEDIUM691419287
QUARTILE489296203
HIGH374227155
1369 x 69LOW1022619425
MEDIUM796483331
QUARTILE580352241
HIGH427259177
1473 x 73LOW1101667458
MEDIUM871528362
QUARTILE621376258
HIGH468283194
1577 x 77LOW1250758520
MEDIUM991600412
QUARTILE703426292
HIGH530321220
1681 x 81LOW1408854586
MEDIUM1082656450
QUARTILE775470322
HIGH602365250
1785 x 85LOW1548938644
MEDIUM1212734504
QUARTILE876531364
HIGH674408280
1889 x 89LOW17251046718
MEDIUM1346816560
QUARTILE948574394
HIGH746452310
1993 x 93LOW19031153792
MEDIUM1500909624
QUARTILE1063644442
HIGH813493338
2097 x 97LOW20611249858
MEDIUM1600970666
QUARTILE1159702482
HIGH919557382
21101 x 101LOW22321352929
MEDIUM17081035711
QUARTILE1224742509
HIGH969587403
22105 x 105LOW240914601003
MEDIUM18721134779
QUARTILE1358823565
HIGH1056640439
23109 x 109LOW262015881091
MEDIUM20591248857
QUARTILE1468890611
HIGH1108672461
24113 x 113LOW281217041171
MEDIUM21881326911
QUARTILE1588963661
HIGH1228744511
25117 x 117LOW305718531273
MEDIUM23951451997
QUARTILE17181041715
HIGH1286779535
26121 x 121LOW328319901367
MEDIUM254415421059
QUARTILE18041094751
HIGH1425864593
27125 x 125LOW351721321465
MEDIUM270116371125
QUARTILE19331172805
HIGH1501910625
28129 x 129LOW366922231528
MEDIUM285717321190
QUARTILE20851263868
HIGH1581958658
29133 x 133LOW390923691628
MEDIUM303518391264
QUARTILE21811322908
HIGH16771016698
30137 x 137LOW415825201732
MEDIUM328919941370
QUARTILE23581429982
HIGH17821080742
31141 x 141LOW441726771840
MEDIUM348621131452
QUARTILE247314991030
HIGH18971150790
32145 x 145LOW468628401952
MEDIUM369322381538
QUARTILE267016181112
HIGH20221226842
33149 x 149LOW496530092068
MEDIUM390923691628
QUARTILE280517001168
HIGH21571307898
34153 x 153LOW525331832188
MEDIUM413425061722
QUARTILE294917871228
HIGH23011394958
35157 x 157LOW552933512303
MEDIUM434326321809
QUARTILE308118671283
HIGH23611431983
36161 x 161LOW583635372431
MEDIUM458827801911
QUARTILE324419661351
HIGH252415301051
37165 x 165LOW615337292563
MEDIUM477528941989
QUARTILE341720711423
HIGH262515911093
38169 x 169LOW647939272699
MEDIUM503930542099
QUARTILE359921811499
HIGH273516581139
39173 x 173LOW674340872809
MEDIUM531332202213
QUARTILE379122981579
HIGH292717741219
40177 x 177LOW708942962953
MEDIUM559633912331
QUARTILE399324201663
HIGH305718521273
+ + +Special Thanks +-------------- + +A HUGE thank you to [Project Nayuki](https://www.nayuki.io/) for the +[QR code C++ library](https://github.com/nayuki/QR-Code-generator/tree/master/cpp) +which was critical in development of this library. + + +License +------- + +MIT License. diff --git a/Libraries/QRCode/examples/QRCode/QRCode.ino b/Libraries/QRCode/examples/QRCode/QRCode.ino new file mode 100644 index 00000000..9f6a6558 --- /dev/null +++ b/Libraries/QRCode/examples/QRCode/QRCode.ino @@ -0,0 +1,56 @@ +/** + * QRCode + * + * A quick example of generating a QR code. + * + * This prints the QR code to the serial monitor as solid blocks. Each module + * is two characters wide, since the monospace font used in the serial monitor + * is approximately twice as tall as wide. + * + */ + +#include "qrcode.h" + +void setup() { + Serial.begin(115200); + + // Start time + uint32_t dt = millis(); + + // Create the QR code + QRCode qrcode; + uint8_t qrcodeData[qrcode_getBufferSize(3)]; + qrcode_initText(&qrcode, qrcodeData, 3, 0, "HELLO WORLD"); + + // Delta time + dt = millis() - dt; + Serial.print("QR Code Generation Time: "); + Serial.print(dt); + Serial.print("\n"); + + // Top quiet zone + Serial.print("\n\n\n\n"); + + for (uint8_t y = 0; y < qrcode.size; y++) { + + // Left quiet zone + Serial.print(" "); + + // Each horizontal module + for (uint8_t x = 0; x < qrcode.size; x++) { + + // Print each module (UTF-8 \u2588 is a solid block) + Serial.print(qrcode_getModule(&qrcode, x, y) ? "\u2588\u2588": " "); + + } + + Serial.print("\n"); + } + + // Bottom quiet zone + Serial.print("\n\n\n\n"); +} + +void loop() { + +} diff --git a/Libraries/QRCode/generate_table.py b/Libraries/QRCode/generate_table.py new file mode 100644 index 00000000..d5d4003b --- /dev/null +++ b/Libraries/QRCode/generate_table.py @@ -0,0 +1,62 @@ +Data = [ + ["1", "41", "25", "17", "34", "20", "14","27", "16", "11","17", "10", "7"], + ["2", "77", "47", "32", "63", "38", "26", "48", "29", "20", "34", "20", "14"], + ["3", "127", "77", "53", "101", "61", "42", "77", "47", "32", "58", "35", "24"], + ["4", "187", "114", "78", "149", "90", "62", "111", "67", "46", "82", "50", "34"], + ["5", "255", "154", "106", "202", "122", "84", "144", "87", "60", "106", "64", "44"], + ["6", "322", "195", "134", "255", "154", "106", "178", "108", "74", "139", "84", "58"], + ["7", "370", "224", "154", "293", "178", "122", "207", "125", "86", "154", "93", "64"], + ["8", "461", "279", "192", "365", "221", "152", "259", "157", "108", "202", "122", "84"], + ["9", "552", "335", "230", "432", "262", "180", "312", "189", "130", "235", "143", "98"], + ["10", "652", "395", "271", "513", "311", "213", "364", "221", "151", "288", "174", "119"], + ["11", "772", "468", "321", "604", "366", "251", "427", "259", "177", "331", "200", "137"], + ["12", "883", "535", "367", "691", "419", "287", "489", "296", "203", "374", "227", "155"], + ["13", "1022", "619", "425", "796", "483", "331", "580", "352", "241", "427", "259", "177"], + ["14", "1101", "667", "458", "871", "528", "362", "621", "376", "258", "468", "283", "194"], + ["15", "1250", "758", "520", "991", "600", "412", "703", "426", "292", "530", "321", "220"], + ["16", "1408", "854", "586", "1082", "656", "450", "775", "470", "322", "602", "365", "250"], + ["17", "1548", "938", "644", "1212", "734", "504", "876", "531", "364", "674", "408", "280"], + ["18", "1725", "1046", "718", "1346", "816", "560", "948", "574", "394", "746", "452", "310"], + ["19", "1903", "1153", "792", "1500", "909", "624", "1063", "644", "442", "813", "493", "338"], + ["20", "2061", "1249", "858", "1600", "970", "666", "1159", "702", "482", "919", "557", "382"], + ["21", "2232", "1352", "929", "1708", "1035", "711", "1224", "742", "509", "969", "587", "403"], + ["22", "2409", "1460", "1003", "1872", "1134", "779", "1358", "823", "565", "1056", "640", "439"], + ["23", "2620", "1588", "1091", "2059", "1248", "857", "1468", "890", "611", "1108", "672", "461"], + ["24", "2812", "1704", "1171", "2188", "1326", "911", "1588", "963", "661", "1228", "744", "511"], + ["25", "3057", "1853", "1273", "2395", "1451", "997", "1718", "1041", "715", "1286", "779", "535"], + ["26", "3283", "1990", "1367", "2544", "1542", "1059", "1804", "1094", "751", "1425", "864", "593"], + ["27", "3517", "2132", "1465", "2701", "1637", "1125", "1933", "1172", "805", "1501", "910", "625"], + ["28", "3669", "2223", "1528", "2857", "1732", "1190", "2085", "1263", "868", "1581", "958", "658"], + ["29", "3909", "2369", "1628", "3035", "1839", "1264", "2181", "1322", "908", "1677", "1016", "698"], + ["30", "4158", "2520", "1732", "3289", "1994", "1370", "2358", "1429", "982", "1782", "1080", "742"], + ["31", "4417", "2677", "1840", "3486", "2113", "1452", "2473", "1499", "1030", "1897", "1150", "790"], + ["32", "4686", "2840", "1952", "3693", "2238", "1538", "2670", "1618", "1112", "2022", "1226", "842"], + ["33", "4965", "3009", "2068", "3909", "2369", "1628", "2805", "1700", "1168", "2157", "1307", "898"], + ["34", "5253", "3183", "2188", "4134", "2506", "1722", "2949", "1787", "1228", "2301", "1394", "958"], + ["35", "5529", "3351", "2303", "4343", "2632", "1809", "3081", "1867", "1283", "2361", "1431", "983"], + ["36", "5836", "3537", "2431", "4588", "2780", "1911", "3244", "1966", "1351", "2524", "1530", "1051"], + ["37", "6153", "3729", "2563", "4775", "2894", "1989", "3417", "2071", "1423", "2625", "1591", "1093"], + ["38", "6479", "3927", "2699", "5039", "3054", "2099", "3599", "2181", "1499", "2735", "1658", "1139"], + ["39", "6743", "4087", "2809", "5313", "3220", "2213", "3791", "2298", "1579", "2927", "1774", "1219"], + ["40", "7089", "4296", "2953", "5596", "3391", "2331", "3993", "2420", "1663", "3057", "1852", "1273"], +] +Template = ''' + %s + %s + LOW%s%s%s + + + MEDIUM%s%s%s + + + QUARTILE%s%s%s + + + HIGH%s%s%s + ''' + +for data in Data: + data = data[:] + size = 4 * int(data[0]) + 17 + data.insert(1, "%d x %d" % (size, size)) + print Template % tuple(data) diff --git a/Libraries/QRCode/keywords.txt b/Libraries/QRCode/keywords.txt new file mode 100644 index 00000000..013f8953 --- /dev/null +++ b/Libraries/QRCode/keywords.txt @@ -0,0 +1,31 @@ + +# Datatypes (KEYWORD1) + +bool KEYWORD1 +uint8_t KEYWORD1 +QRCode KEYWORD1 + + +# Methods and Functions (KEYWORD2) + +qrcode_getBufferSize KEYWORD2 +qrcode_initText KEYWORD2 +qrcode_initBytes KEYWORD2 +qrcode_getModule KEYWORD2 + + +# Instances (KEYWORD2) + + +# Constants (LITERAL1) + +false LITERAL1 +true LITERAL1 + +ECC_LOW LITERAL1 +ECC_MEDIUM LITERAL1 +ECC_QUARTILE LITERAL1 +ECC_HIGH LITERAL1 +MODE_NUMERIC LITERAL1 +MODE_ALPHANUMERIC LITERAL1 +MODE_BYTE LITERAL1 diff --git a/Libraries/QRCode/library.properties b/Libraries/QRCode/library.properties new file mode 100644 index 00000000..01fdca25 --- /dev/null +++ b/Libraries/QRCode/library.properties @@ -0,0 +1,10 @@ +name=QRCode +version=0.0.1 +author=Richard Moore +maintainer=Richard Moore +sentence=A simple QR code generation library. +paragraph=A simple QR code generation library. +category=Other +url=https://github.com/ricmoo/qrcode/ +architectures=* +includes=qrcode.h diff --git a/Libraries/QRCode/src/qrcode.c b/Libraries/QRCode/src/qrcode.c new file mode 100755 index 00000000..c182b355 --- /dev/null +++ b/Libraries/QRCode/src/qrcode.c @@ -0,0 +1,867 @@ +/** + * The MIT License (MIT) + * + * This library is written and maintained by Richard Moore. + * Major parts were derived from Project Nayuki's library. + * + * Copyright (c) 2017 Richard Moore (https://github.com/ricmoo/QRCode) + * Copyright (c) 2017 Project Nayuki (https://www.nayuki.io/page/qr-code-generator-library) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/** + * Special thanks to Nayuki (https://www.nayuki.io/) from which this library was + * heavily inspired and compared against. + * + * See: https://github.com/nayuki/QR-Code-generator/tree/master/cpp + */ + +#include "qrcode.h" + +#include +#include + + +#if LOCK_VERSION == 0 + +static const uint16_t NUM_ERROR_CORRECTION_CODEWORDS[4][40] = { + // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level + { 10, 16, 26, 36, 48, 64, 72, 88, 110, 130, 150, 176, 198, 216, 240, 280, 308, 338, 364, 416, 442, 476, 504, 560, 588, 644, 700, 728, 784, 812, 868, 924, 980, 1036, 1064, 1120, 1204, 1260, 1316, 1372}, // Medium + { 7, 10, 15, 20, 26, 36, 40, 48, 60, 72, 80, 96, 104, 120, 132, 144, 168, 180, 196, 224, 224, 252, 270, 300, 312, 336, 360, 390, 420, 450, 480, 510, 540, 570, 570, 600, 630, 660, 720, 750}, // Low + { 17, 28, 44, 64, 88, 112, 130, 156, 192, 224, 264, 308, 352, 384, 432, 480, 532, 588, 650, 700, 750, 816, 900, 960, 1050, 1110, 1200, 1260, 1350, 1440, 1530, 1620, 1710, 1800, 1890, 1980, 2100, 2220, 2310, 2430}, // High + { 13, 22, 36, 52, 72, 96, 108, 132, 160, 192, 224, 260, 288, 320, 360, 408, 448, 504, 546, 600, 644, 690, 750, 810, 870, 952, 1020, 1050, 1140, 1200, 1290, 1350, 1440, 1530, 1590, 1680, 1770, 1860, 1950, 2040}, // Quartile +}; + +static const uint8_t NUM_ERROR_CORRECTION_BLOCKS[4][40] = { + // Version: (note that index 0 is for padding, and is set to an illegal value) + // 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level + { 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49}, // Medium + { 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25}, // Low + { 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81}, // High + { 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68}, // Quartile +}; + +static const uint16_t NUM_RAW_DATA_MODULES[40] = { + // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 208, 359, 567, 807, 1079, 1383, 1568, 1936, 2336, 2768, 3232, 3728, 4256, 4651, 5243, 5867, 6523, + // 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 7211, 7931, 8683, 9252, 10068, 10916, 11796, 12708, 13652, 14628, 15371, 16411, 17483, 18587, + // 32, 33, 34, 35, 36, 37, 38, 39, 40 + 19723, 20891, 22091, 23008, 24272, 25568, 26896, 28256, 29648 +}; + +// @TODO: Put other LOCK_VERSIONS here +#elif LOCK_VERSION == 3 + +static const int16_t NUM_ERROR_CORRECTION_CODEWORDS[4] = { + 26, 15, 44, 36 +}; + +static const int8_t NUM_ERROR_CORRECTION_BLOCKS[4] = { + 1, 1, 2, 2 +}; + +static const uint16_t NUM_RAW_DATA_MODULES = 567; + +#else + +#error Unsupported LOCK_VERSION (add it...) + +#endif + + +static int max(int a, int b) { + if (a > b) { return a; } + return b; +} + +/* +static int abs(int value) { + if (value < 0) { return -value; } + return value; +} +*/ + + + +static int8_t getAlphanumeric(char c) { + + if (c >= '0' && c <= '9') { return (c - '0'); } + if (c >= 'A' && c <= 'Z') { return (c - 'A' + 10); } + + switch (c) { + case ' ': return 36; + case '$': return 37; + case '%': return 38; + case '*': return 39; + case '+': return 40; + case '-': return 41; + case '.': return 42; + case '/': return 43; + case ':': return 44; + } + + return -1; +} + +static bool isAlphanumeric(const char *text, uint16_t length) { + while (length != 0) { + if (getAlphanumeric(text[--length]) == -1) { return false; } + } + return true; +} + + +static bool isNumeric(const char *text, uint16_t length) { + while (length != 0) { + char c = text[--length]; + if (c < '0' || c > '9') { return false; } + } + return true; +} + + + +// We store the following tightly packed (less 8) in modeInfo +// <=9 <=26 <= 40 +// NUMERIC ( 10, 12, 14); +// ALPHANUMERIC ( 9, 11, 13); +// BYTE ( 8, 16, 16); +static char getModeBits(uint8_t version, uint8_t mode) { + // Note: We use 15 instead of 16; since 15 doesn't exist and we cannot store 16 (8 + 8) in 3 bits + // hex(int("".join(reversed([('00' + bin(x - 8)[2:])[-3:] for x in [10, 9, 8, 12, 11, 15, 14, 13, 15]])), 2)) + unsigned int modeInfo = 0x7bbb80a; + +#if LOCK_VERSION == 0 || LOCK_VERSION > 9 + if (version > 9) { modeInfo >>= 9; } +#endif + +#if LOCK_VERSION == 0 || LOCK_VERSION > 26 + if (version > 26) { modeInfo >>= 9; } +#endif + + char result = 8 + ((modeInfo >> (3 * mode)) & 0x07); + if (result == 15) { result = 16; } + + return result; +} + + + +typedef struct BitBucket { + uint32_t bitOffsetOrWidth; + uint16_t capacityBytes; + uint8_t *data; +} BitBucket; + +/* +void bb_dump(BitBucket *bitBuffer) { + printf("Buffer: "); + for (uint32_t i = 0; i < bitBuffer->capacityBytes; i++) { + printf("%02x", bitBuffer->data[i]); + if ((i % 4) == 3) { printf(" "); } + } + printf("\n"); +} +*/ + +static uint16_t bb_getGridSizeBytes(uint8_t size) { + return (((size * size) + 7) / 8); +} + +static uint16_t bb_getBufferSizeBytes(uint32_t bits) { + return ((bits + 7) / 8); +} + +static void bb_initBuffer(BitBucket *bitBuffer, uint8_t *data, int32_t capacityBytes) { + bitBuffer->bitOffsetOrWidth = 0; + bitBuffer->capacityBytes = capacityBytes; + bitBuffer->data = data; + + memset(data, 0, bitBuffer->capacityBytes); +} + +static void bb_initGrid(BitBucket *bitGrid, uint8_t *data, uint8_t size) { + bitGrid->bitOffsetOrWidth = size; + bitGrid->capacityBytes = bb_getGridSizeBytes(size); + bitGrid->data = data; + + memset(data, 0, bitGrid->capacityBytes); +} + +static void bb_appendBits(BitBucket *bitBuffer, uint32_t val, uint8_t length) { + uint32_t offset = bitBuffer->bitOffsetOrWidth; + for (int8_t i = length - 1; i >= 0; i--, offset++) { + bitBuffer->data[offset >> 3] |= ((val >> i) & 1) << (7 - (offset & 7)); + } + bitBuffer->bitOffsetOrWidth = offset; +} +/* +void bb_setBits(BitBucket *bitBuffer, uint32_t val, int offset, uint8_t length) { + for (int8_t i = length - 1; i >= 0; i--, offset++) { + bitBuffer->data[offset >> 3] |= ((val >> i) & 1) << (7 - (offset & 7)); + } +} +*/ +static void bb_setBit(BitBucket *bitGrid, uint8_t x, uint8_t y, bool on) { + uint32_t offset = y * bitGrid->bitOffsetOrWidth + x; + uint8_t mask = 1 << (7 - (offset & 0x07)); + if (on) { + bitGrid->data[offset >> 3] |= mask; + } else { + bitGrid->data[offset >> 3] &= ~mask; + } +} + +static void bb_invertBit(BitBucket *bitGrid, uint8_t x, uint8_t y, bool invert) { + uint32_t offset = y * bitGrid->bitOffsetOrWidth + x; + uint8_t mask = 1 << (7 - (offset & 0x07)); + bool on = ((bitGrid->data[offset >> 3] & (1 << (7 - (offset & 0x07)))) != 0); + if (on ^ invert) { + bitGrid->data[offset >> 3] |= mask; + } else { + bitGrid->data[offset >> 3] &= ~mask; + } +} + +static bool bb_getBit(BitBucket *bitGrid, uint8_t x, uint8_t y) { + uint32_t offset = y * bitGrid->bitOffsetOrWidth + x; + return (bitGrid->data[offset >> 3] & (1 << (7 - (offset & 0x07)))) != 0; +} + + + +// XORs the data modules in this QR Code with the given mask pattern. Due to XOR's mathematical +// properties, calling applyMask(m) twice with the same value is equivalent to no change at all. +// This means it is possible to apply a mask, undo it, and try another mask. Note that a final +// well-formed QR Code symbol needs exactly one mask applied (not zero, not two, etc.). +static void applyMask(BitBucket *modules, BitBucket *isFunction, uint8_t mask) { + uint8_t size = modules->bitOffsetOrWidth; + + for (uint8_t y = 0; y < size; y++) { + for (uint8_t x = 0; x < size; x++) { + if (bb_getBit(isFunction, x, y)) { continue; } + + bool invert = 0; + switch (mask) { + case 0: invert = (x + y) % 2 == 0; break; + case 1: invert = y % 2 == 0; break; + case 2: invert = x % 3 == 0; break; + case 3: invert = (x + y) % 3 == 0; break; + case 4: invert = (x / 3 + y / 2) % 2 == 0; break; + case 5: invert = x * y % 2 + x * y % 3 == 0; break; + case 6: invert = (x * y % 2 + x * y % 3) % 2 == 0; break; + case 7: invert = ((x + y) % 2 + x * y % 3) % 2 == 0; break; + } + bb_invertBit(modules, x, y, invert); + } + } +} + +static void setFunctionModule(BitBucket *modules, BitBucket *isFunction, uint8_t x, uint8_t y, bool on) { + bb_setBit(modules, x, y, on); + bb_setBit(isFunction, x, y, true); +} + +// Draws a 9*9 finder pattern including the border separator, with the center module at (x, y). +static void drawFinderPattern(BitBucket *modules, BitBucket *isFunction, uint8_t x, uint8_t y) { + uint8_t size = modules->bitOffsetOrWidth; + + for (int8_t i = -4; i <= 4; i++) { + for (int8_t j = -4; j <= 4; j++) { + uint8_t dist = max(abs(i), abs(j)); // Chebyshev/infinity norm + int16_t xx = x + j, yy = y + i; + if (0 <= xx && xx < size && 0 <= yy && yy < size) { + setFunctionModule(modules, isFunction, xx, yy, dist != 2 && dist != 4); + } + } + } +} + +// Draws a 5*5 alignment pattern, with the center module at (x, y). +static void drawAlignmentPattern(BitBucket *modules, BitBucket *isFunction, uint8_t x, uint8_t y) { + for (int8_t i = -2; i <= 2; i++) { + for (int8_t j = -2; j <= 2; j++) { + setFunctionModule(modules, isFunction, x + j, y + i, max(abs(i), abs(j)) != 1); + } + } +} + +// Draws two copies of the format bits (with its own error correction code) +// based on the given mask and this object's error correction level field. +static void drawFormatBits(BitBucket *modules, BitBucket *isFunction, uint8_t ecc, uint8_t mask) { + + uint8_t size = modules->bitOffsetOrWidth; + + // Calculate error correction code and pack bits + uint32_t data = ecc << 3 | mask; // errCorrLvl is uint2, mask is uint3 + uint32_t rem = data; + for (int i = 0; i < 10; i++) { + rem = (rem << 1) ^ ((rem >> 9) * 0x537); + } + + data = data << 10 | rem; + data ^= 0x5412; // uint15 + + // Draw first copy + for (uint8_t i = 0; i <= 5; i++) { + setFunctionModule(modules, isFunction, 8, i, ((data >> i) & 1) != 0); + } + + setFunctionModule(modules, isFunction, 8, 7, ((data >> 6) & 1) != 0); + setFunctionModule(modules, isFunction, 8, 8, ((data >> 7) & 1) != 0); + setFunctionModule(modules, isFunction, 7, 8, ((data >> 8) & 1) != 0); + + for (int8_t i = 9; i < 15; i++) { + setFunctionModule(modules, isFunction, 14 - i, 8, ((data >> i) & 1) != 0); + } + + // Draw second copy + for (int8_t i = 0; i <= 7; i++) { + setFunctionModule(modules, isFunction, size - 1 - i, 8, ((data >> i) & 1) != 0); + } + + for (int8_t i = 8; i < 15; i++) { + setFunctionModule(modules, isFunction, 8, size - 15 + i, ((data >> i) & 1) != 0); + } + + setFunctionModule(modules, isFunction, 8, size - 8, true); +} + + +// Draws two copies of the version bits (with its own error correction code), +// based on this object's version field (which only has an effect for 7 <= version <= 40). +static void drawVersion(BitBucket *modules, BitBucket *isFunction, uint8_t version) { + + int8_t size = modules->bitOffsetOrWidth; + +#if LOCK_VERSION != 0 && LOCK_VERSION < 7 + return; + +#else + if (version < 7) { return; } + + // Calculate error correction code and pack bits + uint32_t rem = version; // version is uint6, in the range [7, 40] + for (uint8_t i = 0; i < 12; i++) { + rem = (rem << 1) ^ ((rem >> 11) * 0x1F25); + } + + uint32_t data = version << 12 | rem; // uint18 + + // Draw two copies + for (uint8_t i = 0; i < 18; i++) { + bool bit = ((data >> i) & 1) != 0; + uint8_t a = size - 11 + i % 3, b = i / 3; + setFunctionModule(modules, isFunction, a, b, bit); + setFunctionModule(modules, isFunction, b, a, bit); + } + +#endif +} + +static void drawFunctionPatterns(BitBucket *modules, BitBucket *isFunction, uint8_t version, uint8_t ecc) { + + uint8_t size = modules->bitOffsetOrWidth; + + // Draw the horizontal and vertical timing patterns + for (uint8_t i = 0; i < size; i++) { + setFunctionModule(modules, isFunction, 6, i, i % 2 == 0); + setFunctionModule(modules, isFunction, i, 6, i % 2 == 0); + } + + // Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules) + drawFinderPattern(modules, isFunction, 3, 3); + drawFinderPattern(modules, isFunction, size - 4, 3); + drawFinderPattern(modules, isFunction, 3, size - 4); + +#if LOCK_VERSION == 0 || LOCK_VERSION > 1 + + if (version > 1) { + + // Draw the numerous alignment patterns + + uint8_t alignCount = version / 7 + 2; + uint8_t step; + if (version != 32) { + step = (version * 4 + alignCount * 2 + 1) / (2 * alignCount - 2) * 2; // ceil((size - 13) / (2*numAlign - 2)) * 2 + } else { // C-C-C-Combo breaker! + step = 26; + } + + uint8_t alignPositionIndex = alignCount - 1; + uint8_t alignPosition[alignCount]; + + alignPosition[0] = 6; + + uint8_t size = version * 4 + 17; + for (uint8_t i = 0, pos = size - 7; i < alignCount - 1; i++, pos -= step) { + alignPosition[alignPositionIndex--] = pos; + } + + for (uint8_t i = 0; i < alignCount; i++) { + for (uint8_t j = 0; j < alignCount; j++) { + if ((i == 0 && j == 0) || (i == 0 && j == alignCount - 1) || (i == alignCount - 1 && j == 0)) { + continue; // Skip the three finder corners + } else { + drawAlignmentPattern(modules, isFunction, alignPosition[i], alignPosition[j]); + } + } + } + } + +#endif + + // Draw configuration data + drawFormatBits(modules, isFunction, ecc, 0); // Dummy mask value; overwritten later in the constructor + drawVersion(modules, isFunction, version); +} + + +// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire +// data area of this QR Code symbol. Function modules need to be marked off before this is called. +static void drawCodewords(BitBucket *modules, BitBucket *isFunction, BitBucket *codewords) { + + uint32_t bitLength = codewords->bitOffsetOrWidth; + uint8_t *data = codewords->data; + + uint8_t size = modules->bitOffsetOrWidth; + + // Bit index into the data + uint32_t i = 0; + + // Do the funny zigzag scan + for (int16_t right = size - 1; right >= 1; right -= 2) { // Index of right column in each column pair + if (right == 6) { right = 5; } + + for (uint8_t vert = 0; vert < size; vert++) { // Vertical counter + for (int j = 0; j < 2; j++) { + uint8_t x = right - j; // Actual x coordinate + bool upwards = ((right & 2) == 0) ^ (x < 6); + uint8_t y = upwards ? size - 1 - vert : vert; // Actual y coordinate + if (!bb_getBit(isFunction, x, y) && i < bitLength) { + bb_setBit(modules, x, y, ((data[i >> 3] >> (7 - (i & 7))) & 1) != 0); + i++; + } + // If there are any remainder bits (0 to 7), they are already + // set to 0/false/white when the grid of modules was initialized + } + } + } +} + + + + +#define PENALTY_N1 3 +#define PENALTY_N2 3 +#define PENALTY_N3 40 +#define PENALTY_N4 10 + +// Calculates and returns the penalty score based on state of this QR Code's current modules. +// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score. +// @TODO: This can be optimized by working with the bytes instead of bits. +static uint32_t getPenaltyScore(BitBucket *modules) { + uint32_t result = 0; + + uint8_t size = modules->bitOffsetOrWidth; + + // Adjacent modules in row having same color + for (uint8_t y = 0; y < size; y++) { + + bool colorX = bb_getBit(modules, 0, y); + for (uint8_t x = 1, runX = 1; x < size; x++) { + bool cx = bb_getBit(modules, x, y); + if (cx != colorX) { + colorX = cx; + runX = 1; + + } else { + runX++; + if (runX == 5) { + result += PENALTY_N1; + } else if (runX > 5) { + result++; + } + } + } + } + + // Adjacent modules in column having same color + for (uint8_t x = 0; x < size; x++) { + bool colorY = bb_getBit(modules, x, 0); + for (uint8_t y = 1, runY = 1; y < size; y++) { + bool cy = bb_getBit(modules, x, y); + if (cy != colorY) { + colorY = cy; + runY = 1; + } else { + runY++; + if (runY == 5) { + result += PENALTY_N1; + } else if (runY > 5) { + result++; + } + } + } + } + + uint16_t black = 0; + for (uint8_t y = 0; y < size; y++) { + uint16_t bitsRow = 0, bitsCol = 0; + for (uint8_t x = 0; x < size; x++) { + bool color = bb_getBit(modules, x, y); + + // 2*2 blocks of modules having same color + if (x > 0 && y > 0) { + bool colorUL = bb_getBit(modules, x - 1, y - 1); + bool colorUR = bb_getBit(modules, x, y - 1); + bool colorL = bb_getBit(modules, x - 1, y); + if (color == colorUL && color == colorUR && color == colorL) { + result += PENALTY_N2; + } + } + + // Finder-like pattern in rows and columns + bitsRow = ((bitsRow << 1) & 0x7FF) | color; + bitsCol = ((bitsCol << 1) & 0x7FF) | bb_getBit(modules, y, x); + + // Needs 11 bits accumulated + if (x >= 10) { + if (bitsRow == 0x05D || bitsRow == 0x5D0) { + result += PENALTY_N3; + } + if (bitsCol == 0x05D || bitsCol == 0x5D0) { + result += PENALTY_N3; + } + } + + // Balance of black and white modules + if (color) { black++; } + } + } + + // Find smallest k such that (45-5k)% <= dark/total <= (55+5k)% + uint16_t total = size * size; + for (uint16_t k = 0; black * 20 < (9 - k) * total || black * 20 > (11 + k) * total; k++) { + result += PENALTY_N4; + } + + return result; +} + + + +static uint8_t rs_multiply(uint8_t x, uint8_t y) { + // Russian peasant multiplication + // See: https://en.wikipedia.org/wiki/Ancient_Egyptian_multiplication + uint16_t z = 0; + for (int8_t i = 7; i >= 0; i--) { + z = (z << 1) ^ ((z >> 7) * 0x11D); + z ^= ((y >> i) & 1) * x; + } + return z; +} + +static void rs_init(uint8_t degree, uint8_t *coeff) { + memset(coeff, 0, degree); + coeff[degree - 1] = 1; + + // Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}), + // drop the highest term, and store the rest of the coefficients in order of descending powers. + // Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D). + uint16_t root = 1; + for (uint8_t i = 0; i < degree; i++) { + // Multiply the current product by (x - r^i) + for (uint8_t j = 0; j < degree; j++) { + coeff[j] = rs_multiply(coeff[j], root); + if (j + 1 < degree) { + coeff[j] ^= coeff[j + 1]; + } + } + root = (root << 1) ^ ((root >> 7) * 0x11D); // Multiply by 0x02 mod GF(2^8/0x11D) + } +} + +static void rs_getRemainder(uint8_t degree, uint8_t *coeff, uint8_t *data, uint8_t length, uint8_t *result, uint8_t stride) { + // Compute the remainder by performing polynomial division + + //for (uint8_t i = 0; i < degree; i++) { result[] = 0; } + //memset(result, 0, degree); + + for (uint8_t i = 0; i < length; i++) { + uint8_t factor = data[i] ^ result[0]; + for (uint8_t j = 1; j < degree; j++) { + result[(j - 1) * stride] = result[j * stride]; + } + result[(degree - 1) * stride] = 0; + + for (uint8_t j = 0; j < degree; j++) { + result[j * stride] ^= rs_multiply(coeff[j], factor); + } + } +} + + + + +static int8_t encodeDataCodewords(BitBucket *dataCodewords, const uint8_t *text, uint16_t length, uint8_t version) { + int8_t mode = MODE_BYTE; + + if (isNumeric((char*)text, length)) { + mode = MODE_NUMERIC; + bb_appendBits(dataCodewords, 1 << MODE_NUMERIC, 4); + bb_appendBits(dataCodewords, length, getModeBits(version, MODE_NUMERIC)); + + uint16_t accumData = 0; + uint8_t accumCount = 0; + for (uint16_t i = 0; i < length; i++) { + accumData = accumData * 10 + ((char)(text[i]) - '0'); + accumCount++; + if (accumCount == 3) { + bb_appendBits(dataCodewords, accumData, 10); + accumData = 0; + accumCount = 0; + } + } + + // 1 or 2 digits remaining + if (accumCount > 0) { + bb_appendBits(dataCodewords, accumData, accumCount * 3 + 1); + } + + } else if (isAlphanumeric((char*)text, length)) { + mode = MODE_ALPHANUMERIC; + bb_appendBits(dataCodewords, 1 << MODE_ALPHANUMERIC, 4); + bb_appendBits(dataCodewords, length, getModeBits(version, MODE_ALPHANUMERIC)); + + uint16_t accumData = 0; + uint8_t accumCount = 0; + for (uint16_t i = 0; i < length; i++) { + accumData = accumData * 45 + getAlphanumeric((char)(text[i])); + accumCount++; + if (accumCount == 2) { + bb_appendBits(dataCodewords, accumData, 11); + accumData = 0; + accumCount = 0; + } + } + + // 1 character remaining + if (accumCount > 0) { + bb_appendBits(dataCodewords, accumData, 6); + } + + } else { + bb_appendBits(dataCodewords, 1 << MODE_BYTE, 4); + bb_appendBits(dataCodewords, length, getModeBits(version, MODE_BYTE)); + for (uint16_t i = 0; i < length; i++) { + bb_appendBits(dataCodewords, (char)(text[i]), 8); + } + } + + //bb_setBits(dataCodewords, length, 4, getModeBits(version, mode)); + + return mode; +} + +static void performErrorCorrection(uint8_t version, uint8_t ecc, BitBucket *data) { + + // See: http://www.thonky.com/qr-code-tutorial/structure-final-message + +#if LOCK_VERSION == 0 + uint8_t numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecc][version - 1]; + uint16_t totalEcc = NUM_ERROR_CORRECTION_CODEWORDS[ecc][version - 1]; + uint16_t moduleCount = NUM_RAW_DATA_MODULES[version - 1]; +#else + uint8_t numBlocks = NUM_ERROR_CORRECTION_BLOCKS[ecc]; + uint16_t totalEcc = NUM_ERROR_CORRECTION_CODEWORDS[ecc]; + uint16_t moduleCount = NUM_RAW_DATA_MODULES; +#endif + + uint8_t blockEccLen = totalEcc / numBlocks; + uint8_t numShortBlocks = numBlocks - moduleCount / 8 % numBlocks; + uint8_t shortBlockLen = moduleCount / 8 / numBlocks; + + uint8_t shortDataBlockLen = shortBlockLen - blockEccLen; + + uint8_t result[data->capacityBytes]; + memset(result, 0, sizeof(result)); + + uint8_t coeff[blockEccLen]; + rs_init(blockEccLen, coeff); + + uint16_t offset = 0; + uint8_t *dataBytes = data->data; + + + // Interleave all short blocks + for (uint8_t i = 0; i < shortDataBlockLen; i++) { + uint16_t index = i; + uint8_t stride = shortDataBlockLen; + for (uint8_t blockNum = 0; blockNum < numBlocks; blockNum++) { + result[offset++] = dataBytes[index]; + +#if LOCK_VERSION == 0 || LOCK_VERSION >= 5 + if (blockNum == numShortBlocks) { stride++; } +#endif + index += stride; + } + } + + // Version less than 5 only have short blocks +#if LOCK_VERSION == 0 || LOCK_VERSION >= 5 + { + // Interleave long blocks + uint16_t index = shortDataBlockLen * (numShortBlocks + 1); + uint8_t stride = shortDataBlockLen; + for (uint8_t blockNum = 0; blockNum < numBlocks - numShortBlocks; blockNum++) { + result[offset++] = dataBytes[index]; + + if (blockNum == 0) { stride++; } + index += stride; + } + } +#endif + + // Add all ecc blocks, interleaved + uint8_t blockSize = shortDataBlockLen; + for (uint8_t blockNum = 0; blockNum < numBlocks; blockNum++) { + +#if LOCK_VERSION == 0 || LOCK_VERSION >= 5 + if (blockNum == numShortBlocks) { blockSize++; } +#endif + rs_getRemainder(blockEccLen, coeff, dataBytes, blockSize, &result[offset + blockNum], numBlocks); + dataBytes += blockSize; + } + + memcpy(data->data, result, data->capacityBytes); + data->bitOffsetOrWidth = moduleCount; +} + +// We store the Format bits tightly packed into a single byte (each of the 4 modes is 2 bits) +// The format bits can be determined by ECC_FORMAT_BITS >> (2 * ecc) +static const uint8_t ECC_FORMAT_BITS = (0x02 << 6) | (0x03 << 4) | (0x00 << 2) | (0x01 << 0); + + + +uint16_t qrcode_getBufferSize(uint8_t version) { + return bb_getGridSizeBytes(4 * version + 17); +} + +// @TODO: Return error if data is too big. +int8_t qrcode_initBytes(QRCode *qrcode, uint8_t *modules, uint8_t version, uint8_t ecc, uint8_t *data, uint16_t length) { + uint8_t size = version * 4 + 17; + qrcode->version = version; + qrcode->size = size; + qrcode->ecc = ecc; + qrcode->modules = modules; + + uint8_t eccFormatBits = (ECC_FORMAT_BITS >> (2 * ecc)) & 0x03; + +#if LOCK_VERSION == 0 + uint16_t moduleCount = NUM_RAW_DATA_MODULES[version - 1]; + uint16_t dataCapacity = moduleCount / 8 - NUM_ERROR_CORRECTION_CODEWORDS[eccFormatBits][version - 1]; +#else + version = LOCK_VERSION; + uint16_t moduleCount = NUM_RAW_DATA_MODULES; + uint16_t dataCapacity = moduleCount / 8 - NUM_ERROR_CORRECTION_CODEWORDS[eccFormatBits]; +#endif + + struct BitBucket codewords; + uint8_t codewordBytes[bb_getBufferSizeBytes(moduleCount)]; + bb_initBuffer(&codewords, codewordBytes, (int32_t)sizeof(codewordBytes)); + + // Place the data code words into the buffer + int8_t mode = encodeDataCodewords(&codewords, data, length, version); + + if (mode < 0) { return -1; } + qrcode->mode = mode; + + // Add terminator and pad up to a byte if applicable + uint32_t padding = (dataCapacity * 8) - codewords.bitOffsetOrWidth; + if (padding > 4) { padding = 4; } + bb_appendBits(&codewords, 0, padding); + bb_appendBits(&codewords, 0, (8 - codewords.bitOffsetOrWidth % 8) % 8); + + // Pad with alternate bytes until data capacity is reached + for (uint8_t padByte = 0xEC; codewords.bitOffsetOrWidth < (dataCapacity * 8); padByte ^= 0xEC ^ 0x11) { + bb_appendBits(&codewords, padByte, 8); + } + + BitBucket modulesGrid; + bb_initGrid(&modulesGrid, modules, size); + + BitBucket isFunctionGrid; + uint8_t isFunctionGridBytes[bb_getGridSizeBytes(size)]; + bb_initGrid(&isFunctionGrid, isFunctionGridBytes, size); + + // Draw function patterns, draw all codewords, do masking + drawFunctionPatterns(&modulesGrid, &isFunctionGrid, version, eccFormatBits); + performErrorCorrection(version, eccFormatBits, &codewords); + drawCodewords(&modulesGrid, &isFunctionGrid, &codewords); + + // Find the best (lowest penalty) mask + uint8_t mask = 0; + int32_t minPenalty = INT32_MAX; + for (uint8_t i = 0; i < 8; i++) { + drawFormatBits(&modulesGrid, &isFunctionGrid, eccFormatBits, i); + applyMask(&modulesGrid, &isFunctionGrid, i); + int penalty = getPenaltyScore(&modulesGrid); + if (penalty < minPenalty) { + mask = i; + minPenalty = penalty; + } + applyMask(&modulesGrid, &isFunctionGrid, i); // Undoes the mask due to XOR + } + + qrcode->mask = mask; + + // Overwrite old format bits + drawFormatBits(&modulesGrid, &isFunctionGrid, eccFormatBits, mask); + + // Apply the final choice of mask + applyMask(&modulesGrid, &isFunctionGrid, mask); + + return 0; +} + +int8_t qrcode_initText(QRCode *qrcode, uint8_t *modules, uint8_t version, uint8_t ecc, const char *data) { + return qrcode_initBytes(qrcode, modules, version, ecc, (uint8_t*)data, strlen(data)); +} + +bool qrcode_getModule(QRCode *qrcode, uint8_t x, uint8_t y) { + if (x < 0 || x >= qrcode->size || y < 0 || y >= qrcode->size) { + return false; + } + + uint32_t offset = y * qrcode->size + x; + return (qrcode->modules[offset >> 3] & (1 << (7 - (offset & 0x07)))) != 0; +} + +/* +uint8_t qrcode_getHexLength(QRCode *qrcode) { + return ((qrcode->size * qrcode->size) + 7) / 4; +} + +void qrcode_getHex(QRCode *qrcode, char *result) { + +} +*/ diff --git a/Libraries/QRCode/src/qrcode.h b/Libraries/QRCode/src/qrcode.h new file mode 100755 index 00000000..6a5745e5 --- /dev/null +++ b/Libraries/QRCode/src/qrcode.h @@ -0,0 +1,99 @@ +/** + * The MIT License (MIT) + * + * This library is written and maintained by Richard Moore. + * Major parts were derived from Project Nayuki's library. + * + * Copyright (c) 2017 Richard Moore (https://github.com/ricmoo/QRCode) + * Copyright (c) 2017 Project Nayuki (https://www.nayuki.io/page/qr-code-generator-library) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/** + * Special thanks to Nayuki (https://www.nayuki.io/) from which this library was + * heavily inspired and compared against. + * + * See: https://github.com/nayuki/QR-Code-generator/tree/master/cpp + */ + + +#ifndef __QRCODE_H_ +#define __QRCODE_H_ + +#ifndef __cplusplus +typedef unsigned char bool; +static const bool false = 0; +static const bool true = 1; +#endif + +#include + + +// QR Code Format Encoding +#define MODE_NUMERIC 0 +#define MODE_ALPHANUMERIC 1 +#define MODE_BYTE 2 + + +// Error Correction Code Levels +#define ECC_LOW 0 +#define ECC_MEDIUM 1 +#define ECC_QUARTILE 2 +#define ECC_HIGH 3 + + +// If set to non-zero, this library can ONLY produce QR codes at that version +// This saves a lot of dynamic memory, as the codeword tables are skipped +#ifndef LOCK_VERSION +#define LOCK_VERSION 0 +#endif + + +typedef struct QRCode { + uint8_t version; + uint8_t size; + uint8_t ecc; + uint8_t mode; + uint8_t mask; + uint8_t *modules; +} QRCode; + + +#ifdef __cplusplus +extern "C"{ +#endif /* __cplusplus */ + + + +uint16_t qrcode_getBufferSize(uint8_t version); + +int8_t qrcode_initText(QRCode *qrcode, uint8_t *modules, uint8_t version, uint8_t ecc, const char *data); +int8_t qrcode_initBytes(QRCode *qrcode, uint8_t *modules, uint8_t version, uint8_t ecc, uint8_t *data, uint16_t length); + +bool qrcode_getModule(QRCode *qrcode, uint8_t x, uint8_t y); + + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __QRCODE_H_ */ diff --git a/Libraries/QRCode/tests/BitBuffer.cpp b/Libraries/QRCode/tests/BitBuffer.cpp new file mode 100755 index 00000000..4b48cb7a --- /dev/null +++ b/Libraries/QRCode/tests/BitBuffer.cpp @@ -0,0 +1,63 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#include +#include "BitBuffer.hpp" + + +qrcodegen::BitBuffer::BitBuffer() : + data(), + bitLength(0) {} + + +int qrcodegen::BitBuffer::getBitLength() const { + return bitLength; +} + + +std::vector qrcodegen::BitBuffer::getBytes() const { + return data; +} + + +void qrcodegen::BitBuffer::appendBits(uint32_t val, int len) { + if (len < 0 || len > 32 || (len < 32 && (val >> len) != 0)) + throw "Value out of range"; + size_t newBitLen = bitLength + len; + while (data.size() * 8 < newBitLen) + data.push_back(0); + for (int i = len - 1; i >= 0; i--, bitLength++) // Append bit by bit + data.at(bitLength >> 3) |= ((val >> i) & 1) << (7 - (bitLength & 7)); +} + + +void qrcodegen::BitBuffer::appendData(const QrSegment &seg) { + size_t newBitLen = bitLength + seg.bitLength; + while (data.size() * 8 < newBitLen) + data.push_back(0); + for (int i = 0; i < seg.bitLength; i++, bitLength++) { // Append bit by bit + int bit = (seg.data.at(i >> 3) >> (7 - (i & 7))) & 1; + data.at(bitLength >> 3) |= bit << (7 - (bitLength & 7)); + } +} diff --git a/Libraries/QRCode/tests/BitBuffer.hpp b/Libraries/QRCode/tests/BitBuffer.hpp new file mode 100755 index 00000000..ee38907e --- /dev/null +++ b/Libraries/QRCode/tests/BitBuffer.hpp @@ -0,0 +1,76 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#pragma once + +#include +#include +#include "QrSegment.hpp" + + +namespace qrcodegen { + +/* + * An appendable sequence of bits. Bits are packed in big endian within a byte. + */ +class BitBuffer { + + /*---- Fields ----*/ +private: + + std::vector data; + int bitLength; + + + + /*---- Constructor ----*/ +public: + + // Creates an empty bit buffer (length 0). + BitBuffer(); + + + + /*---- Methods ----*/ +public: + + // Returns the number of bits in the buffer, which is a non-negative value. + int getBitLength() const; + + + // Returns a copy of all bytes, padding up to the nearest byte. + std::vector getBytes() const; + + + // Appends the given number of bits of the given value to this sequence. + // If 0 <= len <= 31, then this requires 0 <= val < 2^len. + void appendBits(uint32_t val, int len); + + + // Appends the data of the given segment to this bit buffer. + void appendData(const QrSegment &seg); + +}; + +} diff --git a/Libraries/QRCode/tests/QrCode.cpp b/Libraries/QRCode/tests/QrCode.cpp new file mode 100755 index 00000000..cdb42462 --- /dev/null +++ b/Libraries/QRCode/tests/QrCode.cpp @@ -0,0 +1,616 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#include +#include +#include +#include +#include +#include "BitBuffer.hpp" +#include "QrCode.hpp" + + +qrcodegen::QrCode::Ecc::Ecc(int ord, int fb) : + ordinal(ord), + formatBits(fb) {} + + +const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::LOW (0, 1); +const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::MEDIUM (1, 0); +const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::QUARTILE(2, 3); +const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::HIGH (3, 2); + + +qrcodegen::QrCode qrcodegen::QrCode::encodeText(const char *text, int version, const Ecc &ecl) { + std::vector segs(QrSegment::makeSegments(text)); + return encodeSegments(segs, ecl, version, version, -1, false); +} + + +qrcodegen::QrCode qrcodegen::QrCode::encodeBinary(const std::vector &data, const Ecc &ecl) { + std::vector segs; + segs.push_back(QrSegment::makeBytes(data)); + return encodeSegments(segs, ecl); +} + + +qrcodegen::QrCode qrcodegen::QrCode::encodeSegments(const std::vector &segs, const Ecc &ecl, + int minVersion, int maxVersion, int mask, bool boostEcl) { + if (!(1 <= minVersion && minVersion <= maxVersion && maxVersion <= 40) || mask < -1 || mask > 7) + throw "Invalid value"; + + // Find the minimal version number to use + int version, dataUsedBits; + for (version = minVersion; ; version++) { + int dataCapacityBits = getNumDataCodewords(version, ecl) * 8; // Number of data bits available + dataUsedBits = QrSegment::getTotalBits(segs, version); + if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits) + break; // This version number is found to be suitable + if (version >= maxVersion) // All versions in the range could not fit the given data + throw "Data too long"; + } + if (dataUsedBits == -1) + throw "Assertion error"; + + // Increase the error correction level while the data still fits in the current version number + const Ecc *newEcl = &ecl; + if (boostEcl) { + if (dataUsedBits <= getNumDataCodewords(version, Ecc::MEDIUM ) * 8) newEcl = &Ecc::MEDIUM ; + if (dataUsedBits <= getNumDataCodewords(version, Ecc::QUARTILE) * 8) newEcl = &Ecc::QUARTILE; + if (dataUsedBits <= getNumDataCodewords(version, Ecc::HIGH ) * 8) newEcl = &Ecc::HIGH ; + } + + // Create the data bit string by concatenating all segments + int dataCapacityBits = getNumDataCodewords(version, *newEcl) * 8; + BitBuffer bb; + for (size_t i = 0; i < segs.size(); i++) { + const QrSegment &seg(segs.at(i)); + bb.appendBits(seg.mode.modeBits, 4); + bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version)); + bb.appendData(seg); + } + + // Add terminator and pad up to a byte if applicable + bb.appendBits(0, std::min(4, dataCapacityBits - bb.getBitLength())); + bb.appendBits(0, (8 - bb.getBitLength() % 8) % 8); + + // Pad with alternate bytes until data capacity is reached + for (uint8_t padByte = 0xEC; bb.getBitLength() < dataCapacityBits; padByte ^= 0xEC ^ 0x11) + bb.appendBits(padByte, 8); + if (bb.getBitLength() % 8 != 0) + throw "Assertion error"; + + // Create the QR Code symbol + return QrCode(version, *newEcl, bb.getBytes(), mask); +} + + +qrcodegen::QrCode::QrCode(int ver, const Ecc &ecl, const std::vector &dataCodewords, int mask) : + // Initialize scalar fields + version(ver), + size(1 <= ver && ver <= 40 ? ver * 4 + 17 : -1), // Avoid signed overflow undefined behavior + errorCorrectionLevel(ecl) { + + // Check arguments + if (ver < 1 || ver > 40 || mask < -1 || mask > 7) + throw "Value out of range"; + + std::vector row(size); + for (int i = 0; i < size; i++) { + modules.push_back(row); + isFunction.push_back(row); + } + + // Draw function patterns, draw all codewords, do masking + drawFunctionPatterns(); + const std::vector allCodewords(appendErrorCorrection(dataCodewords)); + drawCodewords(allCodewords); + this->mask = handleConstructorMasking(mask); +} + + +qrcodegen::QrCode::QrCode(const QrCode &qr, int mask) : + // Copy scalar fields + version(qr.version), + size(qr.size), + errorCorrectionLevel(qr.errorCorrectionLevel) { + + // Check arguments + if (mask < -1 || mask > 7) + throw "Mask value out of range"; + + // Handle grid fields + modules = qr.modules; + isFunction = qr.isFunction; + + // Handle masking + applyMask(qr.mask); // Undo old mask + this->mask = handleConstructorMasking(mask); +} + + +int qrcodegen::QrCode::getMask() const { + return mask; +} + + +int qrcodegen::QrCode::getModule(int x, int y) const { + if (0 <= x && x < size && 0 <= y && y < size) + return modules.at(y).at(x) ? 1 : 0; + else + return 0; // Infinite white border +} + + +std::string qrcodegen::QrCode::toSvgString(int border) const { + if (border < 0) + throw "Border must be non-negative"; + std::ostringstream sb; + sb << "\n"; + sb << "\n"; + sb << "\n"; + sb << "\t\n"; + sb << "\t\n"; + sb << "\n"; + return sb.str(); +} + + +void qrcodegen::QrCode::drawFunctionPatterns() { + // Draw the horizontal and vertical timing patterns + for (int i = 0; i < size; i++) { + setFunctionModule(6, i, i % 2 == 0); + setFunctionModule(i, 6, i % 2 == 0); + } + + // Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules) + drawFinderPattern(3, 3); + drawFinderPattern(size - 4, 3); + drawFinderPattern(3, size - 4); + + // Draw the numerous alignment patterns + const std::vector alignPatPos(getAlignmentPatternPositions(version)); + int numAlign = alignPatPos.size(); + for (int i = 0; i < numAlign; i++) { + for (int j = 0; j < numAlign; j++) { + if ((i == 0 && j == 0) || (i == 0 && j == numAlign - 1) || (i == numAlign - 1 && j == 0)) + continue; // Skip the three finder corners + else + drawAlignmentPattern(alignPatPos.at(i), alignPatPos.at(j)); + } + } + + // Draw configuration data + drawFormatBits(0); // Dummy mask value; overwritten later in the constructor + drawVersion(); +} + + +void qrcodegen::QrCode::drawFormatBits(int mask) { + // Calculate error correction code and pack bits + int data = errorCorrectionLevel.formatBits << 3 | mask; // errCorrLvl is uint2, mask is uint3 + int rem = data; + for (int i = 0; i < 10; i++) + rem = (rem << 1) ^ ((rem >> 9) * 0x537); + data = data << 10 | rem; + data ^= 0x5412; // uint15 + if (data >> 15 != 0) + throw "Assertion error"; + + // Draw first copy + for (int i = 0; i <= 5; i++) + setFunctionModule(8, i, ((data >> i) & 1) != 0); + setFunctionModule(8, 7, ((data >> 6) & 1) != 0); + setFunctionModule(8, 8, ((data >> 7) & 1) != 0); + setFunctionModule(7, 8, ((data >> 8) & 1) != 0); + for (int i = 9; i < 15; i++) + setFunctionModule(14 - i, 8, ((data >> i) & 1) != 0); + + // Draw second copy + for (int i = 0; i <= 7; i++) + setFunctionModule(size - 1 - i, 8, ((data >> i) & 1) != 0); + for (int i = 8; i < 15; i++) + setFunctionModule(8, size - 15 + i, ((data >> i) & 1) != 0); + setFunctionModule(8, size - 8, true); +} + + +void qrcodegen::QrCode::drawVersion() { + if (version < 7) + return; + + // Calculate error correction code and pack bits + int rem = version; // version is uint6, in the range [7, 40] + for (int i = 0; i < 12; i++) + rem = (rem << 1) ^ ((rem >> 11) * 0x1F25); + int data = version << 12 | rem; // uint18 + if (data >> 18 != 0) + throw "Assertion error"; + + // Draw two copies + for (int i = 0; i < 18; i++) { + bool bit = ((data >> i) & 1) != 0; + int a = size - 11 + i % 3, b = i / 3; + setFunctionModule(a, b, bit); + setFunctionModule(b, a, bit); + } +} + + +void qrcodegen::QrCode::drawFinderPattern(int x, int y) { + for (int i = -4; i <= 4; i++) { + for (int j = -4; j <= 4; j++) { + int dist = std::max(std::abs(i), std::abs(j)); // Chebyshev/infinity norm + int xx = x + j, yy = y + i; + if (0 <= xx && xx < size && 0 <= yy && yy < size) + setFunctionModule(xx, yy, dist != 2 && dist != 4); + } + } +} + + +void qrcodegen::QrCode::drawAlignmentPattern(int x, int y) { + for (int i = -2; i <= 2; i++) { + for (int j = -2; j <= 2; j++) + setFunctionModule(x + j, y + i, std::max(std::abs(i), std::abs(j)) != 1); + } +} + + +void qrcodegen::QrCode::setFunctionModule(int x, int y, bool isBlack) { + modules.at(y).at(x) = isBlack; + isFunction.at(y).at(x) = true; +} + + +std::vector qrcodegen::QrCode::appendErrorCorrection(const std::vector &data) const { + if (data.size() != static_cast(getNumDataCodewords(version, errorCorrectionLevel))) + throw "Invalid argument"; + + // Calculate parameter numbers + int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[errorCorrectionLevel.ordinal][version]; + int totalEcc = NUM_ERROR_CORRECTION_CODEWORDS[errorCorrectionLevel.ordinal][version]; + if (totalEcc % numBlocks != 0) + throw "Assertion error"; + int blockEccLen = totalEcc / numBlocks; + int numShortBlocks = numBlocks - getNumRawDataModules(version) / 8 % numBlocks; + int shortBlockLen = getNumRawDataModules(version) / 8 / numBlocks; + + // Split data into blocks and append ECC to each block + std::vector > blocks; + const ReedSolomonGenerator rs(blockEccLen); + for (int i = 0, k = 0; i < numBlocks; i++) { + std::vector dat; + dat.insert(dat.begin(), data.begin() + k, data.begin() + (k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1))); + k += dat.size(); + const std::vector ecc(rs.getRemainder(dat)); + if (i < numShortBlocks) + dat.push_back(0); + dat.insert(dat.end(), ecc.begin(), ecc.end()); + blocks.push_back(dat); + } + + // Interleave (not concatenate) the bytes from every block into a single sequence + std::vector result; + for (int i = 0; static_cast(i) < blocks.at(0).size(); i++) { + for (int j = 0; static_cast(j) < blocks.size(); j++) { + // Skip the padding byte in short blocks + if (i != shortBlockLen - blockEccLen || j >= numShortBlocks) + result.push_back(blocks.at(j).at(i)); + } + } + if (result.size() != static_cast(getNumRawDataModules(version) / 8)) + throw "Assertion error"; + return result; +} + + +void qrcodegen::QrCode::drawCodewords(const std::vector &data) { + if (data.size() != static_cast(getNumRawDataModules(version) / 8)) + throw "Invalid argument"; + + size_t i = 0; // Bit index into the data + // Do the funny zigzag scan + for (int right = size - 1; right >= 1; right -= 2) { // Index of right column in each column pair + if (right == 6) + right = 5; + for (int vert = 0; vert < size; vert++) { // Vertical counter + for (int j = 0; j < 2; j++) { + int x = right - j; // Actual x coordinate + bool upwards = ((right & 2) == 0) ^ (x < 6); + int y = upwards ? size - 1 - vert : vert; // Actual y coordinate + if (!isFunction.at(y).at(x) && i < data.size() * 8) { + modules.at(y).at(x) = ((data.at(i >> 3) >> (7 - (i & 7))) & 1) != 0; + i++; + } + // If there are any remainder bits (0 to 7), they are already + // set to 0/false/white when the grid of modules was initialized + } + } + } + if (static_cast(i) != data.size() * 8) + throw "Assertion error"; +} + + +void qrcodegen::QrCode::applyMask(int mask) { + if (mask < 0 || mask > 7) + throw "Mask value out of range"; + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + bool invert; + switch (mask) { + case 0: invert = (x + y) % 2 == 0; break; + case 1: invert = y % 2 == 0; break; + case 2: invert = x % 3 == 0; break; + case 3: invert = (x + y) % 3 == 0; break; + case 4: invert = (x / 3 + y / 2) % 2 == 0; break; + case 5: invert = x * y % 2 + x * y % 3 == 0; break; + case 6: invert = (x * y % 2 + x * y % 3) % 2 == 0; break; + case 7: invert = ((x + y) % 2 + x * y % 3) % 2 == 0; break; + default: throw "Assertion error"; + } + modules.at(y).at(x) = modules.at(y).at(x) ^ (invert & !isFunction.at(y).at(x)); + } + } +} + + +int qrcodegen::QrCode::handleConstructorMasking(int mask) { + if (mask == -1) { // Automatically choose best mask + int32_t minPenalty = INT32_MAX; + for (int i = 0; i < 8; i++) { + drawFormatBits(i); + applyMask(i); + int penalty = getPenaltyScore(); + if (penalty < minPenalty) { + mask = i; + minPenalty = penalty; + } + applyMask(i); // Undoes the mask due to XOR + } + } + if (mask < 0 || mask > 7) + throw "Assertion error"; + drawFormatBits(mask); // Overwrite old format bits + applyMask(mask); // Apply the final choice of mask + return mask; // The caller shall assign this value to the final-declared field +} + + +int qrcodegen::QrCode::getPenaltyScore() const { + int result = 0; + + // Adjacent modules in row having same color + for (int y = 0; y < size; y++) { + bool colorX = modules.at(y).at(0); + for (int x = 1, runX = 1; x < size; x++) { + if (modules.at(y).at(x) != colorX) { + colorX = modules.at(y).at(x); + runX = 1; + } else { + runX++; + if (runX == 5) + result += PENALTY_N1; + else if (runX > 5) + result++; + } + } + } + // Adjacent modules in column having same color + for (int x = 0; x < size; x++) { + bool colorY = modules.at(0).at(x); + for (int y = 1, runY = 1; y < size; y++) { + if (modules.at(y).at(x) != colorY) { + colorY = modules.at(y).at(x); + runY = 1; + } else { + runY++; + if (runY == 5) + result += PENALTY_N1; + else if (runY > 5) + result++; + } + } + } + + // 2*2 blocks of modules having same color + for (int y = 0; y < size - 1; y++) { + for (int x = 0; x < size - 1; x++) { + bool color = modules.at(y).at(x); + if ( color == modules.at(y).at(x + 1) && + color == modules.at(y + 1).at(x) && + color == modules.at(y + 1).at(x + 1)) + result += PENALTY_N2; + } + } + + // Finder-like pattern in rows + for (int y = 0; y < size; y++) { + for (int x = 0, bits = 0; x < size; x++) { + bits = ((bits << 1) & 0x7FF) | (modules.at(y).at(x) ? 1 : 0); + if (x >= 10 && (bits == 0x05D || bits == 0x5D0)) // Needs 11 bits accumulated + result += PENALTY_N3; + } + } + // Finder-like pattern in columns + for (int x = 0; x < size; x++) { + for (int y = 0, bits = 0; y < size; y++) { + bits = ((bits << 1) & 0x7FF) | (modules.at(y).at(x) ? 1 : 0); + if (y >= 10 && (bits == 0x05D || bits == 0x5D0)) // Needs 11 bits accumulated + result += PENALTY_N3; + } + } + + // Balance of black and white modules + int black = 0; + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + if (modules.at(y).at(x)) + black++; + } + } + int total = size * size; + // Find smallest k such that (45-5k)% <= dark/total <= (55+5k)% + for (int k = 0; black*20 < (9-k)*total || black*20 > (11+k)*total; k++) + result += PENALTY_N4; + return result; +} + + +std::vector qrcodegen::QrCode::getAlignmentPatternPositions(int ver) { + if (ver < 1 || ver > 40) + throw "Version number out of range"; + else if (ver == 1) + return std::vector(); + else { + int numAlign = ver / 7 + 2; + int step; + if (ver != 32) + step = (ver * 4 + numAlign * 2 + 1) / (2 * numAlign - 2) * 2; // ceil((size - 13) / (2*numAlign - 2)) * 2 + else // C-C-C-Combo breaker! + step = 26; + + std::vector result; + int size = ver * 4 + 17; + for (int i = 0, pos = size - 7; i < numAlign - 1; i++, pos -= step) + result.insert(result.begin(), pos); + result.insert(result.begin(), 6); + return result; + } +} + + +int qrcodegen::QrCode::getNumRawDataModules(int ver) { + if (ver < 1 || ver > 40) + throw "Version number out of range"; + int result = (16 * ver + 128) * ver + 64; + if (ver >= 2) { + int numAlign = ver / 7 + 2; + result -= (25 * numAlign - 10) * numAlign - 55; + if (ver >= 7) + result -= 18 * 2; // Subtract version information + } + return result; +} + + +int qrcodegen::QrCode::getNumDataCodewords(int ver, const Ecc &ecl) { + if (ver < 1 || ver > 40) + throw "Version number out of range"; + return getNumRawDataModules(ver) / 8 - NUM_ERROR_CORRECTION_CODEWORDS[ecl.ordinal][ver]; +} + + +/*---- Tables of constants ----*/ + +const int qrcodegen::QrCode::PENALTY_N1 = 3; +const int qrcodegen::QrCode::PENALTY_N2 = 3; +const int qrcodegen::QrCode::PENALTY_N3 = 40; +const int qrcodegen::QrCode::PENALTY_N4 = 10; + + +const int16_t qrcodegen::QrCode::NUM_ERROR_CORRECTION_CODEWORDS[4][41] = { + // Version: (note that index 0 is for padding, and is set to an illegal value) + //0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level + {-1, 7, 10, 15, 20, 26, 36, 40, 48, 60, 72, 80, 96, 104, 120, 132, 144, 168, 180, 196, 224, 224, 252, 270, 300, 312, 336, 360, 390, 420, 450, 480, 510, 540, 570, 570, 600, 630, 660, 720, 750}, // Low + {-1, 10, 16, 26, 36, 48, 64, 72, 88, 110, 130, 150, 176, 198, 216, 240, 280, 308, 338, 364, 416, 442, 476, 504, 560, 588, 644, 700, 728, 784, 812, 868, 924, 980, 1036, 1064, 1120, 1204, 1260, 1316, 1372}, // Medium + {-1, 13, 22, 36, 52, 72, 96, 108, 132, 160, 192, 224, 260, 288, 320, 360, 408, 448, 504, 546, 600, 644, 690, 750, 810, 870, 952, 1020, 1050, 1140, 1200, 1290, 1350, 1440, 1530, 1590, 1680, 1770, 1860, 1950, 2040}, // Quartile + {-1, 17, 28, 44, 64, 88, 112, 130, 156, 192, 224, 264, 308, 352, 384, 432, 480, 532, 588, 650, 700, 750, 816, 900, 960, 1050, 1110, 1200, 1260, 1350, 1440, 1530, 1620, 1710, 1800, 1890, 1980, 2100, 2220, 2310, 2430}, // High +}; + +const int8_t qrcodegen::QrCode::NUM_ERROR_CORRECTION_BLOCKS[4][41] = { + // Version: (note that index 0 is for padding, and is set to an illegal value) + //0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level + {-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25}, // Low + {-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49}, // Medium + {-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68}, // Quartile + {-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81}, // High +}; + + +qrcodegen::QrCode::ReedSolomonGenerator::ReedSolomonGenerator(int degree) : + coefficients() { + if (degree < 1 || degree > 255) + throw "Degree out of range"; + + // Start with the monomial x^0 + coefficients.resize(degree); + coefficients.at(degree - 1) = 1; + + // Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}), + // drop the highest term, and store the rest of the coefficients in order of descending powers. + // Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D). + int root = 1; + for (int i = 0; i < degree; i++) { + // Multiply the current product by (x - r^i) + for (size_t j = 0; j < coefficients.size(); j++) { + coefficients.at(j) = multiply(coefficients.at(j), static_cast(root)); + if (j + 1 < coefficients.size()) + coefficients.at(j) ^= coefficients.at(j + 1); + } + root = (root << 1) ^ ((root >> 7) * 0x11D); // Multiply by 0x02 mod GF(2^8/0x11D) + } +} + + +std::vector qrcodegen::QrCode::ReedSolomonGenerator::getRemainder(const std::vector &data) const { + // Compute the remainder by performing polynomial division + std::vector result(coefficients.size()); + for (size_t i = 0; i < data.size(); i++) { + uint8_t factor = data.at(i) ^ result.at(0); + result.erase(result.begin()); + result.push_back(0); + for (size_t j = 0; j < result.size(); j++) + result.at(j) ^= multiply(coefficients.at(j), factor); + } + return result; +} + + +uint8_t qrcodegen::QrCode::ReedSolomonGenerator::multiply(uint8_t x, uint8_t y) { + // Russian peasant multiplication + int z = 0; + for (int i = 7; i >= 0; i--) { + z = (z << 1) ^ ((z >> 7) * 0x11D); + z ^= ((y >> i) & 1) * x; + } + if (z >> 8 != 0) + throw "Assertion error"; + return static_cast(z); +} diff --git a/Libraries/QRCode/tests/QrCode.hpp b/Libraries/QRCode/tests/QrCode.hpp new file mode 100755 index 00000000..dd4dcc28 --- /dev/null +++ b/Libraries/QRCode/tests/QrCode.hpp @@ -0,0 +1,314 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#pragma once + +#include +#include +#include +#include "QrSegment.hpp" + + +namespace qrcodegen { + +/* + * Represents an immutable square grid of black and white cells for a QR Code symbol, and + * provides static functions to create a QR Code from user-supplied textual or binary data. + * This class covers the QR Code model 2 specification, supporting all versions (sizes) + * from 1 to 40, all 4 error correction levels, and only 3 character encoding modes. + */ +class QrCode { + + /*---- Public helper enumeration ----*/ +public: + + /* + * Represents the error correction level used in a QR Code symbol. + */ + class Ecc { + // Constants declared in ascending order of error protection. + public: + const static Ecc LOW, MEDIUM, QUARTILE, HIGH; + + // Fields. + public: + const int ordinal; // (Public) In the range 0 to 3 (unsigned 2-bit integer). + const int formatBits; // (Package-private) In the range 0 to 3 (unsigned 2-bit integer). + + // Constructor. + private: + Ecc(int ord, int fb); + }; + + + + /*---- Public static factory functions ----*/ +public: + + /* + * Returns a QR Code symbol representing the given Unicode text string at the given error correction level. + * As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer Unicode + * code points (not UTF-16 code units). The smallest possible QR Code version is automatically chosen for the output. + * The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version. + */ + static QrCode encodeText(const char *text, int version, const Ecc &ecl); + + + /* + * Returns a QR Code symbol representing the given binary data string at the given error correction level. + * This function always encodes using the binary segment mode, not any text mode. The maximum number of + * bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output. + * The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version. + */ + static QrCode encodeBinary(const std::vector &data, const Ecc &ecl); + + + /* + * Returns a QR Code symbol representing the given data segments with the given encoding parameters. + * The smallest possible QR Code version within the given range is automatically chosen for the output. + * This function allows the user to create a custom sequence of segments that switches + * between modes (such as alphanumeric and binary) to encode text more efficiently. + * This function is considered to be lower level than simply encoding text or binary data. + */ + static QrCode encodeSegments(const std::vector &segs, const Ecc &ecl, + int minVersion=1, int maxVersion=40, int mask=-1, bool boostEcl=true); // All optional parameters + + + + /*---- Instance fields ----*/ + + // Public immutable scalar parameters +public: + + /* This QR Code symbol's version number, which is always between 1 and 40 (inclusive). */ + const int version; + + /* The width and height of this QR Code symbol, measured in modules. + * Always equal to version × 4 + 17, in the range 21 to 177. */ + const int size; + + /* The error correction level used in this QR Code symbol. */ + const Ecc &errorCorrectionLevel; + + /* The mask pattern used in this QR Code symbol, in the range 0 to 7 (i.e. unsigned 3-bit integer). + * Note that even if a constructor was called with automatic masking requested + * (mask = -1), the resulting object will still have a mask value between 0 and 7. */ +private: + int mask; + + // Private grids of modules/pixels (conceptually immutable) +private: + std::vector > modules; // The modules of this QR Code symbol (false = white, true = black) + std::vector > isFunction; // Indicates function modules that are not subjected to masking + + + + /*---- Constructors ----*/ +public: + + /* + * Creates a new QR Code symbol with the given version number, error correction level, binary data array, + * and mask number. This is a cumbersome low-level constructor that should not be invoked directly by the user. + * To go one level up, see the encodeSegments() function. + */ + QrCode(int ver, const Ecc &ecl, const std::vector &dataCodewords, int mask); + + + /* + * Creates a new QR Code symbol based on the given existing object, but with a potentially + * different mask pattern. The version, error correction level, codewords, etc. of the newly + * created object are all identical to the argument object; only the mask may differ. + */ + QrCode(const QrCode &qr, int mask); + + + + /*---- Public instance methods ----*/ +public: + + int getMask() const; + + + /* + * Returns the color of the module (pixel) at the given coordinates, which is either 0 for white or 1 for black. The top + * left corner has the coordinates (x=0, y=0). If the given coordinates are out of bounds, then 0 (white) is returned. + */ + int getModule(int x, int y) const; + + + /* + * Based on the given number of border modules to add as padding, this returns a + * string whose contents represents an SVG XML file that depicts this QR Code symbol. + * Note that Unix newlines (\n) are always used, regardless of the platform. + */ + std::string toSvgString(int border) const; + + + + /*---- Private helper methods for constructor: Drawing function modules ----*/ +private: + + void drawFunctionPatterns(); + + + // Draws two copies of the format bits (with its own error correction code) + // based on the given mask and this object's error correction level field. + void drawFormatBits(int mask); + + + // Draws two copies of the version bits (with its own error correction code), + // based on this object's version field (which only has an effect for 7 <= version <= 40). + void drawVersion(); + + + // Draws a 9*9 finder pattern including the border separator, with the center module at (x, y). + void drawFinderPattern(int x, int y); + + + // Draws a 5*5 alignment pattern, with the center module at (x, y). + void drawAlignmentPattern(int x, int y); + + + // Sets the color of a module and marks it as a function module. + // Only used by the constructor. Coordinates must be in range. + void setFunctionModule(int x, int y, bool isBlack); + + + /*---- Private helper methods for constructor: Codewords and masking ----*/ +private: + + // Returns a new byte string representing the given data with the appropriate error correction + // codewords appended to it, based on this object's version and error correction level. + std::vector appendErrorCorrection(const std::vector &data) const; + + + // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire + // data area of this QR Code symbol. Function modules need to be marked off before this is called. + void drawCodewords(const std::vector &data); + + + // XORs the data modules in this QR Code with the given mask pattern. Due to XOR's mathematical + // properties, calling applyMask(m) twice with the same value is equivalent to no change at all. + // This means it is possible to apply a mask, undo it, and try another mask. Note that a final + // well-formed QR Code symbol needs exactly one mask applied (not zero, not two, etc.). + void applyMask(int mask); + + + // A messy helper function for the constructors. This QR Code must be in an unmasked state when this + // method is called. The given argument is the requested mask, which is -1 for auto or 0 to 7 for fixed. + // This method applies and returns the actual mask chosen, from 0 to 7. + int handleConstructorMasking(int mask); + + + // Calculates and returns the penalty score based on state of this QR Code's current modules. + // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score. + int getPenaltyScore() const; + + + + /*---- Private static helper functions ----*/ +private: + + // Returns a set of positions of the alignment patterns in ascending order. These positions are + // used on both the x and y axes. Each value in the resulting array is in the range [0, 177). + // This stateless pure function could be implemented as table of 40 variable-length lists of unsigned bytes. + static std::vector getAlignmentPatternPositions(int ver); + + + // Returns the number of raw data modules (bits) available at the given version number. + // These data modules are used for both user data codewords and error correction codewords. + // This stateless pure function could be implemented as a 40-entry lookup table. + static int getNumRawDataModules(int ver); + + + // Returns the number of 8-bit data (i.e. not error correction) codewords contained in any + // QR Code of the given version number and error correction level, with remainder bits discarded. + // This stateless pure function could be implemented as a (40*4)-cell lookup table. + static int getNumDataCodewords(int ver, const Ecc &ecl); + + + /*---- Private tables of constants ----*/ +private: + + // For use in getPenaltyScore(), when evaluating which mask is best. + static const int PENALTY_N1; + static const int PENALTY_N2; + static const int PENALTY_N3; + static const int PENALTY_N4; + + static const int16_t NUM_ERROR_CORRECTION_CODEWORDS[4][41]; + static const int8_t NUM_ERROR_CORRECTION_BLOCKS[4][41]; + + + + /*---- Private helper class ----*/ +private: + + /* + * Computes the Reed-Solomon error correction codewords for a sequence of data codewords + * at a given degree. Objects are immutable, and the state only depends on the degree. + * This class exists because the divisor polynomial does not need to be recalculated for every input. + */ + class ReedSolomonGenerator { + + /*-- Immutable field --*/ + private: + + // Coefficients of the divisor polynomial, stored from highest to lowest power, excluding the leading term which + // is always 1. For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}. + std::vector coefficients; + + + /*-- Constructor --*/ + public: + + /* + * Creates a Reed-Solomon ECC generator for the given degree. This could be implemented + * as a lookup table over all possible parameter values, instead of as an algorithm. + */ + ReedSolomonGenerator(int degree); + + + /*-- Method --*/ + public: + + /* + * Computes and returns the Reed-Solomon error correction codewords for the given sequence of data codewords. + * The returned object is always a new byte array. This method does not alter this object's state (because it is immutable). + */ + std::vector getRemainder(const std::vector &data) const; + + + /*-- Static function --*/ + private: + + // Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result + // are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8. + static uint8_t multiply(uint8_t x, uint8_t y); + + }; + +}; + +} diff --git a/Libraries/QRCode/tests/QrSegment.cpp b/Libraries/QRCode/tests/QrSegment.cpp new file mode 100755 index 00000000..2ae22428 --- /dev/null +++ b/Libraries/QRCode/tests/QrSegment.cpp @@ -0,0 +1,173 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#include +#include "BitBuffer.hpp" +#include "QrSegment.hpp" + + +qrcodegen::QrSegment::Mode::Mode(int mode, int cc0, int cc1, int cc2) : + modeBits(mode) { + numBitsCharCount[0] = cc0; + numBitsCharCount[1] = cc1; + numBitsCharCount[2] = cc2; +} + + +int qrcodegen::QrSegment::Mode::numCharCountBits(int ver) const { + if ( 1 <= ver && ver <= 9) return numBitsCharCount[0]; + else if (10 <= ver && ver <= 26) return numBitsCharCount[1]; + else if (27 <= ver && ver <= 40) return numBitsCharCount[2]; + else throw "Version number out of range"; +} + + +const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::NUMERIC (0x1, 10, 12, 14); +const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::ALPHANUMERIC(0x2, 9, 11, 13); +const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::BYTE (0x4, 8, 16, 16); +const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::KANJI (0x8, 8, 10, 12); + + + +qrcodegen::QrSegment qrcodegen::QrSegment::makeBytes(const std::vector &data) { + return QrSegment(Mode::BYTE, data.size(), data, data.size() * 8); +} + + +qrcodegen::QrSegment qrcodegen::QrSegment::makeNumeric(const char *digits) { + BitBuffer bb; + int accumData = 0; + int accumCount = 0; + int charCount = 0; + for (; *digits != '\0'; digits++, charCount++) { + char c = *digits; + if (c < '0' || c > '9') + throw "String contains non-numeric characters"; + accumData = accumData * 10 + (c - '0'); + accumCount++; + if (accumCount == 3) { + bb.appendBits(accumData, 10); + accumData = 0; + accumCount = 0; + } + } + if (accumCount > 0) // 1 or 2 digits remaining + bb.appendBits(accumData, accumCount * 3 + 1); + return QrSegment(Mode::NUMERIC, charCount, bb.getBytes(), bb.getBitLength()); +} + + +qrcodegen::QrSegment qrcodegen::QrSegment::makeAlphanumeric(const char *text) { + BitBuffer bb; + int accumData = 0; + int accumCount = 0; + int charCount = 0; + for (; *text != '\0'; text++, charCount++) { + char c = *text; + if (c < ' ' || c > 'Z') + throw "String contains unencodable characters in alphanumeric mode"; + accumData = accumData * 45 + ALPHANUMERIC_ENCODING_TABLE[c - ' ']; + accumCount++; + if (accumCount == 2) { + bb.appendBits(accumData, 11); + accumData = 0; + accumCount = 0; + } + } + if (accumCount > 0) // 1 character remaining + bb.appendBits(accumData, 6); + return QrSegment(Mode::ALPHANUMERIC, charCount, bb.getBytes(), bb.getBitLength()); +} + + +std::vector qrcodegen::QrSegment::makeSegments(const char *text) { + // Select the most efficient segment encoding automatically + std::vector result; + if (*text == '\0'); // Leave the vector empty + else if (QrSegment::isNumeric(text)) + result.push_back(QrSegment::makeNumeric(text)); + else if (QrSegment::isAlphanumeric(text)) + result.push_back(QrSegment::makeAlphanumeric(text)); + else { + std::vector bytes; + for (; *text != '\0'; text++) + bytes.push_back(static_cast(*text)); + result.push_back(QrSegment::makeBytes(bytes)); + } + return result; +} + + +qrcodegen::QrSegment::QrSegment(const Mode &md, int numCh, const std::vector &b, int bitLen) : + mode(md), + numChars(numCh), + data(b), + bitLength(bitLen) { + if (numCh < 0 || bitLen < 0 || b.size() != static_cast((bitLen + 7) / 8)) + throw "Invalid value"; +} + + +int qrcodegen::QrSegment::getTotalBits(const std::vector &segs, int version) { + if (version < 1 || version > 40) + throw "Version number out of range"; + int result = 0; + for (size_t i = 0; i < segs.size(); i++) { + const QrSegment &seg(segs.at(i)); + int ccbits = seg.mode.numCharCountBits(version); + // Fail if segment length value doesn't fit in the length field's bit-width + if (seg.numChars >= (1 << ccbits)) + return -1; + result += 4 + ccbits + seg.bitLength; + } + return result; +} + + +bool qrcodegen::QrSegment::isAlphanumeric(const char *text) { + for (; *text != '\0'; text++) { + char c = *text; + if (c < ' ' || c > 'Z' || ALPHANUMERIC_ENCODING_TABLE[c - ' '] == -1) + return false; + } + return true; +} + + +bool qrcodegen::QrSegment::isNumeric(const char *text) { + for (; *text != '\0'; text++) { + char c = *text; + if (c < '0' || c > '9') + return false; + } + return true; +} + + +const int8_t qrcodegen::QrSegment::ALPHANUMERIC_ENCODING_TABLE[59] = { + // SP, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, :, ;, <, =, >, ?, @, // ASCII codes 32 to 64 + 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, -1, // Array indices 0 to 32 + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, // Array indices 33 to 58 + // A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, // ASCII codes 65 to 90 +}; diff --git a/Libraries/QRCode/tests/QrSegment.hpp b/Libraries/QRCode/tests/QrSegment.hpp new file mode 100755 index 00000000..87ac55cc --- /dev/null +++ b/Libraries/QRCode/tests/QrSegment.hpp @@ -0,0 +1,170 @@ +/* + * QR Code generator library (C++) + * + * Copyright (c) Project Nayuki + * https://www.nayuki.io/page/qr-code-generator-library + * + * (MIT License) + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * - The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * - The Software is provided "as is", without warranty of any kind, express or + * implied, including but not limited to the warranties of merchantability, + * fitness for a particular purpose and noninfringement. In no event shall the + * authors or copyright holders be liable for any claim, damages or other + * liability, whether in an action of contract, tort or otherwise, arising from, + * out of or in connection with the Software or the use or other dealings in the + * Software. + */ + +#pragma once + +#include +#include + + +namespace qrcodegen { + +/* + * Represents a character string to be encoded in a QR Code symbol. Each segment has + * a mode, and a sequence of characters that is already encoded as a sequence of bits. + * Instances of this class are immutable. + * This segment class imposes no length restrictions, but QR Codes have restrictions. + * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data. + * Any segment longer than this is meaningless for the purpose of generating QR Codes. + */ +class QrSegment { + + /*---- Public helper enumeration ----*/ + + /* + * The mode field of a segment. Immutable. Provides methods to retrieve closely related values. + */ +public: + class Mode { + + /*-- Constants --*/ + public: + + static const Mode NUMERIC; + static const Mode ALPHANUMERIC; + static const Mode BYTE; + static const Mode KANJI; + + + /*-- Fields --*/ + + /* (Package-private) An unsigned 4-bit integer value (range 0 to 15) representing the mode indicator bits for this mode object. */ + public: + const int modeBits; + + private: + int numBitsCharCount[3]; + + + /*-- Constructor --*/ + + private: + Mode(int mode, int cc0, int cc1, int cc2); + + + /*-- Method --*/ + + /* + * (Package-private) Returns the bit width of the segment character count field for this mode object at the given version number. + */ + public: + int numCharCountBits(int ver) const; + + }; + + + + /*---- Public static factory functions ----*/ +public: + + /* + * Returns a segment representing the given binary data encoded in byte mode. + */ + static QrSegment makeBytes(const std::vector &data); + + + /* + * Returns a segment representing the given string of decimal digits encoded in numeric mode. + */ + static QrSegment makeNumeric(const char *digits); + + + /* + * Returns a segment representing the given text string encoded in alphanumeric mode. The characters allowed are: + * 0 to 9, A to Z (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon. + */ + static QrSegment makeAlphanumeric(const char *text); + + + /* + * Returns a list of zero or more segments to represent the given text string. + * The result may use various segment modes and switch modes to optimize the length of the bit stream. + */ + static std::vector makeSegments(const char *text); + + + /*---- Public static helper functions ----*/ +public: + + /* + * Tests whether the given string can be encoded as a segment in alphanumeric mode. + */ + static bool isAlphanumeric(const char *text); + + + /* + * Tests whether the given string can be encoded as a segment in numeric mode. + */ + static bool isNumeric(const char *text); + + + + /*---- Instance fields ----*/ +public: + + /* The mode indicator for this segment. */ + const Mode mode; + + /* The length of this segment's unencoded data, measured in characters. Always zero or positive. */ + const int numChars; + + /* The bits of this segment packed into a byte array in big endian. */ + const std::vector data; + + /* The length of this segment's encoded data, measured in bits. Satisfies ceil(bitLength / 8) = data.size(). */ + const int bitLength; + + + /*---- Constructor ----*/ +public: + + /* + * Creates a new QR Code data segment with the given parameters and data. + */ + QrSegment(const Mode &md, int numCh, const std::vector &b, int bitLen); + + + // Package-private helper function. + static int getTotalBits(const std::vector &segs, int version); + + + /*---- Private constant ----*/ +private: + + /* Maps shifted ASCII codes to alphanumeric mode character codes. */ + static const int8_t ALPHANUMERIC_ENCODING_TABLE[59]; + +}; + +} diff --git a/Libraries/QRCode/tests/README.md b/Libraries/QRCode/tests/README.md new file mode 100644 index 00000000..ce157a3e --- /dev/null +++ b/Libraries/QRCode/tests/README.md @@ -0,0 +1,12 @@ +Testing +======= + +The testcases work by using the Nayuki QR code generating library, generating a QR code +in both libraries and comparing them. + +Running +------- + +``` +./run.sh +``` diff --git a/Libraries/QRCode/tests/run-tests.cpp b/Libraries/QRCode/tests/run-tests.cpp new file mode 100644 index 00000000..13565d4a --- /dev/null +++ b/Libraries/QRCode/tests/run-tests.cpp @@ -0,0 +1,85 @@ +#include +#include + +#include "../src/qrcode.h" +#include "QrCode.hpp" + +static uint32_t check(const qrcodegen::QrCode &nayuki, QRCode *ricmoo) { + uint32_t wrong = 0; + + if (nayuki.size != ricmoo->size) { wrong += (1 << 20); } + + int border = 4; + for (int y = -border; y < nayuki.size + border; y++) { + for (int x = -border; x < nayuki.size + border; x++) { + if (!!nayuki.getModule(x, y) != qrcode_getModule(ricmoo, x, y)) { + wrong++; + } + } + } + + return wrong; +} + +int main() { + std::clock_t t0, totalNayuki, totalRicMoo; + + int total = 0, passed = 0; + for (char version = 1; version <= 40; version++) { + if (LOCK_VERSION != 0 && LOCK_VERSION != version) { continue; } + + for (char ecc = 0; ecc < 4; ecc++) { + const qrcodegen::QrCode::Ecc *errCorLvl; + switch (ecc) { + case 0: + errCorLvl = &qrcodegen::QrCode::Ecc::LOW; + break; + case 1: + errCorLvl = &qrcodegen::QrCode::Ecc::MEDIUM; + break; + case 2: + errCorLvl = &qrcodegen::QrCode::Ecc::QUARTILE; + break; + case 3: + errCorLvl = &qrcodegen::QrCode::Ecc::HIGH; + break; + } + + for (char tc = 0; tc < 3; tc++) { + char *data; + switch(tc) { + case 0: + data = (char*)"HELLO"; + break; + case 1: + data = (char*)"Hello"; + break; + case 2: + data = (char*)"1234"; + break; + } + t0 = std::clock(); + const qrcodegen::QrCode nayuki = qrcodegen::QrCode::encodeText(data, version, *errCorLvl); + totalNayuki += std::clock() - t0; + + t0 = std::clock(); + QRCode ricmoo; + uint8_t ricmooBytes[qrcode_getBufferSize(version)]; + qrcode_initText(&ricmoo, ricmooBytes, version, ecc, data); + totalRicMoo += std::clock() - t0; + + uint32_t badModules = check(nayuki, &ricmoo); + if (badModules) { + printf("Failed test case: version=%d, ecc=%d, data=\"%s\", faliured=%d\n", version, ecc, data, badModules); + } else { + passed++; + } + + total++; + } + } + } + + printf("Tests complete: %d passed (out of %d)\n", passed, total); + printf("Timing: Nayuki=%lu, RicMoo=%lu\n", totalNayuki, totalRicMoo); +} diff --git a/Libraries/QRCode/tests/run.sh b/Libraries/QRCode/tests/run.sh new file mode 100755 index 00000000..ff7be5fb --- /dev/null +++ b/Libraries/QRCode/tests/run.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +clang++ run-tests.cpp QrCode.cpp QrSegment.cpp BitBuffer.cpp ../src/qrcode.c -o test && ./test +clang++ run-tests.cpp QrCode.cpp QrSegment.cpp BitBuffer.cpp ../src/qrcode.c -o test -D LOCK_VERSION=3 && ./test + diff --git a/Libraries/lv_screenshot/CMakeLists.txt b/Libraries/lv_screenshot/CMakeLists.txt index b55b6067..1895aa7f 100644 --- a/Libraries/lv_screenshot/CMakeLists.txt +++ b/Libraries/lv_screenshot/CMakeLists.txt @@ -5,7 +5,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) if (DEFINED ENV{ESP_IDF_VERSION}) - file(GLOB_RECURSE SOURCE_FILES Source/*.c*) + file(GLOB_RECURSE SOURCE_FILES Source/*.c*) # TODO: Fix idf_component_register( SRCS ${SOURCE_FILES} diff --git a/Tactility/CMakeLists.txt b/Tactility/CMakeLists.txt index f306ea85..fe7118ad 100644 --- a/Tactility/CMakeLists.txt +++ b/Tactility/CMakeLists.txt @@ -10,7 +10,7 @@ if (DEFINED ENV{ESP_IDF_VERSION}) SRCS ${SOURCE_FILES} INCLUDE_DIRS "Source/" PRIV_INCLUDE_DIRS "Private/" - REQUIRES TactilityHeadless lvgl driver elf_loader lv_screenshot + REQUIRES TactilityHeadless lvgl driver elf_loader lv_screenshot QRCode ) add_definitions(-DESP_PLATFORM) diff --git a/Tactility/Source/Tactility.cpp b/Tactility/Source/Tactility.cpp index 1cb5d3cb..d49d136f 100644 --- a/Tactility/Source/Tactility.cpp +++ b/Tactility/Source/Tactility.cpp @@ -17,7 +17,9 @@ static const Configuration* config_instance = nullptr; namespace service { namespace gui { extern const ServiceManifest manifest; } namespace loader { extern const ServiceManifest manifest; } +#ifndef ESP_PLATFORM // Screenshots don't work yet on ESP32 namespace screenshot { extern const ServiceManifest manifest; } +#endif namespace statusbar { extern const ServiceManifest manifest; } } @@ -54,13 +56,15 @@ namespace app { namespace wifiapsettings { extern const AppManifest manifest; } namespace wificonnect { extern const AppManifest manifest; } namespace wifimanage { extern const AppManifest manifest; } - +#ifdef ESP_PLATFORM extern const AppManifest elfWrapperManifest; + namespace crashdiagnostics { extern const AppManifest manifest; } +#else + namespace app::screenshot { extern const AppManifest manifest; } +#endif } - #ifndef ESP_PLATFORM -extern const app::AppManifest screenshot_app; #endif static const std::vector system_apps = { @@ -81,10 +85,11 @@ static const std::vector system_apps = { &app::wifiapsettings::manifest, &app::wificonnect::manifest, &app::wifimanage::manifest, -#ifndef ESP_PLATFORM - &app::screenshot::manifest, // Screenshots don't work yet on ESP32 -#else +#ifdef ESP_PLATFORM + &app::crashdiagnostics::manifest, &app::elfWrapperManifest, // For hot-loading ELF apps +#else + &app::screenshot::manifest, // Screenshots don't work yet on ESP32 #endif }; diff --git a/Tactility/Source/app/boot/Boot.cpp b/Tactility/Source/app/boot/Boot.cpp index fdabb48c..0c7fb49f 100644 --- a/Tactility/Source/app/boot/Boot.cpp +++ b/Tactility/Source/app/boot/Boot.cpp @@ -4,6 +4,7 @@ #include "app/AppContext.h" #include "app/display/DisplaySettings.h" #include "hal/Display.h" +#include "kernel/PanicHandler.h" #include "service/loader/Loader.h" #include "lvgl/Style.h" @@ -43,8 +44,19 @@ static int32_t threadCallback(TT_UNUSED void* context) { if (minimum_ticks > ticks_passed) { tt::kernel::delayTicks(minimum_ticks - ticks_passed); } + tt::service::loader::stopApp(); +#ifdef ESP_PLATFORM + esp_reset_reason_t reason = esp_reset_reason(); + if (reason == ESP_RST_PANIC) { + tt::service::loader::startApp("CrashDiagnostics"); + } else { + tt::service::loader::startApp("Desktop"); + } +#else tt::service::loader::startApp("Desktop"); +#endif + return 0; } diff --git a/Tactility/Source/app/crashdiagnostics/CrashDiagnostics.cpp b/Tactility/Source/app/crashdiagnostics/CrashDiagnostics.cpp new file mode 100644 index 00000000..65d3453a --- /dev/null +++ b/Tactility/Source/app/crashdiagnostics/CrashDiagnostics.cpp @@ -0,0 +1,121 @@ +#ifdef ESP_PLATFORM + +#include +#include "lvgl.h" +#include "lvgl/Statusbar.h" +#include "service/loader/Loader.h" +#include "qrcode.h" +#include "QrHelpers.h" +#include "QrUrl.h" + +#define TAG "crash_diagnostics" + +namespace tt::app::crashdiagnostics { + +void onContinuePressed(TT_UNUSED lv_event_t* event) { + tt::service::loader::stopApp(); + tt::service::loader::startApp("Desktop"); +} + +static void onShow(TT_UNUSED AppContext& app, lv_obj_t* parent) { + auto* display = lv_obj_get_display(parent); + int32_t parent_height = lv_display_get_vertical_resolution(display) - STATUSBAR_HEIGHT; + + lv_obj_add_event_cb(parent, onContinuePressed, LV_EVENT_CLICKED, nullptr); + auto* top_label = lv_label_create(parent); + lv_label_set_text(top_label, "Oops! We've crashed ..."); // TODO: Funny messages + lv_obj_align(top_label, LV_ALIGN_TOP_MID, 0, 2); + + auto* bottom_label = lv_label_create(parent); + lv_label_set_text(bottom_label, "Tap screen to continue"); + lv_obj_align(bottom_label, LV_ALIGN_BOTTOM_MID, 0, -2); + + std::string url = getUrlFromCrashData(); + TT_LOG_I(TAG, "%s", url.c_str()); + size_t url_length = url.length(); + + int qr_version; + if (!getQrVersionForBinaryDataLength(url_length, qr_version)) { + TT_LOG_E(TAG, "QR is too large"); + service::loader::stopApp(); + return; + } + + TT_LOG_I(TAG, "QR version %d (length: %d)", qr_version, url_length); + auto qrcodeData = std::make_shared(qrcode_getBufferSize(qr_version)); + if (qrcodeData == nullptr) { + TT_LOG_E(TAG, "Failed to allocate QR buffer"); + service::loader::stopApp(); + return; + } + + QRCode qrcode; + TT_LOG_I(TAG, "QR init text"); + if (qrcode_initText(&qrcode, qrcodeData.get(), qr_version, ECC_LOW, url.c_str()) != 0) { + TT_LOG_E(TAG, "QR init text failed"); + service::loader::stopApp(); + return; + } + + TT_LOG_I(TAG, "QR size: %d", qrcode.size); + + // Calculate QR dot size + int32_t top_label_height = lv_obj_get_height(top_label) + 2; + int32_t bottom_label_height = lv_obj_get_height(bottom_label) + 2; + TT_LOG_I(TAG, "Create canvas"); + int32_t available_height = parent_height - top_label_height - bottom_label_height; + int32_t available_width = lv_display_get_horizontal_resolution(display); + int32_t smallest_size = TT_MIN(available_height, available_width); + int32_t pixel_size; + if (qrcode.size * 2 <= smallest_size) { + pixel_size = 2; + } else if (qrcode.size <= smallest_size) { + pixel_size = 1; + } else { + TT_LOG_E(TAG, "QR code won't fit screen"); + service::loader::stopApp(); + return; + } + + auto* canvas = lv_canvas_create(parent); + lv_obj_set_size(canvas, pixel_size * qrcode.size, pixel_size * qrcode.size); + lv_obj_align(canvas, LV_ALIGN_CENTER, 0, 0); + lv_canvas_fill_bg(canvas, lv_color_black(), LV_OPA_COVER); + lv_obj_set_content_height(canvas, qrcode.size * pixel_size); + lv_obj_set_content_width(canvas, qrcode.size * pixel_size); + + TT_LOG_I(TAG, "Create draw buffer"); + auto* draw_buf = lv_draw_buf_create(pixel_size * qrcode.size, pixel_size * qrcode.size, LV_COLOR_FORMAT_RGB565, LV_STRIDE_AUTO); + if (draw_buf == nullptr) { + TT_LOG_E(TAG, "Draw buffer alloc"); + service::loader::stopApp(); + return; + } + + lv_canvas_set_draw_buf(canvas, draw_buf); + + for (uint8_t y = 0; y < qrcode.size; y++) { + for (uint8_t x = 0; x < qrcode.size; x++) { + bool colored = qrcode_getModule(&qrcode, x, y); + auto color = colored ? lv_color_white() : lv_color_black(); + int32_t pos_x = x * pixel_size; + int32_t pos_y = y * pixel_size; + for (int px = 0; px < pixel_size; px++) { + for (int py = 0; py < pixel_size; py++) { + lv_canvas_set_px(canvas, pos_x + px, pos_y + py, color, LV_OPA_COVER); + } + } + } + } +} + +extern const AppManifest manifest = { + .id = "CrashDiagnostics", + .name = "Crash Diagnostics", + .type = TypeHidden, + .onShow = onShow +}; + +} // namespace + +#endif \ No newline at end of file diff --git a/Tactility/Source/app/crashdiagnostics/QrHelpers.cpp b/Tactility/Source/app/crashdiagnostics/QrHelpers.cpp new file mode 100644 index 00000000..e36935f9 --- /dev/null +++ b/Tactility/Source/app/crashdiagnostics/QrHelpers.cpp @@ -0,0 +1,27 @@ +#include +#include +#include "QrHelpers.h" + +/** + * Maps QR version (starting at a fictitious 0) to the usable byte size for L(ow) CRC checking QR. + * + * See https://www.qrcode.com/en/about/version.html + */ +uint16_t qr_version_binary_sizes[] = { + 0, 17, 32, 53, 78, 106, 134, 154, 192, 230, // 0 - 9 + 271, 321, 367, 425, 458, 520, 586, 644, 718, 792, // 10-19 + 858, 929, 1003, 1091, 1171, 1273, 1367, 1465, 1528, 1682, // 20-29 + 1732, 1840, 1952, 2068, 2188, 2303, 2431, 2563, 2699, 2809, 2953 // 30-40 +}; + +bool getQrVersionForBinaryDataLength(size_t inLength, int& outVersion) { + static_assert(sizeof(qr_version_binary_sizes) == 41 * sizeof(int16_t)); + for (int version = 1; version < 41; version++) { + if (inLength <= qr_version_binary_sizes[version]) { + outVersion = version; + return true; + } + } + return false; +} + diff --git a/Tactility/Source/app/crashdiagnostics/QrHelpers.h b/Tactility/Source/app/crashdiagnostics/QrHelpers.h new file mode 100644 index 00000000..3af6c771 --- /dev/null +++ b/Tactility/Source/app/crashdiagnostics/QrHelpers.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +bool getQrVersionForBinaryDataLength(size_t inLength, int& outVersion); diff --git a/Tactility/Source/app/crashdiagnostics/QrUrl.cpp b/Tactility/Source/app/crashdiagnostics/QrUrl.cpp new file mode 100644 index 00000000..38ed5b8a --- /dev/null +++ b/Tactility/Source/app/crashdiagnostics/QrUrl.cpp @@ -0,0 +1,43 @@ +#ifdef ESP_TARGET + +#include "QrUrl.h" + +#include "kernel/PanicHandler.h" +#include "Log.h" + +#include +#include + +std::string getUrlFromCrashData() { + auto* crash_data = getRtcCrashData(); + auto* stack_buffer = (uint32_t*) malloc(crash_data->callstackLength * 2 * sizeof(uint32_t)); + for (int i = 0; i < crash_data->callstackLength; ++i) { + const CallstackFrame&frame = crash_data->callstack[i]; + uint32_t pc = esp_cpu_process_stack_pc(frame.pc); + uint32_t sp = frame.sp; + stack_buffer[i * 2] = pc; + stack_buffer[(i * 2) + 1] = sp; + } + + assert(sizeof(CallstackFrame) == 8); + + std::stringstream stream; + + stream << "https://oops.bytewelder.com?"; + stream << "i=1"; // Application id + stream << "&v=" << TT_VERSION; // Version + stream << "&a=" << CONFIG_IDF_TARGET; // Architecture + stream << "&s="; // Stacktrace + + for (int i = crash_data->callstackLength - 1; i >= 0; --i) { + uint32_t pc = stack_buffer[(i * 2)]; + uint32_t sp = stack_buffer[(i * 2) + 1]; + stream << std::hex << pc << std::hex << sp; + } + + free(stack_buffer); + + return stream.str(); +} + +#endif diff --git a/Tactility/Source/app/crashdiagnostics/QrUrl.h b/Tactility/Source/app/crashdiagnostics/QrUrl.h new file mode 100644 index 00000000..1fe6b671 --- /dev/null +++ b/Tactility/Source/app/crashdiagnostics/QrUrl.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +std::string getUrlFromCrashData(); diff --git a/Tactility/Source/app/files/Files.cpp b/Tactility/Source/app/files/Files.cpp index 97dfb87d..d168d894 100644 --- a/Tactility/Source/app/files/Files.cpp +++ b/Tactility/Source/app/files/Files.cpp @@ -233,6 +233,8 @@ static void onShow(AppContext& app, lv_obj_t* parent) { } static void onStart(AppContext& app) { + auto* test = new uint32_t; + delete test; auto data = std::make_shared(); // PC platform is bound to current work directory because of the LVGL file system mapping if (kernel::getPlatform() == kernel::PlatformSimulator) { diff --git a/TactilityCore/CMakeLists.txt b/TactilityCore/CMakeLists.txt index 20235642..24da6529 100644 --- a/TactilityCore/CMakeLists.txt +++ b/TactilityCore/CMakeLists.txt @@ -9,7 +9,7 @@ if (DEFINED ENV{ESP_IDF_VERSION}) idf_component_register( SRCS ${SOURCE_FILES} INCLUDE_DIRS "Source/" - REQUIRES mbedtls nvs_flash + REQUIRES mbedtls nvs_flash esp_rom ) add_definitions(-DESP_PLATFORM) diff --git a/TactilityCore/Source/kernel/PanicHandler.cpp b/TactilityCore/Source/kernel/PanicHandler.cpp new file mode 100644 index 00000000..65b5fe8e --- /dev/null +++ b/TactilityCore/Source/kernel/PanicHandler.cpp @@ -0,0 +1,63 @@ +#ifdef ESP_PLATFORM + +#include "PanicHandler.h" + +#include +#include +#include +#include +#include + +extern "C" { + +static RTC_NOINIT_ATTR CrashData crashData; + +void __real_esp_panic_handler(void* info); + +void __wrap_esp_panic_handler(void* info) { + + esp_backtrace_frame_t frame = { + .pc = 0, + .sp = 0, + .next_pc = 0, + .exc_frame = nullptr + }; + + crashData.callstackLength = 0; + + esp_backtrace_get_start(&frame.pc, &frame.sp, &frame.next_pc); + crashData.callstack[0].pc = frame.pc; + crashData.callstack[0].sp = frame.sp; + crashData.callstackLength++; + + uint32_t max_framecount = (1024 - 1) / sizeof(esp_backtrace_frame_t); + crashData.callstackCorrupted = !(esp_stack_ptr_is_sane(frame.sp) && + (esp_ptr_executable((void *)esp_cpu_process_stack_pc(frame.pc)) || + /* Ignore the first corrupted PC in case of InstrFetchProhibited */ + (frame.exc_frame && ((XtExcFrame *)frame.exc_frame)->exccause == EXCCAUSE_INSTR_PROHIBITED))); + + while ( + frame.next_pc != 0 && + !crashData.callstackCorrupted + && crashData.callstackLength < CRASH_DATA_CALLSTACK_LIMIT + ) { + if (esp_backtrace_get_next_frame(&frame)) { + crashData.callstack[crashData.callstackLength].pc = frame.pc; + crashData.callstack[crashData.callstackLength].sp = frame.sp; + crashData.callstackLength++; + } else { + crashData.callstackCorrupted = true; + break; + } + } + + // TODO: Handle corrupted logic + + __real_esp_panic_handler(info); +} + +} + +const CrashData* getRtcCrashData() { return &crashData; } + +#endif \ No newline at end of file diff --git a/TactilityCore/Source/kernel/PanicHandler.h b/TactilityCore/Source/kernel/PanicHandler.h new file mode 100644 index 00000000..d461a21e --- /dev/null +++ b/TactilityCore/Source/kernel/PanicHandler.h @@ -0,0 +1,22 @@ +#ifdef ESP_PLATFORM + +#pragma once + +#include + +#define CRASH_DATA_CALLSTACK_LIMIT 32 // bytes + +struct CallstackFrame { + uint32_t pc = 0; + uint32_t sp = 0; +}; + +struct CrashData { + bool callstackCorrupted = false; + uint8_t callstackLength = 0; + CallstackFrame callstack[CRASH_DATA_CALLSTACK_LIMIT]; +}; + +const CrashData* getRtcCrashData(); + +#endif \ No newline at end of file