[SOLVED] Using 2D arrays with different row sizes?

Projects Programming
1

I'm currently trying to make a 24x5 pixel led matrix and I need to use a 2D array to store the 3x5 pixel font. I intend using a nested for() loop to print every letter one by one with a space in between each one of them.

My problem, is that not all of the characters from the font array occupies the same space. This means that if I define the size of the array, using the sizeof() function will return a constant number in my nested for() loop. That's important because it will register all the characters to having the same number of bytes and some characters will have some extra 0x00 bytes at the end.

For now I'm only testing it on the serial monitor. Here's my code:

uint8_t alphabet[95][3] = { // I need to declare a size of 3 in the second pair of brackets, ore else it won't compile (That's the problem!)
  { 0x00, 0x00, 0x00 },  // " "
  { 0x17 },              // "!"
  { 0x03, 0x00, 0x03 },  // """
  { 0x1F, 0x0A, 0x1F },  // "#"
  { 0x0B, 0x1F, 0x0D },  // "$"
  { 0x19, 0x04, 0x13 },  // "%"
  { 0x0A, 0x15, 0x1A },  // "&"
  { 0x03 },              // "'"
  { 0x0E, 0x11 },        // "("
  { 0x11, 0x0E },        // ")"
  { 0x05, 0x02, 0x05 },  // "*"
  { 0x04, 0x0E, 0x04 },  // "+"
  { 0x18 },              // ","
  { 0x04, 0x04, 0x04 },  // "-"
  { 0x10 },              // "."
  { 0x18, 0x04, 0x03 },  // "/"
  { 0x1F, 0x11, 0x1F },  // "0"
  { 0x12, 0x1F, 0x10 },  // "1"
  { 0x19, 0x15, 0x12 },  // "2"
  { 0x11, 0x15, 0x1F },  // "3"
  { 0x07, 0x04, 0x1F },  // "4"
  { 0x17, 0x15, 0x1D },  // "5"
  { 0x1E, 0x15, 0x1D },  // "6"
  { 0x01, 0x01, 0x1F },  // "7"
  { 0x1F, 0x15, 0x1F },  // "8"
  { 0x17, 0x15, 0x1F },  // "9"
  { 0x0A },              // ":"
  { 0x1A },              // ";"
  { 0x04, 0x0A, 0x11 },  // "<"
  { 0x0A, 0x0A, 0x0A },  // "="
  { 0x11, 0x0A, 0x04 },  // ">"
  { 0x01, 0x15, 0x03 },  // "?"
  { 0x0E, 0x11, 0x17 },  // "@"
  { 0x1F, 0x05, 0x1F },  // "A"
  { 0x1F, 0x15, 0x1B },  // "B"
  { 0x1F, 0x11, 0x11 },  // "C"
  { 0x1F, 0x11, 0x0E },  // "D"
  { 0x1F, 0x15, 0x11 },  // "E"
  { 0x1F, 0x05, 0x01 },  // "F"
  { 0x1F, 0x11, 0x1D },  // "G"
  { 0x1F, 0x04, 0x1F },  // "H"
  { 0x11, 0x1F, 0x11 },  // "I"
  { 0x18, 0x10, 0x1F },  // "J"
  { 0x1F, 0x04, 0x1B },  // "K"
  { 0x1F, 0x10, 0x10 },  // "L"
  { 0x1F, 0x06, 0x1F },  // "M"
  { 0x1F, 0x01, 0x1F },  // "N"
  { 0x1F, 0x11, 0x1F },  // "O"
  { 0x1F, 0x05, 0x07 },  // "P"
  { 0x0F, 0x19, 0x0F },  // "Q"
  { 0x1F, 0x05, 0x1A },  // "R"
  { 0x17, 0x15, 0x1D },  // "S"
  { 0x01, 0x1F, 0x01 },  // "T"
  { 0x1F, 0x10, 0x1F },  // "U"
  { 0x0F, 0x10, 0x1F },  // "V"
  { 0x1F, 0x0C, 0x1F },  // "W"
  { 0x1B, 0x04, 0x1B },  // "X"
  { 0x07, 0x1C, 0x07 },  // "Y"
  { 0x19, 0x15, 0x13 },  // "Z"
  { 0x1F, 0x11 },        // "["
  { 0x03, 0x04, 0x18 },  // "\"
  { 0x11, 0x1F },        // "]"
  { 0x02, 0x01, 0x02 },  // "^"
  { 0x10, 0x10, 0x10 },  // "_"
  { 0x01, 0x02 },        // "`"
  { 0x0c, 0x12, 0x1E },  // "a"
  { 0x1F, 0x12, 0x0C },  // "b"
  { 0x1E, 0x12, 0x12 },  // "c"
  { 0x0C, 0x12, 0x1F },  // "d"
  { 0x0C, 0x1A, 0x14 },  // "e"
  { 0x04, 0x1F, 0x05 },  // "f"
  { 0x17, 0x15, 0x0F },  // "g"
  { 0x1F, 0x02, 0x1C },  // "h"
  { 0x1D },              // "i"
  { 0x10, 0x0D },        // "j"
  { 0x1F, 0x04, 0x1A },  // "k"
  { 0x01, 0x1F },        // "l"
  { 0x1E, 0x04, 0x1E },  // "m"
  { 0x1E, 0x02, 0x1E },  // "n"
  { 0x1E, 0x12, 0x1E },  // "o"
  { 0x1F, 0x09, 0x06 },  // "p"
  { 0x06, 0x09, 0x1F },  // "q"
  { 0x1E, 0x02, 0x06 },  // "r"
  { 0x14, 0x12, 0x0A },  // "s"
  { 0x02, 0x0F, 0x02 },  // "t"
  { 0x1E, 0x10, 0x1E },  // "u"
  { 0x0E, 0x10, 0x0E },  // "v"
  { 0x1E, 0x08, 0x1E },  // "w"
  { 0x1A, 0x04, 0x1A },  // "x"
  { 0x17, 0x14, 0x0F },  // "y"
  { 0x1A, 0x12, 0x16 },  // "z"
  { 0x04, 0x1F, 0x11 },  // "{"
  { 0x1F },              // "|"
  { 0x11, 0x1F, 0x04 },  // "}"
  { 0x04, 0x0C, 0x08 }   // "~"
};

