font header

[Suresh6060]

First of all , let me thank you for a wonderful library.
I have used DMD32 + ESP32 for its wifi capability and cost effectiveness. However it cannot render Indian languages like Malayalam (unicode 3330 to 3439) . I think it can do only 0 to 127. Is there any such limitation for DMD_STM32 too?

problem with indian languages are the ligatures and double joints. for example
the unicode string for നമോ shall be നമ&#3403 = where
&#3368 is ന
&#3374 is മ
&#3403 is ോ - the first part goes to the left of previous character മ and the second part goes to its right. This is one issue. The second is that of double characters.
for example the english word
matt shall be മാറ്റ് a combination of 4 unicode characters &#3374, &#3390, &#3377 (double) &#3405

Not all the double characters are rendered one below the other. Some goes side by side too.

In most of the language utilities googly API is used to render the words correctly as per my understanding.

Can DMD_STM32 do this correctly. ?

[board707]

problem with indian languages are the ligatures and double joints.
Can DMD_STM32 do this correctly. ?

Hi
I think it is possible, and I have even tried using Hindi (Devanagari) with my library. However, it is not such a simple question. This library can display characters outside the range 0-127. However, this is not enough.

Firstly, all text output functions work only with single-byte characters. This means we need a font where all Hindi characters have codes from 127 to 255. And we need to convert the source text from Unicode to the encoding of our font.

Secondly, as far as I know, there are many variants of writing letters in Hindi. That is, elements can be added to each letter, displayed above or below the line. When I worked with Devanagari, these elements were used as separate letters, which led to a problem - they were drawn not under or above the letter, but next to it. This also needs to be solved.

On the link below you can read a long thread about how we tried to solve this and see pictures of what we got:
https://community.pixelmatix.com/t/how-to-display-non-english-characters-in-led-matrix/1334/1

The main problem here is that I do not know Hindi and therefore can not help much if problems arise.

[Suresh6060]

In this thread You provided a proc to display Hindi font (join)

If you have time , pls look into this.

int utf8_hindi(char* dest, const unsigned char* src) {

uint16_t i, j;
for (i = 0, j = 0; src[i]; i++) {
    if ((src[i] == 0xe0) && src[i + 1] == 0xa4) { dest[j++] = src[i+2]; i+=2;}
    else if ((src[i] == 0xe0) && src[i + 1] == 0xa5) { dest[j++] = src[i+2] + 0x40; i+=2;}
    else dest[j++] = src[i];
}
dest[j] = '\0';
return j;

}

What are the hex codes 0xe0 , 0xa4 & 0xa5. How did you get them ?

I did get DMD_STM32 running with GFX font for Malayalam. The board is able to display individual characters.

I have to send the hex code (converted from decimal code). No issues there .

Malayalam language has two kinds of issues

1. hex 0xD4A, 0xD4B & 0xD4C has three portions - left , middle and right.
   When it is detected , this character is super- imposed on the character before it while moving that character to the middle portion . which means the left portion is printed first then the actual character and then the right portion.

