6.6 KiB
UUID
Arduino library for generating UUID strings.
Description
This library provides a UUID generator class. A UUID is an Universally Unique IDentifier of 128 bits. These are typically written in the following format, defined in RFC-4122.
0ac82d02-002b-4ccb-b96c-1c7839cbc4c0
^ ^
The length is 32 hexadecimal digits + four hyphens = 36 characters. Note that the hexadecimal digits are all lower case.
The 0.1.1 version of the lib tries to follow the RFC-4122, for version 4 (random generated) and variant 1. In the format above the version 4 is indicated by the first arrow and must be 4. The variant 1 is at the position of the second arrow. This nibble must be 8, 9, A or B. All the remaining bits are random.
The basis for the UUID class is a Marsaglia pseudo random number generator (PRNG). Note: This PRNG must be seeded with two real random uint32_t to get real random UUID's. Regular reseeding with external entropy improves randomness. Default it will generate the same sequence as it uses the same seeds. This is useful for testing.
Often one sees also the term GUID = Globally Unique Identifier.
Tested on Arduino UNO + ESP32.
Interface
#include "UUID.h"
UUID class
The UUID class has only a few methods.
- UUID() Constructor, initializes internals an generates a default UUID.
- void seed(uint32_t s1, uint32_t s2 = 0) reseeds the internal pseudo random number generator. It is mandatory to set s1 while s2 is optional. The combination {0, 0} is not allowed and overruled in software.
- void generate() generates a new UUID depending on the mode.
- UUID_MODE_RANDOM: all UUID bits are random.
- UUID_MODE_VARIANT4: the UUID (tries to) conform to version 4 variant 1. See above. This is the default.
- char * toCharArray() returns a pointer to a char buffer representing the last generated UUID. Multiple subsequent calls to toCharArray() gives the same UUID until generate() is called again.
Mode
Only two modi are supported, default is the UUID_MODE_VARIANT4. This is conform RFC-4122.
- void setVariant4Mode() set mode to UUID_MODE_VARIANT4.
- void setRandomMode() set mode to UUID_MODE_RANDOM.
- uint8_t getMode() returns mode set.
Printable
The UUID class implements the Printable interface. This allows one to print the UUID object directly over Serial and any other stream implementing the Print interface. Think Ethernet or SD card.
UUID uuid;
Serial.println(uuid);
// gives same output as
Serial.println(uuid.toCharArray());
Performance
Performance measured with UUID_test.ino shows the following times:
microseconds per byte
| Version | Function | UNO 16 MHz | ESP32 240 MHz |
|---|---|---|---|
| 0.1.0 | seed | 4 us | |
| 0.1.0 | generate | 412 us | |
| 0.1.0 | toCharArray | 4 us | |
| 0.1.1 | seed | 4 us | |
| 0.1.1 | generate | 248 us | |
| 0.1.1 | toCharArray | 4 us | |
| 0.1.2 | generate | 156 us | |
| 0.1.3 | generate | 120 us | |
| - | - | ||
| 0.1.4 | seed | 4 us | 3 us |
| 0.1.4 | generate | 120 us | 14 us |
| 0.1.4 | toCharArray | 4 us | 0 us |
| 0.1.5 | seed | 4 us | 4 us |
| 0.1.5 | generate | 120 us | 15 us |
| 0.1.5 | toCharArray | 4 us | 1 us |
Note: generating the 16 random bytes already takes ~40 us (UNO).
UUID's per second
indicative maximum performance (see example sketch)
| Version | UNO 16 MHz | ESP32 240 MHz | notes |
|---|---|---|---|
| 0.1.0 | 2000++ | both modi | |
| 0.1.1 | 4000++ | both modi | |
| 0.1.2 | 6400++ | both modi | |
| 0.1.3 | 8200++ | both modi | |
| 0.1.4 | 8268 | 31970 | VARIANT4 |
| 0.1.4 | 8418 | 34687 | RANDOM |
| 0.1.5 | 8268 | 31969 | VARIANT4 |
| 0.1.5 | 8418 | 34689 | RANDOM |
Note that these maxima are not realistic e.g. for a server. Other tasks need to be done too (listening, transfer etc.).
Future
Must
- improve documentation
- background
- test other platforms
Should
- optimize
- reduce footprint
- can the buffer be reduced?
- buffer as static char in generate is ~2% faster on AVR (not shocking, impact ?)
- smaller / faster random generator?
Could
- investigate entropy harvesting
- micros() between calls.
- freeRAM, timers, RAM, USB-ID, ...
- compile constants DATE and TIME
- see example
- auto reseed function?
- e.g. micros() between calls.
- GUID as derived class?
- (further identical?)
- add setUpperCase() and setLowerCase(), isUpperCase()
- one bool flag
- binary output in a byte array
- getBinary(uint8_t * array)
- need to store them from generate.
- add examples
- ESP32 UUID server => using timing of the calls as entropy !
- RTC for entropy
- EEPROM to store last seeds? (n)
Won't
- support for { and }
- add setSeparator(char) and getSeparator() ?
- minus is the RFC specification.
- move code to .h so compiler can optimize more?
- next() add 1 to UUID to generate a continuous sequence ?