Void setup() {
  Serial.begin(9600);
  for (uint8_t i = 0; i < 95; i++) {
    Serial.print("Character: ");
    Serial.write(i + 32);
    Serial.println();
    Serial.println("Letter Size: " + String(sizeof(alphabet[i])));
    for (uint8_t j = 0; j < sizeof(alphabet[i]); j++) {
      Serial.println(alphabet[i][j] + 0x80, BIN);
      delay(1);
    }
    Serial.println();
  }
}

void loop(){
}

Here's the output: (There's a leading bit to align the bytes together)

Character:  // Space
Character Size: 3
10000000
10000000
10000000

Character: !
Character Size: 3 // Should be 1
10010111
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte


Character: "
Character Size: 3
10000011
10000000
10000011

Character: #
Character Size: 3
10011111
10001010
10011111

Character: $
Character Size: 3
10001011
10011111
10001101

Character: %
Character Size: 3
10011001
10000100
10010011

Character: &
Character Size: 3
10001010
10010101
10011010

Character: '
Character Size: 3 // Should be 1
10000011
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: (
Character Size: 3 // Should be 2
10001110
10010001
10000000 // Extra 0x00 byte

Character: )
Character Size: 3 // Should be 2
10010001
10001110
10000000 // Extra 0x00 byte

Character: *
Character Size: 3
10000101
10000010
10000101

Character: +
Character Size: 3
10000100
10001110
10000100

Character: ,
Character Size: 3 // Should be 1
10011000
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: -
Character Size: 3
10000100
10000100
10000100

Character: .
Character Size: 3 // Should be 1
10010000
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: /
Character Size: 3
10011000
10000100
10000011

