neil/Flipper
1
0
Fork 0
mirror of https://github.com/UberGuidoZ/Flipper.git synced 2024-12-22 06:20:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added QR Code source (thanks bmatcuk!)

Browse Source
This commit is contained in:
UberGuidoZ 2023-01-03 08:57:45 -08:00 committed by GitHub
parent bab0146653
commit 3aafb87a92
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1809 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/LICENSE Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2022 Bob Matcuk
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.

156
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/README.md Normal file
View File

@ -0,0 +1,156 @@
# flipperzero-qrcode
Display qrcodes on the [Flipper Zero]
## Download
Grab the latest `qrcode.fap` from [Releases].
## Installation
Copy the `qrcode.fap` file onto your [Flipper Zero] sd card in the `apps/Tools`
directory. Then create a top level directory called `qrcodes` to store your
qrcode files. This can be done using [qFlipper], for example, by
draging-and-dropping `qrcode.fap` into `apps/Tools` and then navigating back to
the top level (where the directories like `infrared` and `nfc` live), right
click, and create a new folder called `qrcodes`.
## Creating QR Codes
qrcode files are simple text files with the extension `.qrcode`. This app will
expect them to live in a top-level directory on your sd card called `qrcodes`.
They should have the following content:
```
Filetype: QRCode
Version: 0
Message: your content here
```
### Message Format
qrcodes support 4 formats called "modes": numeric, alpha-numeric, binary, and
kanji. Because of the limited screen real-estate on the [Flipper Zero], you'll
want to pick the best mode for the data you are trying to display.
The app will automatically detect the best mode to use, so the only thing you
need to do is make sure the message in your file is formatted to use the best
mode. For example, if your message is entirely numeric, make sure you don't
include any extraneous punctuation in your file. If you're only encoding a
domain name, make sure it's uppercase to take advantage of alpha-numeric mode,
etc.
#### Numeric Mode
Consists of only numbers, nothing else. This mode can encode the most data.
#### Alpha-Numeric Mode
This mode can encode numbers, uppercase letters *only*, spaces, and the
following symbols: `$%*+-./:`. This format _may_ be appropriate for urls, as
long as you're only encoding the domain name and you remember to use uppercase
letters (ex: `HTTP://EXAMPLE.COM`). If your url includes some path after the
domain, you'll likely need to use binary mode because the paths are usually
case-sensitive.
A qrcode in alpha-numeric mode can encode ~40% less data than numeric mode.
#### Binary Mode
This mode is a little bit of a misnomer: binary mode simply means that the
message will be encoded as 8-bit bytes. The qrcode standard stipulates that
text will use ISO-8859-1 (also known as Latin-1) encoding, _not_ utf8 as would
be the standard these days. However, _some_ readers _may_ automatically detect
utf8. To be standard-compliant, that basically means you can only use Latin
letters, numbers, and symbols.
A qrcode in binary mode can encode ~60% less data than numeric mode, and ~30%
less than alpha-numeric.
#### Kanji Mode
This mode is unsupported, so I won't go into detail. A limitation of the
underlying qrcode library that I'm using, unfortunately. If there's interest,
perhaps I'll hack in support sometime.
## Using the App
The app is fairly straightforward. When it first starts, the file browser will
automatically open to the `qrcodes` directory and display any `.qrcode` files.
Select one using the arrow keys and the center button. The qrcode will display.
If you push the right arrow, some stats will display: the qrcode "Version" -
which corresponds to how big it is; the ECC level - which determines the
qrcode's resilience to damage, such as a dirty screen (Low, Medium, Quartile,
and High); and the qrcode Mode (Numeric, Alpha-Numeric, Binary, or Kanji).
While viewing the stats, you can select Version or ECC using the up and down
arrows and the center button. You can then increase or decrease the Version or
ECC using up and down and save your choice using the center buttton. This
feature was mostly added for my own amusement and testing, but, theoretically,
it may help a reader that's having trouble if the default ECC is less than the
highest value ("H"): you can increase the Version by 1 and then set the ECC to
"H". Whether or not this helps depends on the reader.
You can hide the stats by pressing the left arrow.
When you're done viewing the qrcode, press the back button to return to the
file browser. If you push the back button in the file browser, the app will
exit.
I will ask that you temper your expectations: the Flipper Zero screen is small
and many readers may have difficulty reading the qrcodes, especially if they
are encoding a lot of data. However, I have successfully got my iPhone to read
qrcodes encoding phone numbers, wifi info, and a url, all the way up to a
version 11 qrcode (ie, the largest size the screen will fit).
## Example: Wifi QRCodes
Most phones can automatically connect to wifi networks from a qrcode. If you
should like to encode your wifi's connection info into a qrcode, here's how
you'd do it:
```
Filetype: QRCode
Version: 0
Message: WIFI:S:<ssid>;P:<password>;T:<encryption>;
```
Replace `<ssid>` with the name of your wifi, `<password>` with the password.
`<encryption>` would be "WPA" or "WEP". If your wifi is open (no password),
this can be "None" and you can remove `P:<password>;` from the message. If your
wifi is hidden (ie, does not broadcast the ssid), you can add `H:true;` to the
end.
Note that if your ssid or password contain any of these characters: `\";,:`,
you'll need to "escape" it by placing a backslash (`\`) before it.
For example, if my ssid was "wifiball" and not broadcast, and the password was
"pa$$:word" with WPA encryption, the message would be:
```
Message: WIFI:S:wifiball;P:pa$$\:word;T:WPA;H:true;
```
## Building
First, clone the [flipperzero-firmware] repo and then clone this repo in the
`applications_user` directory:
```bash
git clone git@github.com:flipperdevices/flipperzero-firmware.git
cd flipperzero-firmware/applications_user
git clone git@github.com:bmatcuk/flipperzero-qrcode.git
```
Next, in the base of the [flipperzero-firmware] directory, run fbt:
```bash
cd ..
./fbt fap_qrcode
```
This will automatically install dependencies and build the application. When it
has finished building, the .fap will be in
`build/f7-firmware-D/.extapps/qrcode.fap` (fbt output will tell you where to
find the .fap, should it change in the future).
## qrcode library
This application uses the [QRCode] library by ricmoo. This is the same library
that is in the lib directory of the flipper-firmware repo (which was originally
included for a [now-removed demo app]), but modified slightly to fix some
compiler errors.
[now-removed demo app]: https://github.com/flipperdevices/flipperzero-firmware/pull/160/files
[flipperzero-firmware]: https://github.com/flipperdevices/flipperzero-firmware
[Flipper Zero]: https://flipperzero.one/
[QRCode]: https://github.com/ricmoo/QRCode
[qFlipper]: https://docs.flipperzero.one/qflipper
[Releases]: https://github.com/bmatcuk/flipperzero-qrcode/releases/latest