How is it possible to move the character like that. GFX library , as far as I know wont do that , unless some changes are made in that library which might be almost not possible ( I haven't checked those file).

Or I can create a new string with two other characters

If 0xD4A say after 0xD15 , I can make a new string like 0xD46 0xD15 0xD3E

The second issue is that of joints.

if 0xD15 is jointed with another 0xD15 , The hex string shall be 0xD15 0xD4D 0xD15
This is done in two ways. either by adding the right end part of the third character with that of the first character

or in some case stack the 3rd character below the first character in a smaller font size. The total height should be same as others, which means even the size of the first character should be reduced. The middle character (0xD4D) is ignored. It is used only to indicate a joint.

is it possible to do any of this through software , which may require modifying the Glyphs on the run.

Or will have to create new characters and modify the main string. However this requires creating the Glyphs too. I haven't understood how it is made.

It would be helpfull if you can throw some light on these aspects.

Thank you.

[board707]

Hi

What are the hex codes 0xe0 , 0xa4 & 0xa5.

The symbols of the Devanagari text are 3-byte unicode codes, starts from 0xe0a4 or 0xe0a5. The hindi() function search an input text for these byte sequences and converts it to the one-byte custom codes, that then used to output the text on matrix panel. This is how we solve the problem of working with multi-byte Unicode

How did you get them ?

I extracted these codes from the Devanagari unicode table, provided by another user.

I can create a new string with two other characters
If 0xD4A say after 0xD15 , I can make a new string like 0xD46 0xD15 0xD3E

The second issue is that of joints.
if 0xD15 is jointed with another 0xD15 , The hex string shall be 0xD15 0xD4D 0xD15

It seems that in both cases you have to preprocess the text before printing, adding the joins and another things like this:

0xD15 + 0xD15 = 0xD15 0xD4D 0xD15

[Suresh6060]

Thank you for clarifying.

//I extracted these codes from the Devanagari unicode table, provided by another user.// That explains it. It was a custom build. The standard UNICODE chart for devanagiri is from 0x0900 to 0x097F,

The first issue could be solved by creating a new string .

The second issue will require new font characters to be added to the font table along with corresponding Glyphs.

The structure of Glyph table is
/// Font data stored PER GLYPH
typedef struct {
uint16_t bitmapOffset; ///< Pointer into GFXfont->bitmap
uint8_t width; ///< Bitmap dimensions in pixels
uint8_t height; ///< Bitmap dimensions in pixels
uint8_t xAdvance; ///< Distance to advance cursor (x axis)
int8_t xOffset; ///< X dist from cursor pos to UL corner
int8_t yOffset; ///< Y dist from cursor pos to UL corner
} GFXglyph;

How is bitmapOffset found ?

for example this a GFX font

#pragma once
#include <Adafruit_GFX.h>

const uint8_t FreeMono9pt7bBitmaps[] PROGMEM = {
0xAA, 0xA8, 0x0C, 0xED, 0x24, 0x92, 0x48, 0x24, 0x48, 0x91, 0x2F, 0xE4,
0x89, 0x7F, 0x28, 0x51, 0x22, 0x40, 0x08, 0x3E, 0x62, 0x40, 0x30, 0x0E,
0x01, 0x81, 0xC3, 0xBE, 0x08, 0x08, 0x71, 0x12, 0x23, 0x80, 0x23, 0xB8,
0x0E, 0x22, 0x44, 0x70, 0x38, 0x81, 0x02, 0x06, 0x1A, 0x65, 0x46, 0xC8,
0xEC, 0xE9, 0x24, 0x5A, 0xAA, 0xA9, 0x40, 0xA9, 0x55, 0x5A, 0x80, 0x10,
0x22, 0x4B, 0xE3, 0x05, 0x11, 0x00, 0x10, 0x20, 0x47, 0xF1, 0x02, 0x04,
0x00, 0x6B, 0x48, 0xFF, 0x00, 0xF0, 0x02, 0x08, 0x10, 0x60, 0x81, 0x04,
0x08, 0x20, 0x41, 0x02, 0x08, 0x00, 0x38, 0x8A, 0x0C, 0x18, 0x30, 0x60,
0xC1, 0x82, 0x88, 0xE0, 0x27, 0x28, 0x42, 0x10, 0x84, 0x21, 0x3E, 0x38,
0x8A, 0x08, 0x10, 0x20, 0x82, 0x08, 0x61, 0x03, 0xF8, 0x7C, 0x06, 0x02,
0x02, 0x1C, 0x06, 0x01, 0x01, 0x01, 0x42, 0x3C, 0x18, 0xA2, 0x92, 0x8A,
0x28, 0xBF, 0x08, 0x21, 0xC0, 0x7C, 0x81, 0x03, 0xE4, 0x40, 0x40, 0x81,
0x03, 0x88, 0xE0, 0x1E, 0x41, 0x04, 0x0B, 0x98, 0xB0, 0xC1, 0xC2, 0x88,
0xE0, 0xFE, 0x04, 0x08, 0x20, 0x40, 0x82, 0x04, 0x08, 0x20, 0x40, 0x38,
0x8A, 0x0C, 0x14, 0x47, 0x11, 0x41, 0x83, 0x8C, 0xE0, 0x38, 0x8A, 0x1C,
0x18, 0x68, 0xCE, 0x81, 0x04, 0x13, 0xC0, 0xF0, 0x0F, 0x6C, 0x00, 0xD2,
0xD2, 0x00, 0x03, 0x04, 0x18, 0x60, 0x60, 0x18, 0x04, 0x03, 0xFF, 0x80,
0x00, 0x1F, 0xF0, 0x40, 0x18, 0x03, 0x00, 0x60, 0x20, 0x60, 0xC0, 0x80,
0x3D, 0x84, 0x08, 0x30, 0xC2, 0x00, 0x00, 0x00, 0x30, 0x3C, 0x46, 0x82,
0x8E, 0xB2, 0xA2, 0xA2, 0x9F, 0x80, 0x80, 0x40, 0x3C, 0x3C, 0x01, 0x40,
0x28, 0x09, 0x01, 0x10, 0x42, 0x0F, 0xC1, 0x04, 0x40, 0x9E, 0x3C, 0xFE,
0x21, 0x90, 0x48, 0x67, 0xE2, 0x09, 0x02, 0x81, 0x41, 0xFF, 0x80, 0x3E,
0xB0, 0xF0, 0x30, 0x08, 0x04, 0x02, 0x00, 0x80, 0x60, 0x8F, 0x80, 0xFE,
0x21, 0x90, 0x68, 0x14, 0x0A, 0x05, 0x02, 0x83, 0x43, 0x7F, 0x00, 0xFF,
0x20, 0x90, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x81, 0x40, 0xFF, 0xC0, 0xFF,
0xA0, 0x50, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x80, 0x40, 0x78, 0x00, 0x1E,
0x98, 0x6C, 0x0A, 0x00, 0x80, 0x20, 0xF8, 0x0B, 0x02, 0x60, 0x87, 0xC0,
0xE3, 0xA0, 0x90, 0x48, 0x27, 0xF2, 0x09, 0x04, 0x82, 0x41, 0x71, 0xC0,
0xF9, 0x08, 0x42, 0x10, 0x84, 0x27, 0xC0, 0x1F, 0x02, 0x02, 0x02, 0x02,
0x02, 0x82, 0x82, 0xC6, 0x78, 0xE3, 0xA1, 0x11, 0x09, 0x05, 0x83, 0x21,
0x08, 0x84, 0x41, 0x70, 0xC0, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41,
0x41, 0x41, 0xFF, 0xE0, 0xEC, 0x19, 0x45, 0x28, 0xA4, 0xA4, 0x94, 0x91,
0x12, 0x02, 0x40, 0x5C, 0x1C, 0xC3, 0xB0, 0x94, 0x4A, 0x24, 0x92, 0x49,
0x14, 0x8A, 0x43, 0x70, 0x80, 0x1E, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06,
0x02, 0x82, 0x63, 0x0F, 0x00, 0xFE, 0x43, 0x41, 0x41, 0x42, 0x7C, 0x40,
0x40, 0x40, 0xF0, 0x1C, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06, 0x02, 0x82,
0x63, 0x1F, 0x04, 0x07, 0x92, 0x30, 0xFE, 0x21, 0x90, 0x48, 0x24, 0x23,
0xE1, 0x10, 0x84, 0x41, 0x70, 0xC0, 0x3A, 0xCD, 0x0A, 0x03, 0x01, 0x80,
0xC1, 0xC7, 0x78, 0xFF, 0xC4, 0x62, 0x21, 0x00, 0x80, 0x40, 0x20, 0x10,
0x08, 0x1F, 0x00, 0xE3, 0xA0, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x82,
0x22, 0x0E, 0x00, 0xF1, 0xE8, 0x10, 0x82, 0x10, 0x42, 0x10, 0x22, 0x04,
0x80, 0x50, 0x0C, 0x00, 0x80, 0xF1, 0xE8, 0x09, 0x11, 0x25, 0x44, 0xA8,
0x55, 0x0C, 0xA1, 0x8C, 0x31, 0x84, 0x30, 0xE3, 0xA0, 0x88, 0x82, 0x80,
0x80, 0xC0, 0x90, 0x44, 0x41, 0x71, 0xC0, 0xE3, 0xA0, 0x88, 0x82, 0x81,
0x40, 0x40, 0x20, 0x10, 0x08, 0x1F, 0x00, 0xFD, 0x0A, 0x20, 0x81, 0x04,
0x10, 0x21, 0x83, 0xFC, 0xEA, 0xAA, 0xAA, 0xC0, 0x80, 0x81, 0x03, 0x02,
0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0xD5, 0x55, 0x55, 0xC0,
0x10, 0x51, 0x22, 0x28, 0x20, 0xFF, 0xE0, 0x88, 0x80, 0x7E, 0x00, 0x80,
0x47, 0xEC, 0x14, 0x0A, 0x0C, 0xFB, 0xC0, 0x20, 0x10, 0x0B, 0xC6, 0x12,
0x05, 0x02, 0x81, 0x40, 0xB0, 0xB7, 0x80, 0x3A, 0x8E, 0x0C, 0x08, 0x10,
0x10, 0x9E, 0x03, 0x00, 0x80, 0x47, 0xA4, 0x34, 0x0A, 0x05, 0x02, 0x81,
0x21, 0x8F, 0x60, 0x3C, 0x43, 0x81, 0xFF, 0x80, 0x80, 0x61, 0x3E, 0x3D,
0x04, 0x3E, 0x41, 0x04, 0x10, 0x41, 0x0F, 0x80, 0x3D, 0xA1, 0xA0, 0x50,
0x28, 0x14, 0x09, 0x0C, 0x7A, 0x01, 0x01, 0x87, 0x80, 0xC0, 0x20, 0x10,
0x0B, 0xC6, 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0xB8, 0xE0, 0x10, 0x01,
0xC0, 0x81, 0x02, 0x04, 0x08, 0x11, 0xFC, 0x10, 0x3E, 0x10, 0x84, 0x21,
0x08, 0x42, 0x3F, 0x00, 0xC0, 0x40, 0x40, 0x4F, 0x44, 0x58, 0x70, 0x48,
0x44, 0x42, 0xC7, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23,
0xF8, 0xB7, 0x64, 0x62, 0x31, 0x18, 0x8C, 0x46, 0x23, 0x91, 0x5E, 0x31,
0x90, 0x48, 0x24, 0x12, 0x09, 0x05, 0xC7, 0x3E, 0x31, 0xA0, 0x30, 0x18,
0x0C, 0x05, 0x8C, 0x7C, 0xDE, 0x30, 0x90, 0x28, 0x14, 0x0A, 0x05, 0x84,
0xBC, 0x40, 0x20, 0x38, 0x00, 0x3D, 0xA1, 0xA0, 0x50, 0x28, 0x14, 0x09,
0x0C, 0x7A, 0x01, 0x00, 0x80, 0xE0, 0xCE, 0xA1, 0x82, 0x04, 0x08, 0x10,
0x7C, 0x3A, 0x8D, 0x0B, 0x80, 0xF0, 0x70, 0xDE, 0x40, 0x40, 0xFC, 0x40,
0x40, 0x40, 0x40, 0x40, 0x41, 0x3E, 0xC3, 0x41, 0x41, 0x41, 0x41, 0x41,
0x43, 0x3D, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x20, 0xA0, 0x50, 0x10, 0xE3,
0xC0, 0x92, 0x4B, 0x25, 0x92, 0xA9, 0x98, 0x44, 0xE3, 0x31, 0x05, 0x01,
0x01, 0x41, 0x11, 0x05, 0xC7, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x40, 0xA0,
0x60, 0x10, 0x10, 0x08, 0x3E, 0x00, 0xFD, 0x08, 0x20, 0x82, 0x08, 0x10,
0xBF, 0x29, 0x24, 0xA2, 0x49, 0x26, 0xFF, 0xF8, 0x89, 0x24, 0x8A, 0x49,
0x2C, 0x61, 0x24, 0x30};

const GFXglyph FreeMono9pt7bGlyphs[] PROGMEM = {
{0, 0, 0, 11, 0, 1}, // 0x20 ' '
{0, 2, 11, 11, 4, -10}, // 0x21 '!'
{3, 6, 5, 11, 2, -10}, // 0x22 '"'
{7, 7, 12, 11, 2, -10}, // 0x23 '#'
{18, 8, 12, 11, 1, -10}, // 0x24 '$'
{30, 7, 11, 11, 2, -10}, // 0x25 '%'
{40, 7, 10, 11, 2, -9}, // 0x26 '&'
{49, 3, 5, 11, 4, -10}, // 0x27 '''
{51, 2, 13, 11, 5, -10}, // 0x28 '('
{55, 2, 13, 11, 4, -10}, // 0x29 ')'
{59, 7, 7, 11, 2, -10}, // 0x2A '*'
{66, 7, 7, 11, 2, -8}, // 0x2B '+'
{73, 3, 5, 11, 2, -1}, // 0x2C ','
{75, 9, 1, 11, 1, -5}, // 0x2D '-'
{77, 2, 2, 11, 4, -1}, // 0x2E '.'
{78, 7, 13, 11, 2, -11}, // 0x2F '/'
{90, 7, 11, 11, 2, -10}, // 0x30 '0'
{100, 5, 11, 11, 3, -10}, // 0x31 '1'
{107, 7, 11, 11, 2, -10}, // 0x32 '2'
{117, 8, 11, 11, 1, -10}, // 0x33 '3'
{128, 6, 11, 11, 3, -10}, // 0x34 '4'
{137, 7, 11, 11, 2, -10}, // 0x35 '5'
{147, 7, 11, 11, 2, -10}, // 0x36 '6'
{157, 7, 11, 11, 2, -10}, // 0x37 '7'
{167, 7, 11, 11, 2, -10}, // 0x38 '8'
{177, 7, 11, 11, 2, -10}, // 0x39 '9'
{187, 2, 8, 11, 4, -7}, // 0x3A ':'
{189, 3, 11, 11, 3, -7}, // 0x3B ';'
{194, 8, 8, 11, 1, -8}, // 0x3C '<'
{202, 9, 4, 11, 1, -6}, // 0x3D '='
{207, 9, 8, 11, 1, -8}, // 0x3E '>'
{216, 7, 10, 11, 2, -9}, // 0x3F '?'
{225, 8, 12, 11, 2, -10}, // 0x40 '@'
{237, 11, 10, 11, 0, -9}, // 0x41 'A'
{251, 9, 10, 11, 1, -9}, // 0x42 'B'
{263, 9, 10, 11, 1, -9}, // 0x43 'C'
{275, 9, 10, 11, 1, -9}, // 0x44 'D'
{287, 9, 10, 11, 1, -9}, // 0x45 'E'
{299, 9, 10, 11, 1, -9}, // 0x46 'F'
{311, 10, 10, 11, 1, -9}, // 0x47 'G'
{324, 9, 10, 11, 1, -9}, // 0x48 'H'
{336, 5, 10, 11, 3, -9}, // 0x49 'I'
{343, 8, 10, 11, 2, -9}, // 0x4A 'J'
{353, 9, 10, 11, 1, -9}, // 0x4B 'K'
{365, 8, 10, 11, 2, -9}, // 0x4C 'L'
{375, 11, 10, 11, 0, -9}, // 0x4D 'M'
{389, 9, 10, 11, 1, -9}, // 0x4E 'N'
{401, 9, 10, 11, 1, -9}, // 0x4F 'O'
{413, 8, 10, 11, 1, -9}, // 0x50 'P'
{423, 9, 13, 11, 1, -9}, // 0x51 'Q'
{438, 9, 10, 11, 1, -9}, // 0x52 'R'
{450, 7, 10, 11, 2, -9}, // 0x53 'S'
{459, 9, 10, 11, 1, -9}, // 0x54 'T'
{471, 9, 10, 11, 1, -9}, // 0x55 'U'
{483, 11, 10, 11, 0, -9}, // 0x56 'V'
{497, 11, 10, 11, 0, -9}, // 0x57 'W'
{511, 9, 10, 11, 1, -9}, // 0x58 'X'
{523, 9, 10, 11, 1, -9}, // 0x59 'Y'
{535, 7, 10, 11, 2, -9}, // 0x5A 'Z'
{544, 2, 13, 11, 5, -10}, // 0x5B '['
{548, 7, 13, 11, 2, -11}, // 0x5C ''
{560, 2, 13, 11, 4, -10}, // 0x5D ']'
{564, 7, 5, 11, 2, -10}, // 0x5E '^'
{569, 11, 1, 11, 0, 2}, // 0x5F '_'
{571, 3, 3, 11, 3, -11}, // 0x60 '`'
{573, 9, 8, 11, 1, -7}, // 0x61 'a'
{582, 9, 11, 11, 1, -10}, // 0x62 'b'
{595, 7, 8, 11, 2, -7}, // 0x63 'c'
{602, 9, 11, 11, 1, -10}, // 0x64 'd'
{615, 8, 8, 11, 1, -7}, // 0x65 'e'
{623, 6, 11, 11, 3, -10}, // 0x66 'f'
{632, 9, 11, 11, 1, -7}, // 0x67 'g'
{645, 9, 11, 11, 1, -10}, // 0x68 'h'
{658, 7, 10, 11, 2, -9}, // 0x69 'i'
{667, 5, 13, 11, 3, -9}, // 0x6A 'j'
{676, 8, 11, 11, 2, -10}, // 0x6B 'k'
{687, 7, 11, 11, 2, -10}, // 0x6C 'l'
{697, 9, 8, 11, 1, -7}, // 0x6D 'm'
{706, 9, 8, 11, 1, -7}, // 0x6E 'n'
{715, 9, 8, 11, 1, -7}, // 0x6F 'o'
{724, 9, 11, 11, 1, -7}, // 0x70 'p'
{737, 9, 11, 11, 1, -7}, // 0x71 'q'
{750, 7, 8, 11, 3, -7}, // 0x72 'r'
{757, 7, 8, 11, 2, -7}, // 0x73 's'
{764, 8, 10, 11, 2, -9}, // 0x74 't'
{774, 8, 8, 11, 1, -7}, // 0x75 'u'
{782, 9, 8, 11, 1, -7}, // 0x76 'v'
{791, 9, 8, 11, 1, -7}, // 0x77 'w'
{800, 9, 8, 11, 1, -7}, // 0x78 'x'
{809, 9, 11, 11, 1, -7}, // 0x79 'y'
{822, 7, 8, 11, 2, -7}, // 0x7A 'z'
{829, 3, 13, 11, 4, -10}, // 0x7B '{'
{834, 1, 13, 11, 5, -10}, // 0x7C '|'
{836, 3, 13, 11, 4, -10}, // 0x7D '}'
{841, 7, 3, 11, 2, -6}}; // 0x7E '~'

const GFXfont FreeMono9pt7b PROGMEM = {(uint8_t *)FreeMono9pt7bBitmaps,
(GFXglyph *)FreeMono9pt7bGlyphs, 0x20,
0x7E, 18};

// Approx. 1516 bytes

how is bitmapOffset 3 in {3, 6, 5, 11, 2, -10}, // 0x22 '"' used or 7 in {7, 7, 12, 11, 2, -10}, // 0x23 '#' ?

do you have any info on this ?

Standard font do not use Glyph table rather it uses a width table to identify the position of character. which is simpler.

I have calculated Malayalam font requires 41 new characters for jointed characters to be added. Rest of the joints could be made easily.

it is much easier to add characters to the standard font table and specify the width in the width table than in GFX font, provided that there is no limit for adding new characters for DMD_STM32 .

I had already written codes for conversion of the original string for ESP32 and is almost finished. But ESP32 has some quirks in its overall operation which is why I thought of switching to STM32.

However using ST-Link, I am not able to Serial.print or debug (as in STM32CubeIDE). hence do not have any idea what happens inside the code. So it takes more time to detect mistakes. Life is harder. Compare this with VB6. I wrote a whole software to make a new character , extract the Hex and Binary code and width and reverse too, save it is a database for corrections in future in just 2 days. I can input a string of hex code and get to see the font character too for the standard font. I can make a new character in less than 3 minutes with it.

[board707]

How is bitmapOffset found ?

hi
For many years I have used the description of the adafruit font format posted on the link below:

https://glenviewsoftware.com/projects/products/adafonteditor/adafruit-gfx-font-format/index.html

It is very accurate and useful. However, on my last visit I noticed that the pictures depicting the character parameters are no longer available. Unfortunately, I not found another tutorial about this subject. You can try to read the description from the article above, using this picture:
https://radiokot.ru/artfiles/6741/04_pre.png

[Suresh6060]

Thanks a lot. I had totally forgotten about that website and GFX font utility mentioned there. That saves a lot of time. Hope I can swap the joint characters with newly created characters and works well.

Thanks again for the reply.

[board707]

Below another interesting link.
Although it's not a Hindy or an LED panel, it's a good example of how to display a language with Unicode characters using a byte array font.
https://github.com/balawi28/LiquidCrystalArabic

[Suresh6060]

Thank you for replying.
I am aware that it is not an easy task to implement Indian language.

Displaying fixed test is much easy. But the text to display comes from either mobile or computer typed in the Indian language. So what the controller gets is a string of unicode numbers. This string needs to be processed to display the text correctly. This is where google api comes in. However it is not possible to use it in the controller. But I can create fonts for all the single and double characters and map it to the specific unicode formations (needs a procedure to properly process the string). But this require more than 127 characters. DMD32 for ESp32 has this limitation (I think).

I have already done some work on this line to extract the unicode numbers from the string and map them to individual characters. Next I shall implement the combinations too.

Thank you very much.

[board707]

But this require more than 127 characters.

See the discussion in the my first link, where we worked with Devanagari. It has a more than 127 characters too.
However, letters can be divided into basic ones, and those that are derived from the basic ones by adding elements above or below the line. By dividing the basic letters and additional suffixes, for Devanagari we managed to write an alphabet of more than 800 symbols in a little over 100 character spaces.

[Suresh6060]

Thank you for pointing out that discussion. You have spend a lot of time on this.

I am in a bit dilemma. Whether to continue working with DMD32_ESP32 (half way through) or switch to DMD_STM32. Earlier I tried making font files with a couple of software. All failed in one way or other. So created one myself using Vb6

I can get the hex codes and width code , save and edit the font at any time. So that part is fine.

I have also kept STM32 ready. The initial setup is fine. Needs only to connect the board for testing. Let me see how it develops.
Thanks once gain. Shall keep in touch as it develops.

[board707]

Do you need any assistance from me?

[Suresh6060]

Thanks for asking.
As I see it, I will surely need your assistance for DMD_STM32. I shall take it up once the present work is over or have to abandon.

I have kept everything ready for switching over to stm32 or rpi.

between the two STM32 & RPI which in your experience is good for these projects ?

[board707]

between the two STM32 & RPI which in your experience is good for these projects ?

In case of HUB12 monochrome panels there is no much difference.

[Suresh6060]

Ok & thank you.

[Suresh6060]

Thanks to all your help, I could display the Indian-Malayalam Language characters successfully creating additional characters and updating an existing GFX font file.

Hope in a couple of days , I can finish the whole setup.

Some of the key points :
Though DMD_STM32 can display UNICODE characters of a language, additional processing may be required to display it as a functional language. Which may require additional characters. The Important point is one could create those additional characters and DMD_STM32 shall coolly display them. There is no restriction of character count (?).

There is no requirement of additional level shifters. This is great particularly for small or medium projects.

Works for both mono and rgb boards. Different library means more headache to maintain.

Use of FTDI and serial is much better than ST-Link (Not related to DMD_STM32).

Thank you very much for a wonderful library.

[board707]

Thank you for your feedback.

See below another link that may be useful in developing your own GFX fonts:
https://www.sigmdel.ca/michel/program/misc/gfxfont_8bit_en.html

[Suresh6060]

You are most welcome. You deserve more.

I have completed the code for re-formatting required for Indian Malayalam language and is under testing process.

It is displaying nicely.

Thank you for the link too. It is a wealth of core information.

Thanks a lot for all the additional support. May be someday I can compensate for your efforts.