Character: 0
Character Size: 3
10011111
10010001
10011111

Character: 1
Character Size: 3
10010010
10011111
10010000

Character: 2
Character Size: 3
10011001
10010101
10010010

Character: 3
Character Size: 3
10010001
10010101
10011111

Character: 4
Character Size: 3
10000111
10000100
10011111

Character: 5
Character Size: 3
10010111
10010101
10011101

Character: 6
Character Size: 3
10011110
10010101
10011101

Character: 7
Character Size: 3
10000001
10000001
10011111

Character: 8
Character Size: 3
10011111
10010101
10011111

Character: 9
Character Size: 3
10010111
10010101
10011111

Character: :
Character Size: 3 // Should be 1
10001010
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: ;
Character Size: 3 // Should be 1
10011010
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: <
Character Size: 3
10000100
10001010
10010001

Character: =
Character Size: 3
10001010
10001010
10001010

Character: >
Character Size: 3
10010001
10001010
10000100

Character: ?
Character Size: 3
10000001
10010101
10000011

Character: @
Character Size: 3
10001110
10010001
10010111

Character: A
Character Size: 3
10011111
10000101
10011111

Character: B
Character Size: 3
10011111
10010101
10011011

Character: C
Character Size: 3
10011111
10010001
10010001

Character: D
Character Size: 3
10011111
10010001
10001110

Character: E
Character Size: 3
10011111
10010101
10010001

Character: F
Character Size: 3
10011111
10000101
10000001

Character: G
Character Size: 3
10011111
10010001
10011101

Character: H
Character Size: 3
10011111
10000100
10011111

Character: I
Character Size: 3
10010001
10011111
10010001

Character: J
Character Size: 3
10011000
10010000
10011111

Character: K
Character Size: 3
10011111
10000100
10011011

Character: L
Character Size: 3
10011111
10010000
10010000

Character: M
Character Size: 3
10011111
10000110
10011111

Character: N
Character Size: 3
10011111
10000001
10011111

Character: O
Character Size: 3
10011111
10010001
10011111

Character: P
Character Size: 3
10011111
10000101
10000111

Character: Q
Character Size: 3
10001111
10011001
10001111

Character: R
Character Size: 3
10011111
10000101
10011010

Character: S
Character Size: 3
10010111
10010101
10011101

Character: T
Character Size: 3
10000001
10011111
10000001

Character: U
Character Size: 3
10011111
10010000
10011111

Character: V
Character Size: 3
10001111
10010000
10011111

Character: W
Character Size: 3
10011111
10001100
10011111

Character: X
Character Size: 3
10011011
10000100
10011011

Character: Y
Character Size: 3
10000111
10011100
10000111

Character: Z
Character Size: 3
10011001
10010101
10010011

Character: [
Character Size: 3 // Should be 2
10011111
10010001
10000000 // Extra 0x00 byte

Character: \
Character Size: 3
10000011
10000100
10011000

Character: ]
Character Size: 3 // Should be 2
10010001
10011111
10000000 // Extra 0x00 byte

Character: ^
Character Size: 3
10000010
10000001
10000010

Character: _
Character Size: 3
10010000
10010000
10010000