19
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/application.fam Normal file
View File

@ -0,0 +1,19 @@
App(
appid="qrcode",
name="qrcode",
fap_version=(1,1),
fap_description="Display qrcodes",
fap_author="Bob Matcuk",
fap_weburl="https://github.com/bmatcuk/flipperzero-qrcode",
apptype=FlipperAppType.EXTERNAL,
entry_point="qrcode_app",
stack_size=2 * 1024,
cdefines=["APP_QRCODE"],
requires=[
"gui",
"dialogs",
],
fap_category="Tools",
fap_icon="icons/qrcode_10px.png",
fap_icon_assets="icons",
)

BIN
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/icons/qrcode_10px.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 KiB

858
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/qrcode.c Normal file
View File

@ -0,0 +1,858 @@
/**
* 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 <stdlib.h>
#include <string.h>
#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 >= qrcode->size || 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) {
}
*/

100
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/qrcode.h Normal file
View File

@ -0,0 +1,100 @@
/**
* 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 <stdbool.h>
#include <stdint.h>
// 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_ */

586
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/qrcode_app.c Normal file
View File

@ -0,0 +1,586 @@
#include <furi.h>
#include <dialogs/dialogs.h>
#include <gui/gui.h>
#include <storage/storage.h>
#include <lib/flipper_format/flipper_format.h>
// this file is generated by the build script
#include <qrcode_icons.h>
#include "qrcode.h"
#define TAG "qrcode"
#define QRCODE_FOLDER ANY_PATH("qrcodes")
#define QRCODE_EXTENSION ".qrcode"
#define QRCODE_FILETYPE "QRCode"
#define QRCODE_FILE_VERSION 0
/**
* Maximum version is 11 because the f0 screen is only 64 pixels high and
* version 12 is 65x65. Version 11 is 61x61.
*/
#define MAX_QRCODE_VERSION 11
/** Maximum length by mode, ecc, and version */
static const uint16_t MAX_LENGTH[3][4][MAX_QRCODE_VERSION] = {
{
// Numeric
{41, 77, 127, 187, 255, 322, 370, 461, 552, 652, 772}, // Low
{34, 63, 101, 149, 202, 255, 293, 365, 432, 513, 604}, // Medium
{27, 48, 77, 111, 144, 178, 207, 259, 312, 364, 427}, // Quartile
{17, 34, 58, 82, 106, 139, 154, 202, 235, 288, 331}, // High
},
{
// Alphanumeric
{25, 47, 77, 114, 154, 195, 224, 279, 335, 395, 468}, // Low
{20, 38, 61, 90, 122, 154, 178, 221, 262, 311, 366}, // Medium
{16, 29, 47, 67, 87, 108, 125, 157, 189, 221, 259}, // Quartile
{10, 20, 35, 50, 64, 84, 93, 122, 143, 174, 200}, // High
},
{
// Binary
{17, 32, 53, 78, 106, 134, 154, 192, 230, 271, 321}, // Low
{14, 26, 42, 62, 84, 106, 122, 152, 180, 213, 251}, // Medium
{11, 20, 32, 46, 60, 74, 86, 108, 130, 151, 177}, // Quartile
{7, 14, 24, 34, 44, 58, 64, 84, 98, 119, 137}, // High
},
};
/** Main app instance */
typedef struct {
FuriMessageQueue* input_queue;
Gui* gui;
ViewPort* view_port;
FuriMutex** mutex;
FuriString* message;
QRCode* qrcode;
uint8_t min_version;
uint8_t max_ecc_at_min_version;
bool loading;
bool too_long;
bool show_stats;
uint8_t selected_idx;
bool edit;
uint8_t set_version;
uint8_t set_ecc;
} QRCodeApp;
/**
* @param ecc ECC number
* @returns a character corresponding to the ecc level
*/
static char get_ecc_char(uint8_t ecc) {
switch (ecc) {
case 0: return 'L';
case 1: return 'M';
case 2: return 'Q';
case 3: return 'H';
default: return '?';
}
}
/**
* @param mode qrcode mode
* @returns a character corresponding to the mode
*/
static char get_mode_char(uint8_t mode) {
switch (mode) {
case 0: return 'N';
case 1: return 'A';
case 2: return 'B';
case 3: return 'K';
default: return '?';
}
}
/**
* Render
* @param canvas The canvas to render to
* @param ctx Context provided to the callback by view_port_draw_callback_set
*/
static void render_callback(Canvas* canvas, void* ctx) {
furi_assert(canvas);
furi_assert(ctx);
QRCodeApp* instance = ctx;
furi_check(furi_mutex_acquire(instance->mutex, FuriWaitForever) == FuriStatusOk);
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
uint8_t font_height = canvas_current_font_height(canvas);
uint8_t width = canvas_width(canvas);
uint8_t height = canvas_height(canvas);
if (instance->loading) {
canvas_draw_str_aligned(canvas, width / 2, height / 2, AlignCenter, AlignCenter, "Loading...");
} else if (instance->qrcode) {
uint8_t size = instance->qrcode->size;
uint8_t pixel_size = height / size;
uint8_t top = (height - pixel_size * size) / 2;
uint8_t left = ((instance->show_stats ? 65 : width) - pixel_size * size) / 2;
for (uint8_t y = 0; y < size; y++) {
for (uint8_t x = 0; x < size; x++) {
if (qrcode_getModule(instance->qrcode, x, y)) {
if (pixel_size == 1) {
canvas_draw_dot(canvas, left + x * pixel_size, top + y * pixel_size);
} else {
canvas_draw_box(canvas, left + x * pixel_size, top + y * pixel_size, pixel_size, pixel_size);
}
}
}
}
if (instance->show_stats) {
top = 10;
left = 66;
FuriString* str = furi_string_alloc();
if (!instance->edit || instance->selected_idx == 0) {
furi_string_printf(str, "Ver: %i", instance->set_version);
canvas_draw_str(canvas, left + 5, top + font_height, furi_string_get_cstr(str));
if (instance->selected_idx == 0) {
canvas_draw_triangle(canvas, left, top + font_height / 2, font_height - 4, 4, CanvasDirectionLeftToRight);
}
if (instance->edit) {
uint8_t arrow_left = left + 5 + canvas_string_width(canvas, "Ver: 8") / 2;
canvas_draw_triangle(canvas, arrow_left, top, font_height - 4, 4, CanvasDirectionBottomToTop);
canvas_draw_triangle(canvas, arrow_left, top + font_height + 1, font_height - 4, 4, CanvasDirectionTopToBottom);
}
}
if (!instance->edit || instance->selected_idx == 1) {
furi_string_printf(str, "ECC: %c", get_ecc_char(instance->set_ecc));
canvas_draw_str(canvas, left + 5, 2 * font_height + top + 2, furi_string_get_cstr(str));
if (instance->selected_idx == 1) {
canvas_draw_triangle(canvas, left, 3 * font_height / 2 + top + 2, font_height - 4, 4, CanvasDirectionLeftToRight);
}
if (instance->edit) {
uint8_t arrow_left = left + 5 + canvas_string_width(canvas, "ECC: H") / 2;
canvas_draw_triangle(canvas, arrow_left, font_height + top + 2, font_height - 4, 4, CanvasDirectionBottomToTop);
canvas_draw_triangle(canvas, arrow_left, 2 * font_height + top + 3, font_height - 4, 4, CanvasDirectionTopToBottom);
}
}
if (!instance->edit) {
furi_string_printf(str, "Mod: %c", get_mode_char(instance->qrcode->mode));
canvas_draw_str(canvas, left + 5, 3 * font_height + top + 4, furi_string_get_cstr(str));
}
furi_string_free(str);
}
} else {
uint8_t margin = (height - font_height * 2) / 3;
canvas_draw_str_aligned(canvas, width / 2, margin, AlignCenter, AlignTop, "Could not load qrcode.");
if (instance->too_long) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, width / 2, margin * 2 + font_height, "Message is too long.");
}
}
furi_mutex_release(instance->mutex);
}
/**
* Handle input
* @param input_event The received input event
* @param ctx Context provided to the callback by view_port_input_callback_set
*/
static void input_callback(InputEvent* input_event, void* ctx) {
furi_assert(input_event);
furi_assert(ctx);
if (input_event->type == InputTypeShort) {
QRCodeApp* instance = ctx;
furi_message_queue_put(instance->input_queue, input_event, 0);
}
}
/**
* Determine if the given string is all numeric
* @param str The string to test
* @returns true if the string is all numeric
*/
static bool is_numeric(const char* str, uint16_t len) {
furi_assert(str);
while (len > 0) {
char c = str[--len];
if (c < '0' || c > '9') return false;
}
return true;
}
/**
* Determine if the given string is alphanumeric
* @param str The string to test
* @returns true if the string is alphanumeric
*/
static bool is_alphanumeric(const char* str, uint16_t len) {
furi_assert(str);
while (len > 0) {
char c = str[--len];
if (c >= '0' && c <= '9') continue;
if (c >= 'A' && c <= 'Z') continue;
if (c == ' '
|| c == '$'
|| c == '%'
|| c == '*'
|| c == '+'
|| c == '-'
|| c == '.'
|| c == '/'
|| c == ':')
continue;
return false;
}
return true;
}
/**
* Allocate a qrcode
* @param version qrcode version
* @returns an allocated QRCode
*/
static QRCode* qrcode_alloc(uint8_t version) {
QRCode* qrcode = malloc(sizeof(QRCode));
qrcode->modules = malloc(qrcode_getBufferSize(version));
return qrcode;
}
/**
* Free a QRCode
* @param qrcode The QRCode to free
*/
static void qrcode_free(QRCode* qrcode) {
furi_assert(qrcode);
free(qrcode->modules);
free(qrcode);
}
/**
* Rebuild the qrcode. Assumes that instance->message is the message to encode,
* that the mutex has been acquired, and the specified version/ecc will be
* sufficiently large enough to encode the full message. It is also assumed
* that the old qrcode will be free'd by the caller.
* @param instance The qrcode app instance
* @param version The qrcode version to use
* @param ecc The qrcode ECC level to use
* @returns true if the qrcode was successfully created
*/
static bool rebuild_qrcode(QRCodeApp* instance, uint8_t version, uint8_t ecc) {
furi_assert(instance);
furi_assert(instance->message);
const char* cstr = furi_string_get_cstr(instance->message);
uint16_t len = strlen(cstr);
instance->qrcode = qrcode_alloc(version);
int8_t res = qrcode_initBytes(instance->qrcode, instance->qrcode->modules, version, ecc, (uint8_t*)cstr, len);
if (res != 0) {
FURI_LOG_E(TAG, "Could not create qrcode");
qrcode_free(instance->qrcode);
instance->qrcode = NULL;
return false;
}
return true;
}
/**
* Load a qrcode from a string
* @param instance The qrcode app instance
* @param str The message to encode as a qrcode
* @returns true if the string was successfully loaded
*/
static bool qrcode_load_string(QRCodeApp* instance, FuriString* str) {
furi_assert(instance);
furi_assert(str);
furi_check(furi_mutex_acquire(instance->mutex, FuriWaitForever) == FuriStatusOk);
if (instance->message) {
furi_string_free(instance->message);
instance->message = NULL;
}
if (instance->qrcode) {
qrcode_free(instance->qrcode);
instance->qrcode = NULL;
}
instance->too_long = false;
instance->show_stats = false;
instance->selected_idx = 0;
instance->edit = false;
bool result = false;
do {
const char* cstr = furi_string_get_cstr(str);
uint16_t len = strlen(cstr);
instance->message = furi_string_alloc_set(str);
if (!instance->message) {
FURI_LOG_E(TAG, "Could not allocate message");
break;
}
// figure out the qrcode "mode"
uint8_t mode = MODE_BYTE;
if (is_numeric(cstr, len)) mode = MODE_NUMERIC;
else if (is_alphanumeric(cstr, len)) mode = MODE_ALPHANUMERIC;
// Figure out the smallest qrcode version that'll fit all of the data -
// we prefer the smallest version to maximize the pixel size of each
// module to improve reader performance. Here, version is the 0-based
// index. The qrcode_initBytes function will want a 1-based version
// number, so we'll add one later.
uint8_t ecc = ECC_LOW;
uint8_t version = 0;
while (version < MAX_QRCODE_VERSION && MAX_LENGTH[mode][ecc][version] < len) {
version++;
}
if (version == MAX_QRCODE_VERSION) {
instance->too_long = true;
break;
}
// Figure out the maximum ECC we can use. I shouldn't need to
// bounds-check ecc in this loop because I already know from the loop
// above that ECC_LOW (0) works... don't forget to add one to that
// version number...
ecc = ECC_HIGH;
while (MAX_LENGTH[mode][ecc][version] < len) {
ecc--;
}
version++;
// Build the qrcode
if (!rebuild_qrcode(instance, version, ecc)) {
furi_string_free(instance->message);
instance->message = NULL;
break;
}
instance->min_version = instance->set_version = version;
instance->max_ecc_at_min_version = instance->set_ecc = ecc;
result = true;
} while (false);
instance->loading = false;
furi_mutex_release(instance->mutex);
return result;
}
/**
* Load a qrcode from a file
* @param instance The qrcode app instance
* @param file_path Path to the file to read
* @returns true if the file was successfully loaded
*/
static bool qrcode_load_file(QRCodeApp* instance, const char* file_path) {
furi_assert(instance);
furi_assert(file_path);
FuriString* temp_str = furi_string_alloc();
bool result = false;
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* file = flipper_format_file_alloc(storage);
do {
if (!flipper_format_file_open_existing(file, file_path)) break;
uint32_t version = 0;
if (!flipper_format_read_header(file, temp_str, &version)) break;
if (furi_string_cmp_str(temp_str, QRCODE_FILETYPE)
|| version != QRCODE_FILE_VERSION) {
FURI_LOG_E(TAG, "Incorrect file format or version");
break;
}
if (!flipper_format_read_string(file, "Message", temp_str)) {
FURI_LOG_E(TAG, "Message is missing");
break;
}
if (!qrcode_load_string(instance, temp_str)) {
break;
}
result = true;
} while (false);
furi_record_close(RECORD_STORAGE);
flipper_format_free(file);
furi_string_free(temp_str);
return result;
}
/**
* Allocate the qrcode app
* @returns a qrcode app instance
*/
static QRCodeApp* qrcode_app_alloc() {
QRCodeApp* instance = malloc(sizeof(QRCodeApp));
instance->input_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
instance->view_port = view_port_alloc();
view_port_draw_callback_set(instance->view_port, render_callback, instance);
view_port_input_callback_set(instance->view_port, input_callback, instance);
instance->gui = furi_record_open(RECORD_GUI);
gui_add_view_port(instance->gui, instance->view_port, GuiLayerFullscreen);
instance->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
instance->message = NULL;
instance->qrcode = NULL;
instance->loading = true;
instance->too_long = false;
instance->show_stats = false;
instance->selected_idx = 0;
instance->edit = false;
return instance;
}
/**
* Free the qrcode app
* @param qrcode_app The app to free
*/
static void qrcode_app_free(QRCodeApp* instance) {
if (instance->message) furi_string_free(instance->message);
if (instance->qrcode) qrcode_free(instance->qrcode);
gui_remove_view_port(instance->gui, instance->view_port);
furi_record_close(RECORD_GUI);
view_port_free(instance->view_port);
furi_message_queue_free(instance->input_queue);
furi_mutex_free(instance->mutex);
free(instance);
}
/** App entrypoint */
int32_t qrcode_app(void* p) {
QRCodeApp* instance = qrcode_app_alloc();
FuriString* file_path = furi_string_alloc();
do {
if (p && strlen(p)) {
furi_string_set(file_path, (const char*)p);
} else {
furi_string_set(file_path, QRCODE_FOLDER);
DialogsFileBrowserOptions browser_options;
dialog_file_browser_set_basic_options(
&browser_options, QRCODE_EXTENSION, &I_qrcode_10px);
browser_options.hide_ext = true;
browser_options.base_path = QRCODE_FOLDER;
DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
bool res = dialog_file_browser_show(dialogs, file_path, file_path, &browser_options);
furi_record_close(RECORD_DIALOGS);
if (!res) {
FURI_LOG_E(TAG, "No file selected");
break;
}
}
if (!qrcode_load_file(instance, furi_string_get_cstr(file_path))) {
FURI_LOG_E(TAG, "Unable to load file");
}
InputEvent input;
while (furi_message_queue_get(instance->input_queue, &input, FuriWaitForever) == FuriStatusOk) {
furi_check(furi_mutex_acquire(instance->mutex, FuriWaitForever) == FuriStatusOk);
if (input.key == InputKeyBack) {
if (instance->message) {
furi_string_free(instance->message);
instance->message = NULL;
}
if (instance->qrcode) {
qrcode_free(instance->qrcode);
instance->qrcode = NULL;
}
instance->loading = true;
instance->edit = false;
furi_mutex_release(instance->mutex);
break;
} else if (input.key == InputKeyRight) {
instance->show_stats = true;
} else if (input.key == InputKeyLeft) {
instance->show_stats = false;
} else if (instance->show_stats && !instance->loading && instance->qrcode) {
if (input.key == InputKeyUp) {
if (!instance->edit) {
instance->selected_idx = MAX(0, instance->selected_idx - 1);
} else {
if (instance->selected_idx == 0 && instance->set_version < MAX_QRCODE_VERSION) {
instance->set_version++;
} else if (instance->selected_idx == 1) {
uint8_t max_ecc = instance->set_version == instance->min_version ? instance->max_ecc_at_min_version : ECC_HIGH;
if (instance->set_ecc < max_ecc) {
instance->set_ecc++;
}
}
}
} else if (input.key == InputKeyDown) {
if (!instance->edit) {
instance->selected_idx = MIN(1, instance->selected_idx + 1);
} else {
if (instance->selected_idx == 0 && instance->set_version > instance->min_version) {
instance->set_version--;
if (instance->set_version == instance->min_version) {
instance->set_ecc = MAX(instance->set_ecc, instance->max_ecc_at_min_version);
}
} else if (instance->selected_idx == 1 && instance->set_ecc > 0) {
instance->set_ecc--;
}
}
} else if (input.key == InputKeyOk) {
if (instance->edit && (instance->set_version != instance->qrcode->version || instance->set_ecc != instance->qrcode->ecc)) {
QRCode* qrcode = instance->qrcode;
instance->loading = true;
if (rebuild_qrcode(instance, instance->set_version, instance->set_ecc)) {
qrcode_free(qrcode);
} else {
FURI_LOG_E(TAG, "Could not rebuild qrcode");
instance->qrcode = qrcode;
instance->set_version = qrcode->version;
instance->set_ecc = qrcode->ecc;
}
instance->loading = false;
}
instance->edit = !instance->edit;
}
}
furi_mutex_release(instance->mutex);
view_port_update(instance->view_port);
}
if (p && strlen(p)) {
// if started with an arg, exit instead
// of looping back to the browser
break;
}
} while (true);
furi_string_free(file_path);
qrcode_app_free(instance);
return 0;
}