Character: `
Character Size: 3 // Should be 2
10000001
10000010
10000000 // Extra 0x00 byte

Character: a
Character Size: 3
10001100
10010010
10011110

Character: b
Character Size: 3
10011111
10010010
10001100

Character: c
Character Size: 3
10011110
10010010
10010010

Character: d
Character Size: 3
10001100
10010010
10011111

Character: e
Character Size: 3
10001100
10011010
10010100

Character: f
Character Size: 3
10000100
10011111
10000101

Character: g
Character Size: 3
10010111
10010101
10001111

Character: h
Character Size: 3
10011111
10000010
10011100

Character: i
Character Size: 3 // Should be 1
10011101
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character: j
Character Size: 3 // Should be 2
10010000
10001101
10000000 // Extra 0x00 byte

Character: k
Character Size: 3
10011111
10000100
10011010

Character: l
Character Size: 3 // Should be 2
10000001
10011111
10000000 // Extra 0x00 byte

Character: m
Character Size: 3
10011110
10000100
10011110

Character: n
Character Size: 3
10011110
10000010
10011110

Character: o
Character Size: 3
10011110
10010010
10011110

Character: p
Character Size: 3
10011111
10001001
10000110

Character: q
Character Size: 3
10000110
10001001
10011111

Character: r
Character Size: 3
10011110
10000010
10000110

Character: s
Character Size: 3
10010100
10010010
10001010

Character: t
Character Size: 3
10000010
10001111
10000010

Character: u
Character Size: 3
10011110
10010000
10011110

Character: v
Character Size: 3
10001110
10010000
10001110

Character: w
Character Size: 3
10011110
10001000
10011110

Character: x
Character Size: 3
10011010
10000100
10011010

Character: y
Character Size: 3
10010111
10010100
10001111

Character: z
Character Size: 3
10011010
10010010
10010110

Character: {
Character Size: 3
10000100
10011111
10010001

Character: |
Character Size: 3 // Should be 1
10011111
10000000 // Extra 0x00 byte
10000000 // Extra 0x00 byte

Character }
Character Size: 3
10010001
10011111
10000100

Character: ~
Character Size: 3
10000100
10001100
10001000

As you can see, all the characters have an equal amount of bytes, 3. But in the array, some characters (for example: a comma) are only one byte long. So I need a way to declare the array and still be able to get the actual size of each row of the array.

I would greatly appreciate your help!

─ ArduMasterPro44 ─

2

Every row of the array must have a same size. It is how an array defined in C language.

3

Is there a way to declare the maximum length but still be able to get the actual size with the sizeof() function?

4

That 2D array won't work. You need to specify the number of bytes for each character, if variable.

One approach would be to make the array 4 bytes per character, with the first byte being the number of bytes or bits actually occupied by the character data. But all four bytes must be filled with something.

5

I thought of that, but I hoped for an easier way to do it. I guess I'll try it.

I'll get back to you when I do it.

─ ArduMasterPro44 ─

6

Not with sizeof() function. Create additional array, that will be contains a char sizes

7

You need to change the concept of working with the font. See font examples in graphic libraries - as a rule they do not use two-dimensional arrays.
Usually a one-dimensional array is used and in addition to it a table of width, height and number of bytes in each character

8

Ok, I'll try it

9

A 3x5 pixel font is fixed size, and the font data fit into two bytes.

There is nothing variable about that, so where is the problem? A 1D array of 16 bit unsigned integers is all you need.

10

I just wanted it to be flexible, and I'm currently trying jremington's response.

11

jremington's response worked. Thanks!

My new code:

uint8_t alphabet[95][4] = {
  { 3, 0x00, 0x00, 0x00 },  // " "
  { 1, 0x17, 0x00, 0x00 },  // "!"
  { 3, 0x03, 0x00, 0x03 },  // """
  { 3, 0x1F, 0x0A, 0x1F },  // "#"
  { 3, 0x0B, 0x1F, 0x0D },  // "$"
  { 3, 0x19, 0x04, 0x13 },  // "%"
  { 3, 0x0A, 0x15, 0x1A },  // "&"
  { 1, 0x03, 0x00, 0x00 },  // "'"
  { 2, 0x0E, 0x11, 0x00 },  // "("
  { 2, 0x11, 0x0E, 0x00 },  // ")"
  { 3, 0x05, 0x02, 0x05 },  // "*"
  { 3, 0x04, 0x0E, 0x04 },  // "+"
  { 1, 0x18, 0x00, 0x00 },  // ","
  { 3, 0x04, 0x04, 0x04 },  // "-"
  { 1, 0x10, 0x00, 0x00 },  // "."
  { 3, 0x18, 0x04, 0x03 },  // "/"
  { 3, 0x1F, 0x11, 0x1F },  // "0"
  { 3, 0x12, 0x1F, 0x10 },  // "1"
  { 3, 0x19, 0x15, 0x12 },  // "2"
  { 3, 0x11, 0x15, 0x1F },  // "3"
  { 3, 0x07, 0x04, 0x1F },  // "4"
  { 3, 0x17, 0x15, 0x1D },  // "5"
  { 3, 0x1E, 0x15, 0x1D },  // "6"
  { 3, 0x01, 0x01, 0x1F },  // "7"
  { 3, 0x1F, 0x15, 0x1F },  // "8"
  { 3, 0x17, 0x15, 0x1F },  // "9"
  { 1, 0x0A, 0x00, 0x00 },  // ":"
  { 1, 0x1A, 0x00, 0x00 },  // ";"
  { 3, 0x04, 0x0A, 0x11 },  // "<"
  { 3, 0x0A, 0x0A, 0x0A },  // "="
  { 3, 0x11, 0x0A, 0x04 },  // ">"
  { 3, 0x01, 0x15, 0x03 },  // "?"
  { 3, 0x0E, 0x11, 0x17 },  // "@"
  { 3, 0x1F, 0x05, 0x1F },  // "A"
  { 3, 0x1F, 0x15, 0x1B },  // "B"
  { 3, 0x1F, 0x11, 0x11 },  // "C"
  { 3, 0x1F, 0x11, 0x0E },  // "D"
  { 3, 0x1F, 0x15, 0x11 },  // "E"
  { 3, 0x1F, 0x05, 0x01 },  // "F"
  { 3, 0x1F, 0x11, 0x1D },  // "G"
  { 3, 0x1F, 0x04, 0x1F },  // "H"
  { 3, 0x11, 0x1F, 0x11 },  // "I"
  { 3, 0x18, 0x10, 0x1F },  // "J"
  { 3, 0x1F, 0x04, 0x1B },  // "K"
  { 3, 0x1F, 0x10, 0x10 },  // "L"
  { 3, 0x1F, 0x06, 0x1F },  // "M"
  { 3, 0x1F, 0x01, 0x1F },  // "N"
  { 3, 0x1F, 0x11, 0x1F },  // "O"
  { 3, 0x1F, 0x05, 0x07 },  // "P"
  { 3, 0x0F, 0x19, 0x0F },  // "Q"
  { 3, 0x1F, 0x05, 0x1A },  // "R"
  { 3, 0x17, 0x15, 0x1D },  // "S"
  { 3, 0x01, 0x1F, 0x01 },  // "T"
  { 3, 0x1F, 0x10, 0x1F },  // "U"
  { 3, 0x0F, 0x10, 0x1F },  // "V"
  { 3, 0x1F, 0x0C, 0x1F },  // "W"
  { 3, 0x1B, 0x04, 0x1B },  // "X"
  { 3, 0x07, 0x1C, 0x07 },  // "Y"
  { 3, 0x19, 0x15, 0x13 },  // "Z"
  { 2, 0x1F, 0x11, 0x00 },  // "["
  { 3, 0x03, 0x04, 0x18 },  // "\"
  { 2, 0x11, 0x1F, 0x00 },  // "]"
  { 3, 0x02, 0x01, 0x02 },  // "^"
  { 3, 0x10, 0x10, 0x10 },  // "_"
  { 2, 0x01, 0x02, 0x00 },   // "`"
  { 3, 0x0c, 0x12, 0x1E },  // "a"
  { 3, 0x1F, 0x12, 0x0C },  // "b"
  { 3, 0x1E, 0x12, 0x12 },  // "c"
  { 3, 0x0C, 0x12, 0x1F },  // "d"
  { 3, 0x0C, 0x1A, 0x14 },  // "e"
  { 3, 0x04, 0x1F, 0x05 },  // "f"
  { 3, 0x17, 0x15, 0x0F },  // "g"
  { 3, 0x1F, 0x02, 0x1C },  // "h"
  { 1, 0x1D, 0x00, 0x00 },  // "i"
  { 2, 0x10, 0x0D, 0x00 },  // "j"
  { 3, 0x1F, 0x04, 0x1A },  // "k"
  { 2, 0x01, 0x1F, 0x00 },  // "l"
  { 3, 0x1E, 0x04, 0x1E },  // "m"
  { 3, 0x1E, 0x02, 0x1E },  // "n"
  { 3, 0x1E, 0x12, 0x1E },  // "o"
  { 3, 0x1F, 0x09, 0x06 },  // "p"
  { 3, 0x06, 0x09, 0x1F },  // "q"
  { 3, 0x1E, 0x02, 0x06 },  // "r"
  { 3, 0x14, 0x12, 0x0A },  // "s"
  { 3, 0x02, 0x0F, 0x02 },  // "t"
  { 3, 0x1E, 0x10, 0x1E },  // "u"
  { 3, 0x0E, 0x10, 0x0E },  // "v"
  { 3, 0x1E, 0x08, 0x1E },  // "w"
  { 3, 0x1A, 0x04, 0x1A },  // "x"
  { 3, 0x17, 0x14, 0x0F },  // "y"
  { 3, 0x1A, 0x12, 0x16 },  // "z"
  { 3, 0x04, 0x1F, 0x11 },  // "{"
  { 1, 0x1F, 0x00, 0x00 },  // "|"
  { 3, 0x11, 0x1F, 0x04 },  // "}"
  { 3, 0x04, 0x0C, 0x08 }   // "~"
};