26
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/scripts/check-firmware.sh Normal file
View File

@ -0,0 +1,26 @@
#!/bin/bash
set -Exeuo pipefail
print_status() {
local level="$1"
local body="${2//%/%25}"
body="${body//$'\r'/}"
body="${body//$'\n'/%0A}"
echo "::$level::$body"
}
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")"; pwd -P)"
FIRMWARE_DIR="$1"
LASTVER="$(git -C "$SCRIPT_DIR" tag | grep firmware-v | sort -V | tail -n1 | sed -e 's/^firmware-v//')"
print_status notice "last built against firmware version: $LASTVER"
VER="$(git -C "$FIRMWARE_DIR" tag | sed -E -e '/^[0-9]+\.[0-9]+\.[0-9]+$/!d' | sort -V | sed -e "1,/$LASTVER/d" | tail -n1)"
# VER="$(curl https://api.github.com/repos/flipperdevices/flipperzero-firmware/tags | jq -r --arg current "$LASTVER" 'def ver($v): $v | ltrimstr("v") | split(".") | map(tonumber); map(.name) | map(select(. | test("^\\d+\\.\\d+\\.\\d+$";"s"))) | map(ver(.)) | map(select(. > ver($current))) | sort | last | if . == null then "" else join(".") end')"
if [ -z "$VER" ]; then
print_status notice "no new firmware version"
exit 0
fi
print_status notice "new firmware version: $VER"
echo "::set-output name=version::$VER"