void setup(){
Serial.begin(9600);
  for (uint8_t i = 0; i < 95; i++) {
    Serial.print("Character: ");
    Serial.write(i + 32);
    Serial.println();
    Serial.println("Character Size: " + String(alphabet[i][0]));
    for (uint8_t j = 0; j < alphabet[i][0]; j++) {
      Serial.println(alphabet[i][j + 1] + 0x80, BIN);
      delay(1);
    }
    Serial.println();
  }
}

void loop(){
}

And my output:

Character:  // Space
Character Size: 3
10000000
10000000
10000000

Character: !
Character Size: 1
10010111

Character: "
Character Size: 3
10000011
10000000
10000011

Character: #
Character Size: 3
10011111
10001010
10011111

Character: $
Character Size: 3
10001011
10011111
10001101

Character: %
Character Size: 3
10011001
10000100
10010011

Character: &
Character Size: 3
10001010
10010101
10011010

Character: '
Character Size: 1
10000011

Character: (
Character Size: 2
10001110
10010001

Character: )
Character Size: 2
10010001
10001110

Character: *
Character Size: 3
10000101
10000010
10000101

Character: +
Character Size: 3
10000100
10001110
10000100

Character: ,
Character Size: 1
10011000

Character: -
Character Size: 3
10000100
10000100
10000100

Character: .
Character Size: 1
10010000

Character: /
Character Size: 3
10011000
10000100
10000011

Character: 0
Character Size: 3
10011111
10010001
10011111

Character: 1
Character Size: 3
10010010
10011111
10010000

Character: 2
Character Size: 3
10011001
10010101
10010010

Character: 3
Character Size: 3
10010001
10010101
10011111

Character: 4
Character Size: 3
10000111
10000100
10011111

Character: 5
Character Size: 3
10010111
10010101
10011101

Character: 6
Character Size: 3
10011110
10010101
10011101

Character: 7
Character Size: 3
10000001
10000001
10011111

Character: 8
Character Size: 3
10011111
10010101
10011111

Character: 9
Character Size: 3
10010111
10010101
10011111

Character: :
Character Size: 1
10001010

Character: ;
Character Size: 1
10011010

Character: <
Character Size: 3
10000100
10001010
10010001

Character: =
Character Size: 3
10001010
10001010
10001010

Character: >
Character Size: 3
10010001
10001010
10000100

Character: ?
Character Size: 3
10000001
10010101
10000011

Character: @
Character Size: 3
10001110
10010001
10010111

Character: A
Character Size: 3
10011111
10000101
10011111

Character: B
Character Size: 3
10011111
10010101
10011011