43
Applications/Official/DEV_FW/source/flipperzero-qrcode-1.1.0/scripts/update-firmware.sh Normal file
View File

@ -0,0 +1,43 @@
#!/bin/bash
set -Exeuo pipefail
print_status() {
local level="$1"
local body="${2//%/%25}"
body="${body//$'\r'/}"
body="${body//$'\n'/%0A}"
echo "::$level::$body"
}
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")"; pwd -P)"
FIRMWARE_VER="$1"
pushd "$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel)"
print_status notice "updating to firmware $FIRMWARE_VER"
# setup git
git config --local user.name $GIT_USER_NAME
git config --local user.email $GIT_USER_EMAIL
# construct a new version number for the qrcode app
VER="$(git tag | sed -E -e '/^v[0-9]+\.[0-9]+\.[0-9]+$/!d' | sort -V | tail -n1)"
if [[ "$VER" =~ ^(v[0-9]+.[0-9]+).([0-9]+)$ ]]; then
VER="${BASH_REMATCH[1]}.$(( ${BASH_REMATCH[2]} + 1 ))"
else
print_status warning "couldn't construct new version number from $VER"
exit 1
fi
print_status notice "new qrcode version: $VER"
# update firmware version in automation
sed -i -e "/firmware_version:/s/'.*'/'$FIRMWARE_VER'/" .github/workflows/release.yml
# commit and tag
git add .github/workflows/release.yml
git commit -m "update to firmware $FIRMWARE_VER"
git tag -a -m "$VER" "$VER"
git tag "firmware-v$FIRMWARE_VER"
git push --all
popd