Character: C
Character Size: 3
10011111
10010001
10010001

Character: D
Character Size: 3
10011111
10010001
10001110

Character: E
Character Size: 3
10011111
10010101
10010001

Character: F
Character Size: 3
10011111
10000101
10000001

Character: G
Character Size: 3
10011111
10010001
10011101

Character: H
Character Size: 3
10011111
10000100
10011111

Character: I
Character Size: 3
10010001
10011111
10010001

Character: J
Character Size: 3
10011000
10010000
10011111

Character: K
Character Size: 3
10011111
10000100
10011011

Character: L
Character Size: 3
10011111
10010000
10010000

Character: M
Character Size: 3
10011111
10000110
10011111

Character: N
Character Size: 3
10011111
10000001
10011111

Character: O
Character Size: 3
10011111
10010001
10011111

Character: P
Character Size: 3
10011111
10000101
10000111

Character: Q
Character Size: 3
10001111
10011001
10001111

Character: R
Character Size: 3
10011111
10000101
10011010

Character: S
Character Size: 3
10010111
10010101
10011101

Character: T
Character Size: 3
10000001
10011111
10000001

Character: U
Character Size: 3
10011111
10010000
10011111

Character: V
Character Size: 3
10001111
10010000
10011111

Character: W
Character Size: 3
10011111
10001100
10011111

Character: X
Character Size: 3
10011011
10000100
10011011

Character: Y
Character Size: 3
10000111
10011100
10000111

Character: Z
Character Size: 3
10011001
10010101
10010011

Character: [
Character Size: 2
10011111
10010001

Character: \
Character Size: 3
10000011
10000100
10011000

Character: ]
Character Size: 2
10010001
10011111

Character: ^
Character Size: 3
10000010
10000001
10000010

Character: _
Character Size: 3
10010000
10010000
10010000

Character: `
Character Size: 2
10000001
10000010

Character: a
Character Size: 3
10001100
10010010
10011110

Character: b
Character Size: 3
10011111
10010010
10001100

Character: c
Character Size: 3
10011110
10010010
10010010

Character: d
Character Size: 3
10001100
10010010
10011111

Character: e
Character Size: 3
10001100
10011010
10010100

Character: f
Character Size: 3
10000100
10011111
10000101

Character: g
Character Size: 3
10010111
10010101
10001111

Character: h
Character Size: 3
10011111
10000010
10011100

Character: i
Character Size: 1
1011101

Character: j
Character Size: 2
10010000
10001101

Character: k
Character Size: 3
10011111
10000100
10011010

Character: l
Character Size: 2
10000001
10011111

Character: m
Character Size: 3
10011110
10000100
10011110

Character: n
Character Size: 3
10011110
10000010
10011110

Character: o
Character Size: 3
10011110
10010010
10011110

Character: p
Character Size: 3
10011111
10001001
10000110

Character: q
Character Size: 3
10000110
10001001
10011111

Character: r
Character Size: 3
10011110
10000010
10000110

Character: s
Character Size: 3
10010100
10010010
10001010

Character: t
Character Size: 3
10000010
10001111
10000010

Character: u
Character Size: 3
10011110
10010000
10011110

Character: v
Character Size: 3
10001110
10010000
10001110

Character: w
Character Size: 3
10011110
10001000
10011110

Character: x
Character Size: 3
10011010
10000100
10011010

Character: y
Character Size: 3
10010111
10010100
10001111

Character: z
Character Size: 3
10011010
10010010
10010110

Character: {
Character Size: 3
10000100
10011111
10010001

Character: |
Character Size: 1
10011111

Character: }
Character Size: 3
10010001
10011111
10000100

Character: ~
Character Size: 3
10000100
10001100
10001000

Thanks

─ ArduMasterPro44 ─

12

You could have used the two last bits (because they are never used) of the first byte of each character to store its length

13

I put it before, but I could have put it after too. For some reason I preferred at the beginning.

14

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.