Arduino.ru

файл FontRusProp18.c

// This comes with no warranty, implied or otherwise

// This data structure was designed to support Proportional fonts
// on Arduinos. It can however handle any ttf font that has been converted
// using the conversion program. These could be fixed width or proportional 
// fonts. Individual characters do not have to be multiples of 8 bits wide. 
// Any width is fine and does not need to be fixed.

// The data bits are packed to minimize data requirements, but the tradeoff
// is that a header is required per character.

// FontRusProp18.c
// Point Size   : 18
// Memory usage : 
// # characters : 

// Header Format (to make Arduino UTFT Compatible):
// ------------------------------------------------
// Character Width (Used as a marker to indicate use this format. i.e.: = 0x00)
// Character Height
// First Character (Reserved. 0x00)
// Number Of Characters (Reserved. 0x00)

#include <avr/pgmspace.h>

const uint8_t FontRusProp18[] PROGMEM = 
{
0x00, 0x12, 0x00, 0x00,

// Individual Character Format:
// ----------------------------
// Character Code             код символа
// Adjusted Y Offset          смещение по Y  - сколько срок с верху пустых
// Width                      ширина символа в пикселях (не знакоместа а имено картинки символа)
// Height                     высота символа в пикселях
// xOffset                    начальное смещение по X - сколько пикселей отступаем с лева по вертикали
// xDelta (the distance to move the cursor. Effective width of the character.)  Эффективная ширина символа - ширина самого символа и кол-во пикселей после символа
// Data[n]  // описание символа (целое кол-во байт = Width*Height/8 в хвосте забиваеи нулевыми битами до ближайщего целого числа)
// символ занимает по ширине xOffset+xDelta 


// NOTE: You can remove any of these characters if they are not needed in
// your application. The first character number in each Glyph indicates
// the ASCII character code. Therefore, these do not have to be sequential.
// Just remove all the content for a particular character to save space.

// ' '
0x20,0x0E,0x00,0x00,0x00,0x06,

// '!'
0x21,0x01,0x02,0x0D,0x03,0x07,
0xFF,0xFF,0xC3,0xC0,

// 'A'
0x80,0x01,0x0C,0x0D,0x00,0x0C,
0x06,0x00,0x60,0x0F,0x00,0xF0,0x19,0x81,0x98,0x19,0x83,0x0C,0x3F,0xC7,0xFE,0x60,0x66,0x06,0xC0,0x30,

// 'Б'
0x81,0x01,0x08,0x0D,0x01,0x0A,
0xFE,0xFE,0xC0,0xC0,0xC0,0xFC,0xFE,0xC3,0xC3,0xC3,0xC3,0xFE,0xFC,

// 'B'
0x82,0x01,0x09,0x0D,0x01,0x0B,
0xFC,0x7F,0xB0,0xD8,0x6C,0x37,0xF3,0xF9,0x86,0xC1,0xE0,0xF0,0xFF,0xEF,0xE0,

// 'Г'
0x83,0x01,0x08,0x0D,0x01,0x0A,
0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,

// 'Д'
0x84,0x01,0x0A,0x0E,0x01,0x0C,
0x0F,0x87,0xE3,0x98, 0xC6, 0x61, 0x98, 0x66, 0x19, 0x86, 0x61, 0x98, 0x6F, 0xFF, 0xFF, 0xC0, 0xF0, 0x30,

// 'E'
0x85,0x01,0x08,0x0D,0x01,0x0A,
0xFF,0xFF,0xC0,0xC0,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xFF,0xFF,

// 'Ё'
0xF0,0x00,0x08,0x0E,0x01,0x0A,
0x66,0x00,0xFF,0xFF,0xC0,0xC0,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xFF,0xFF,

// 'Ж'
0x86,0x01,0x0C,0x0D,0x01,0x0D,
0xC6, 0x3C, 0x63, 0xE6, 0x77, 0x6E, 0x3F, 0xC1, 0xF8, 0x0F, 0x01, 0xF8, 0x3F, 0xC7, 0x6E, 0xE6, 0x7C, 0x63, 0xC6, 0x30,

// 'З'
0x87,0x01,0x09,0x0D,0x01,0x0B,
0x7E,0x7F,0xA0,0xE0,0x30,0x39,0xF0,0xFC,0x07,0x01,0x80,0xE0,0xFF,0xE7,0xE0,

// 'И'
0x88,0x01,0x0A,0x0D,0x01,0x0C,
0xC1, 0xF0, 0x7C, 0x3F, 0x0B, 0xC6, 0xF1, 0x3C, 0xCF, 0x23, 0xD8, 0xF4, 0x3F, 0x0F, 0x83, 0xE0, 0xC0, 

// 'Й'
0x89,0x00,0x0A,0x0E,0x01,0x0C,
0x1C, 0x32, 0x7C, 0x1F, 0x0F, 0xC2, 0xF1, 0xBC, 0x4F, 0x33, 0xC8, 0xF6, 0x3D, 0x0F, 0xC3, 0xE0, 0xF8, 0x30,

// 'К'
0x8A,0x01,0x0B,0x0D,0x01,0x0C,
0xC1,0x98,0x63,0x18,0x66,0x0D,0x81,0xE0,0x3C,0x06,0xC0,0xCC,0x18,0xC3,0x0C,0x60,0xCC,0x0C,

// 'Л'
0x8B,0x01,0x08,0x0D,0x01,0x0A,
0x0F,0x1F,0x3B,0x33,0x33,0x23,0x63,0x63,0x63,0x63,0xC3,0xC3,0xC3,

// 'M'
0x8C,0x01,0x0C,0x0D,0x01,0x0E,
0xE0,0x7F,0x0F,0xF0,0xFD,0x8B,0xD9,0xBD,0x9B,0xCF,0x3C,0xF3,0xC6,0x3C,0x63,0xC0,0x3C,0x03,0xC0,0x30,

// 'Н'
0x8D,0x01,0x0A,0x0D,0x01,0x0C,
0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xFF,0xFF,0xFF,0x03,0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xC0,

// 'О'
0x8E,0x01,0x0C,0x0D,0x01,0x0D,
0x1F,0x83,0xFC,0x70,0xE6,0x06,0xC0,0x3C,0x03,0xC0,0x3C,0x03,0xC0,0x36,0x06,0x70,0xE3,0xFC,0x1F,0x80,

// 'П'
0x8F,0x01,0x0A,0x0D,0x01,0x0C,
0xFF,0xFF,0xFC,0x0F,0x03,0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xC0,

// 'Р'
0x90,0x01,0x08,0x0D,0x01,0x09,
0xFC,0xFE,0xC7,0xC3,0xC3,0xC7,0xFE,0xFC,0xC0,0xC0,0xC0,0xC0,0xC0,

// 'С'
0x91,0x01,0x0A,0x0D,0x01,0x0C,
0x1F,0x0F,0xE7,0x1F,0x81,0xE0,0x30,0x0C,0x03,0x00,0xC0,0x38,0x17,0x1C,0xFE,0x1F,0x00,

// 'Т'
0x92,0x01,0x0C,0x0D,0x00,0x0C,
0xFF,0xFF,0xFF,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,

// 'У'
0x93,0x01,0x0A,0x0D,0x00,0x0A,
0xC0,0xD8,0x62,0x18,0xCC,0x13,0x06,0x80,0xE0,0x30,0x0C,0x06,0x01,0x82,0xC0,0x60,0x00,

// 'Ф'
0x94,0x01,0x0C,0x0D,0x01,0x0D,
0x06,0x03,0xFC,0x7F,0xEC,0x63,0xC6,0x3C,0x63,0x7F,0xE3,0xFC,0x06,0x00,0x60,0x06,0x00,0x60,0x0F,0x00,

// 'X'
0x95,0x01,0x0A,0x0D,0x01,0x0B,
0xC0,0xD8,0x62,0x10,0xCC,0x12,0x07,0x80,0xC0,0x78,0x12,0x0C,0xC2,0x11,0x86,0xC0,0xC0,

// 'Ц'
0x96,0x01,0x0A,0x0F,0x01,0x0B,
0xC1,0xB0,0x6C,0x1B,0x06,0xC1,0xB0,0x6C,0x1B,0x06,0xC1,0xB0,0x6C,0x1B,0xFE,0xFF,0xC0,0x30,0x0C,

// 'Х'
0x97,0x01,0x0A,0x0D,0x01,0x0B,
0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xFF,0xF7,0xFC,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0xC0,

// 'Ш'
0x98,0x01,0x0C,0x0D,0x01,0x0E,
0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3F,0xFF,0xFF,0xF0,

// 'Щ'
0x99,0x01,0x0C,0x0F,0x01,0x0E,
//0xCC,0x6C,0xC6,0xCC,0x6C,0xC6,0xCC,0x6C,0xC6,0xCC,0x6C,0xC6,0xCC,0x6C,0xC6,0xCC,0x6F,0xFF,0xFF,0xF0,0x03,0x00,0x30,
0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3F,0xFF,0xFF,0xF0,0x07,0x00,0x70,

// 'Ъ'
0x9A,0x01,0x0A,0x0D,0x01,0x0B,
0xF0,0x3C,0x03,0x00,0xC0,0x30,0x0F,0xE3,0xFC,0xC3,0x30,0xCC,0x33,0x0C,0xFF,0x3F,0x80,

// 'Ы'
0x9B,0x01,0x0C,0x0D,0x01,0x0D,
0xC0,0x3C,0x03,0xC0,0x3C,0x03,0xC0,0x3F,0xE3,0xFF,0x3C,0x33,0xC3,0x3C,0x33,0xC3,0x3F,0xF3,0xFE,0x30,

// 'Ь'
0x9C,0x01,0x08,0x0D,0x01,0x09,
0xC0,0xC0,0xC0,0xC0,0xC0,0xFE,0xFF,0xC3,0xC3,0xC3,0xC3,0xFF,0xFE,

// 'Э'
0x9D,0x01,0x0A,0x0D,0x01,0x0B,
0x1C,0x1F,0xCE,0x38,0x06,0x00,0xC0,0x30,0xFC,0x3F,0x00,0xF0,0x77,0x38,0xFC,0x1C,0x00,

// 'Ю'
0x9E,0x01,0x0C,0x0D,0x01,0x0D,
0xC1,0x8C,0x3C,0xC6,0x6C,0xC3,0xCC,0x3F,0xC3,0xFC,0x3C,0xC3,0xCC,0x3C,0xC3,0xC6,0x6C,0x3C,0xC1,0x80,

// 'Я'
0x9F,0x01,0x0A,0x0D,0x00,0x0B,
0x1F,0xCF,0xF3,0x0D,0x83,0x60,0xCC,0x33,0xFC,0x7F,0x06,0xC3,0x31,0x8C,0xC3,0x60,0xC0,

// 'a'
0xA0,0x04,0x08,0x0A,0x01,0x09,
0x3C,0x7E,0x47,0x03,0x3F,0xFF,0xC3,0xC7,0xFF,0x7B,

// 'б'
0xA1,0x01,0x08,0x0D,0x01,0x09,
0x3,0x3F,0x7E,0xE0,0xC0,0xFC,0xFE,0xE7,0xC3,0xC3,0xE7,0x7E,0x3C,

// 'в'
0xA2,0x04,0x08,0x0A,0x01,0x08,
0xFC,0xFE,0xC6,0xC6,0xFC,0xFC,0xC6,0xC6,0xFE,0xFC,

// 'г'
0xA3,0x04,0x06,0x0A,0x01,0x07,
0xFF,0xFC,0x30,0xC3,0xC,0x30,0xC3,0x0,

// 'д'
0xA4,0x04,0x08,0x0C,0x01,0x09,
0x3E,0x7E,0x66,0x66,0x66,0x66,0x66,0x66,0xFF,0xFF,0xC3,0xC3,


// 'е'
0xA5,0x04,0x08,0x0A,0x01,0x09,
0x3C,0x7E,0xC3,0xC3,0xFF,0xFF,0xC0,0xE0,0x7E,0x3C,

// 'ё'
0xF1,0x02,0x08,0x0C,0x01,0x09,
0x66,0x0,0x3C,0x7E,0xC3,0xC3,0xFF,0xFF,0xC0,0xE0,0x7E,0x3C,

// 'ж'
0xA6,0x04,0x0A,0x0A,0x01,0x0B,
0xCC,0xFB,0x77,0xF8,0xFC,0x1E,0x0F,0xC7,0xFB,0xB7,0xCC,0xE3,0x10,

// 'з'
0xA7,0x04,0x08,0x0A,0x01,0x09,
0x7C,0xFE,0x87,0x6,0x1C,0x1C,0x6,0x87,0xFE,0x7C,

// 'и'
0xA8,0x04,0x08,0x0A,0x01,0x09,
0xC3,0xC7,0xC7,0xCB,0xCB,0xD3,0xD3,0xE3,0xE3,0xC3,

// 'й'
0xA9,0x02,0x08,0x0C,0x01,0x09,
0x18,0x0,0xC3,0xC7,0xC7,0xCB,0xCB,0xD3,0xD3,0xE3,0xE3,0xC3,

// 'к'
0xAA,0x04,0x08,0x0A,0x01,0x08,
0xC6,0xCC,0xD8,0xF0,0xE0,0xF0,0xD8,0xCC,0xC6,0xC3,
//0xC6,0xCC,0xD8,0xF0,0xE0,0xF0,0xD8,0xCC,0xC6,0xC6,

// 'л'
0xAB,0x04,0x08,0x0A,0x01,0x09,
//0x1E,0x36,0x36,0x66,0x66,0x66,0x66,0x66,0x66,0xC6,
0xF,0x1F,0x3B,0x33,0x63,0x63,0x63,0x63,0x63,0xC3,

// 'м'
0xAC,0x04,0x0A,0x0A,0x01,0x0B,
0xC0,0xF8,0x7F,0x3F,0xFF,0xDE,0xF3,0x3C,0x0F,0x03,0xC0,0xF0,0x30,

// 'н'
0xAD,0x04,0x08,0x0A,0x01,0x09,
0xC3,0xC3,0xC3,0xC3,0xFF,0xFF,0xC3,0xC3,0xC3,0xC3,

// 'о'
0xAE,0x04,0x08,0x0A,0x01,0x09,
0x3C,0x7E,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0x7E,0x3C,

// 'п'
0xAF,0x04,0x08,0x0A,0x01,0x09,
0xFF,0xFF,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,

// 'p'
0xE0,0x04,0x09,0x0E,0x01,0x09,
0xDE,0x7F,0xB8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0xFF,0x6F,0x30,0x18,0x0C,0x06,0x00,

// 'c'
0xE1,0x04,0x08,0x0A,0x01,0x09,
0x1E,0x7F,0x61,0xC0,0xC0,0xC0,0xC0,0x61,0x7F,0x1E,

// 'т'
0xE2,0x04,0x08,0x0A,0x01,0x09,
0xFF,0xFF,0x99,0x18,0x18,0x18,0x18,0x18,0x18,0x3C,

// 'y'
0xE3,0x04,0x0C,0x0E,0x00,0x0B,
0x60,0x66,0x06,0x30,0xC3,0x0C,0x19,0x81,0x98,0x0F,0x00,0xF0,0x06,0x00,0x60,0x06,0x00,0xC0,0x3C,0x03,0x80,

// 'ф'
0xE4,0x04,0x0A,0x0A,0x01,0x0B,
0x0C,0x0F,0xC7,0xFB,0x33,0xCC,0xF3,0x37,0xF8,0xFC,0x0C,0x03,0x00,

// 'x'
0xE5,0x04,0x0A,0x0A,0x01,0x0B,
0xE1,0xD8,0x63,0x30,0xCC,0x1E,0x07,0x83,0x30,0xCC,0x61,0xB8,0x70,

// ц
0xE6,0x04,0x08,0x0C,0x01,0x09,
0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0xFF,0xFF,0x03,0x03,

// 'ч'
0xE7,0x04,0x08,0x0A,0x01,0x09,
0xC3,0xC3,0xC3,0xC3,0xFF,0x7F,0x03,0x03,0x03,0x03,
//0xC3,0xC3,0xC3,0xC3,0xFF,0xFF,0x03,0x03,0x03,0x03,

// 'ш'
0xE8,0x04,0x0A,0x0A,0x01,0x0B,
0xCC,0xF3,0x3C,0xCF,0x33,0xCC,0xF3,0x3C,0xCF,0x33,0xFF,0xFF,0xF0,

// 'щ'
0xE9,0x04,0x0A,0x0C,0x01,0x0B,
0xCC,0xF3,0x3C,0xCF,0x33,0xCC,0xF3,0x3C,0xCF,0x33,0xFF,0xFF,0xF0,0x0C,0x03,

// 'ь'
0xEA,0x04,0x08,0x0A,0x01,0x09,
0xE0,0xE0,0x60,0x60,0x7E,0x7F,0x63,0x63,0x7F,0x7E,

// 'ы'
0xEB,0x04,0x0A,0x0A,0x01,0x0C,
0xC0,0xF0,0x3C,0x0F,0x03,0xFC,0xFF,0xBC,0x6F,0x1B,0xFE,0xFF,0x30,

// 'ь'
0xEC,0x04,0x08,0x0A,0x00,0x08,
0xC0,0xC0,0xC0,0xC0,0xFC,0xFE,0xC6,0xC6,0xFE,0xFC,

// 'э'
0xED,0x04,0x08,0x0A,0x01,0x09,
0x3C,0x7E,0xC7,0x3,0x1F,0x1F,0x3,0xC7,0x7E,0x3C,

// 'ю'
0xEE,0x04,0x0A,0x0A,0x01,0x0B,
0xC7,0x33,0xED,0x8F,0x63,0xF8,0xFE,0x3D,0x8F,0x63,0xCF,0xB1,0xC0,

// 'я'
0xEF,0x04,0x08,0x0A,0x01,0x09,
0x3F,0x7F,0xC3,0xC3,0x7F,0x3F,0x1B,0x33,0x63,0xC3,

// '"'
0x22,0x01,0x06,0x05,0x01,0x08,
0xCF,0x3C,0xF3,0xCC,
// '#'
0x23,0x00,0x0C,0x0E,0x01,0x0F,
0x04,0x40,0x44,0x0C,0xC0,0xC8,0x7F,0xF7,0xFF,0x09,0x81,0x90,0xFF,0xEF,0xFE,0x13,0x03,0x30,0x32,0x02,0x20,
// '$'
0x24,0x00,0x0A,0x11,0x01,0x0B,
0x08,0x02,0x03,0xE1,0xFC,0xE9,0x32,0x0F,0x81,0xF8,0x0F,0x02,0x60,0x9A,0x2E,0xFF,0x1F,0x80,0x80,0x20,0x08,0x00,
// '%'
0x25,0x01,0x0F,0x0D,0x01,0x11,
0x78,0x10,0x90,0x43,0x31,0x86,0x62,0x0C,0xC8,0x19,0x10,0x1E,0x4F,0x01,0x12,0x02,0x66,0x08,0xCC,0x31,0x98,0x41,0x21,0x03,0xC0,
// '&'
0x26,0x01,0x0C,0x0D,0x01,0x0D,
0x0F,0x01,0xF8,0x30,0x83,0x00,0x38,0x03,0xC0,0x7E,0x6C,0x76,0xC3,0xCC,0x18,0xE1,0xC7,0xFE,0x3E,0x70,
// '''
0x27,0x01,0x02,0x05,0x01,0x04,
0xFF,0xC0,
// '('
0x28,0x00,0x04,0x10,0x02,0x07,
0x32,0x66,0x4C,0xCC,0xCC,0xC4,0x66,0x23,
// ')'
0x29,0x00,0x04,0x10,0x01,0x07,
0xC4,0x66,0x23,0x33,0x33,0x32,0x66,0x4C,
// '*'
0x2A,0x01,0x07,0x08,0x01,0x09,
0x11,0x25,0x51,0xC3,0x8A,0xA4,0x88,
// '+'
0x2B,0x02,0x0C,0x0C,0x02,0x0F,
0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x0F,0xFF,0xFF,0xF0,0x60,0x06,0x00,0x60,0x06,0x00,0x60,
// ','
0x2C,0x0C,0x03,0x04,0x01,0x06,
0x6D,0x40,
// '-'
0x2D,0x08,0x05,0x02,0x01,0x07,
0xFF,0xC0,
// '.'
0x2E,0x0C,0x02,0x02,0x01,0x04,
0xF0,
// '/'
0x2F,0x01,0x06,0x0F,0x00,0x06,
0x0C,0x31,0x86,0x18,0xE3,0x0C,0x31,0xC6,0x18,0x63,0x0C,0x00,
// '0'
0x30,0x01,0x09,0x0D,0x01,0x0A,
0x3E,0x3F,0x98,0xD8,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xD8,0xCF,0xE3,0xE0,
// '1'
0x31,0x01,0x08,0x0D,0x1,0x09,
0x38,0xF8,0xD8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0xFF,
// '2'
0x32,0x01,0x09,0x0D,0x01,0x0A,
0x7C,0x7F,0x21,0xC0,0x60,0x30,0x30,0x18,0x18,0x18,0x18,0x18,0x1F,0xEF,0xF0,
// '3'
0x33,0x01,0x09,0x0D,0x01,0x0A,
0x7E,0x7F,0xA0,0xE0,0x30,0x39,0xF0,0xFC,0x07,0x01,0x80,0xE0,0xFF,0xE7,0xE0,
// '4'
0x34,0x01,0x0A,0x0D,0x01,0x0B,
0x07,0x01,0xC0,0xB0,0x6C,0x13,0x08,0xC6,0x31,0x0C,0xFF,0xFF,0xF0,0x30,0x0C,0x03,0x00,
// '5'
0x35,0x01,0x08,0x0D,0x01,0x09,
0x7E,0x7E,0x60,0x60,0x7C,0x7E,0x47,0x03,0x03,0x03,0x87,0xFE,0x7C,
// '6'
0x36,0x01,0x09,0x0D,0x01,0x0A,
0x1E,0x1F,0x9C,0x5C,0x0C,0x06,0xF3,0xFD,0xC7,0xC1,0xE0,0xD8,0xEF,0xE1,0xE0,
// '7'
0x37,0x01,0x08,0x0D,0x01,0x09,
0xFF,0xFF,0x06,0x06,0x06,0x0E,0x0C,0x0C,0x1C,0x18,0x18,0x38,0x30,
// '8'
0x38,0x01,0x09,0x0D,0x01,0x0A,
0x3E,0x3F,0xB8,0xF8,0x3E,0x39,0xF1,0xFD,0xC7,0xC1,0xE0,0xF8,0xEF,0xE3,0xE0,
// '9'
0x39,0x01,0x09,0x0D,0x01,0x0A,
0x3C,0x3F,0xB8,0xD8,0x3C,0x1F,0x1D,0xFE,0x7B,0x01,0x81,0xD1,0xCF,0xC3,0xC0,
// ':'
0x3A,0x04,0x02,0x09,0x01,0x04,
0xF0,0x03,0xC0,
// ';'
0x3B,0x05,0x03,0x0B,0x01,0x05,
0x6C,0x00,0x03,0x6A,0x00,
// '<'
0x3C,0x04,0x0B,0x0A,0x02,0x0F,
0x00,0x20,0x3C,0x1F,0x1F,0x0F,0x81,0xF0,0x0F,0x80,0x3E,0x01,0xE0,0x04,
// '='
0x3D,0x05,0x0B,0x06,0x02,0x0F,
0xFF,0xFF,0xFC,0x00,0x00,0x0F,0xFF,0xFF,0xC0,
// '>'
0x3E,0x04,0x0B,0x0A,0x02,0x0F,
0x80,0x1E,0x01,0xF0,0x07,0xC0,0x3E,0x07,0xC3,0xE3,0xE0,0xF0,0x10,0x00,
// '?'
0x3F,0x01,0x07,0x0D,0x01,0x0A,
0x79,0xFA,0x38,0x30,0x61,0x86,0x18,0x30,0x60,0x01,0x83,0x00,
// '@'
0x40,0x01,0x10,0x10,0x01,0x12,
0x07,0xE0,0x1F,0xF8,0x3C,0x1C,0x70,0x06,0x60,0x07,0xE3,0x63,0xC7,0xE3,0xC6,0x63,0xC6,0x66,0xC7,0xFC,0xE3,0x70,0x60,0x00,0x70,0x00,0x3C,0x30,0x1F,0xF0,0x07,0xC0,
// 'A'
0x41,0x01,0x0C,0x0D,0x00,0x0C,
0x06,0x00,0x60,0x0F,0x00,0xF0,0x19,0x81,0x98,0x19,0x83,0x0C,0x3F,0xC7,0xFE,0x60,0x66,0x06,0xC0,0x30,
// 'B'
0x42,0x01,0x09,0x0D,0x02,0x0C,
0xFC,0x7F,0xB0,0xD8,0x6C,0x37,0xF3,0xF9,0x86,0xC1,0xE0,0xF0,0xFF,0xEF,0xE0,
// 'C'
0x43,0x01,0x0B,0x0D,0x01,0x0D,
0x0F,0xC7,0xFD,0xC0,0xB0,0x0C,0x01,0x80,0x30,0x06,0x00,0xC0,0x0C,0x01,0xC0,0x9F,0xF0,0xFC,
// 'D'
0x44,0x01,0x0B,0x0D,0x02,0x0E,
0xFE,0x1F,0xF3,0x07,0x60,0x6C,0x07,0x80,0xF0,0x1E,0x03,0xC0,0x78,0x1B,0x07,0x7F,0xCF,0xE0,
// 'E'
0x45,0x01,0x08,0x0D,0x02,0x0B,
0xFF,0xFF,0xC0,0xC0,0xC0,0xFF,0xFF,0xC0,0xC0,0xC0,0xC0,0xFF,0xFF,
// 'F'
0x46,0x01,0x08,0x0D,0x02,0x0A,
0xFF,0xFF,0xC0,0xC0,0xC0,0xFE,0xFE,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,
// 'G'
0x47,0x01,0x0B,0x0D,0x01,0x0E,
0x0F,0xC7,0xFD,0xC0,0xB0,0x0C,0x01,0x87,0xF0,0xFE,0x03,0xC0,0x6C,0x0D,0xC1,0x9F,0xE0,0xF8,
// 'H'
0x48,0x01,0x0A,0x0D,0x02,0x0E,
0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xFF,0xFF,0xFF,0x03,0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xC0,
// 'I'
0x49,0x01,0x02,0x0D,0x02,0x06,
0xFF,0xFF,0xFF,0xC0,
// 'J'
0x4A,0x01,0x05,0x11,0xFF,0x06,
0x18,0xC6,0x31,0x8C,0x63,0x18,0xC6,0x31,0x8C,0xFE,0xE0,
// 'K'
0x4B,0x01,0x0B,0x0D,0x02,0x0C,
0xC1,0x98,0x63,0x18,0x66,0x0D,0x81,0xE0,0x3C,0x06,0xC0,0xCC,0x18,0xC3,0x0C,0x60,0xCC,0x0C,
// 'L'
0x4C,0x01,0x08,0x0D,0x02,0x0A,
0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFF,0xFF,
// 'M'
0x4D,0x01,0x0C,0x0D,0x02,0x10,
0xE0,0x7F,0x0F,0xF0,0xFD,0x8B,0xD9,0xBD,0x9B,0xCF,0x3C,0xF3,0xC6,0x3C,0x63,0xC0,0x3C,0x03,0xC0,0x30,
// 'N'
0x4E,0x01,0x0A,0x0D,0x02,0x0E,
0xE0,0xF8,0x3F,0x0F,0xC3,0xD8,0xF6,0x3C,0xCF,0x1B,0xC6,0xF0,0xFC,0x3F,0x07,0xC1,0xC0,
// 'O'
0x4F,0x01,0x0C,0x0D,0x01,0x0E,
0x1F,0x83,0xFC,0x70,0xE6,0x06,0xC0,0x3C,0x03,0xC0,0x3C,0x03,0xC0,0x36,0x06,0x70,0xE3,0xFC,0x1F,0x80,
// 'P'
0x50,0x01,0x08,0x0D,0x02,0x0B,
0xFC,0xFE,0xC7,0xC3,0xC3,0xC7,0xFE,0xFC,0xC0,0xC0,0xC0,0xC0,0xC0,
// 'Q'
0x51,0x01,0x0C,0x0F,0x01,0x0E,
0x1F,0x83,0xFC,0x70,0xE6,0x06,0xC0,0x3C,0x03,0xC0,0x3C,0x03,0xC0,0x36,0x06,0x70,0xE3,0xFC,0x1F,0x80,0x18,0x00,0xC0,
// 'R'
0x52,0x01,0x0A,0x0D,0x02,0x0D,
0xFC,0x3F,0x8C,0x73,0x0C,0xC3,0x31,0xCF,0xE3,0xF0,0xC6,0x30,0xCC,0x33,0x06,0xC1,0xC0,
// 'S'
0x53,0x01,0x0A,0x0D,0x01,0x0B,
0x3E,0x1F,0xCE,0x13,0x00,0xC0,0x1F,0x03,0xF0,0x0E,0x01,0x80,0x68,0x3B,0xFC,0x7E,0x00,
// 'T'
0x54,0x01,0x0C,0x0D,0x00,0x0C,
0xFF,0xFF,0xFF,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,
// 'U'
0x55,0x01,0x0A,0x0D,0x02,0x0E,
0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xF0,0x3C,0x0F,0x03,0xC0,0xF0,0x36,0x19,0xFE,0x1E,0x00,
// 'V'
0x56,0x01,0x0C,0x0D,0x00,0x0C,
0xC0,0x36,0x06,0x60,0x66,0x06,0x30,0xC3,0x0C,0x19,0x81,0x98,0x19,0x80,0xF0,0x0F,0x00,0x60,0x06,0x00,
// 'W'
0x57,0x01,0x11,0x0D,0x01,0x13,
0xC1,0xC1,0xE0,0xE0,0xD8,0xF8,0xCC,0x6C,0x66,0x36,0x33,0x1B,0x18,0xD8,0xD8,0x6C,0x6C,0x36,0x36,0x1F,0x1F,0x07,0x07,0x03,0x83,0x81,0xC1,0xC0,
// 'X'
0x58,0x01,0x0B,0x0D,0x01,0x0D,
0x70,0xE6,0x18,0xE6,0x0D,0xC0,0xF0,0x1C,0x03,0x80,0x78,0x1B,0x07,0x30,0xC7,0x30,0x6E,0x0E,
// 'Y'
0x59,0x01,0x0C,0x0D,0x00,0x0C,
0xE0,0x76,0x06,0x30,0xC1,0x98,0x19,0x80,0xF0,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,0x60,0x06,0x00,
// 'Z'
0x5A,0x01,0x0B,0x0D,0x01,0x0D,
0xFF,0xFF,0xFC,0x07,0x01,0xC0,0x30,0x0E,0x03,0x80,0xE0,0x18,0x06,0x01,0xC0,0x7F,0xFF,0xFE,
// '['
0x5B,0x00,0x04,0x10,0x01,0x07,
0xFF,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFF,
// '\'
0x5C,0x01,0x06,0x0F,0x00,0x06,
0xC3,0x06,0x18,0x61,0xC3,0x0C,0x30,0xE1,0x86,0x18,0x30,0xC0,
// ']'
0x5D,0x00,0x04,0x10,0x02,0x07,
0xFF,0x33,0x33,0x33,0x33,0x33,0x33,0xFF,
// '^'
0x5E,0x01,0x0B,0x05,0x02,0x0F,
0x0E,0x03,0xE0,0xC6,0x30,0x6C,0x06,
// '_'
0x5F,0x10,0x09,0x02,0x00,0x09,
0xFF,0xFF,0xC0,
// '`'
0x60,0x00,0x04,0x03,0x02,0x09,
0xC6,0x30,
// 'a'
0x61,0x04,0x08,0x0A,0x01,0x0A,
0x3C,0x7E,0x47,0x03,0x3F,0xFF,0xC3,0xC7,0xFF,0x7B,
// 'b'
0x62,0x00,0x09,0x0E,0x02,0x0B,
0xC0,0x60,0x30,0x18,0x0D,0xE7,0xFB,0x8F,0x83,0xC1,0xE0,0xF0,0x7C,0x7F,0xF6,0xF0,
// 'c'
0x63,0x04,0x08,0x0A,0x01,0x09,
0x1E,0x7F,0x61,0xC0,0xC0,0xC0,0xC0,0x61,0x7F,0x1E,
// 'd'
0x64,0x00,0x09,0x0E,0x01,0x0B,
0x01,0x80,0xC0,0x60,0x33,0xDB,0xFF,0x8F,0x83,0xC1,0xE0,0xF0,0x7C,0x77,0xF9,0xEC,
// 'e'
0x65,0x04,0x0A,0x0A,0x01,0x0B,
0x1F,0x1F,0xE6,0x1F,0x03,0xFF,0xFF,0xFC,0x01,0x81,0x7F,0xC7,0xE0,
// 'f'
0x66,0x00,0x07,0x0E,0x00,0x06,
0x1E,0x7C,0xC1,0x8F,0xFF,0xCC,0x18,0x30,0x60,0xC1,0x83,0x06,0x00,
// 'g'
0x67,0x04,0x09,0x0E,0x01,0x0B,
0x3D,0xBF,0xF8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x9E,0xC0,0x68,0x67,0xF1,0xF0,
// 'h'
0x68,0x00,0x08,0x0E,0x02,0x0B,
0xC0,0xC0,0xC0,0xC0,0xDE,0xFE,0xE7,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,
// 'i'
0x69,0x00,0x02,0x0E,0x02,0x05,
0xF0,0xFF,0xFF,0xF0,
// 'j'
0x6A,0x00,0x04,0x12,0x00,0x05,
0x33,0x00,0x33,0x33,0x33,0x33,0x33,0x33,0xEC,
// 'k'
0x6B,0x00,0x09,0x0E,0x02,0x0A,
0xC0,0x60,0x30,0x18,0x0C,0x36,0x33,0x31,0xB0,0xF0,0x78,0x36,0x19,0x8C,0x66,0x18,
// 'l'
0x6C,0x00,0x02,0x0E,0x02,0x05,
0xFF,0xFF,0xFF,0xF0,
// 'm'
0x6D,0x04,0x0E,0x0A,0x02,0x11,
0xDC,0x7B,0xFB,0xEE,0x79,0xF0,0xC3,0xC3,0x0F,0x0C,0x3C,0x30,0xF0,0xC3,0xC3,0x0F,0x0C,0x30,
// 'n'
0x6E,0x04,0x08,0x0A,0x02,0x0B,
0xDE,0xFE,0xE7,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,
// 'o'
0x6F,0x04,0x0A,0x0A,0x01,0x0B,
0x1E,0x1F,0xE6,0x1B,0x03,0xC0,0xF0,0x3C,0x0D,0x86,0x7F,0x87,0x80,
// 'p'
0x70,0x04,0x09,0x0E,0x02,0x0B,
0xDE,0x7F,0xB8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0xFF,0x6F,0x30,0x18,0x0C,0x06,0x00,
// 'q'
0x71,0x04,0x09,0x0E,0x01,0x0B,
0x3D,0xBF,0xF8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x9E,0xC0,0x60,0x30,0x18,0x0C,
// 'r'
0x72,0x04,0x06,0x0A,0x02,0x08,
0xDF,0xFE,0x30,0xC3,0x0C,0x30,0xC3,0x00,
// 's'
0x73,0x04,0x08,0x0A,0x01,0x08,
0x7C,0xFE,0xC2,0xE0,0x7C,0x1E,0x06,0x86,0xFE,0x78,
// 't'
0x74,0x01,0x06,0x0D,0x01,0x07,
0x61,0x86,0x3F,0xFD,0x86,0x18,0x61,0x86,0x1F,0x3C,
// 'u'
0x75,0x04,0x08,0x0A,0x02,0x0B,
0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0xE7,0x7F,0x7B,
// 'v'
0x76,0x04,0x0C,0x0A,0x00,0x0B,
0x60,0x66,0x06,0x30,0xC3,0x0C,0x19,0x81,0x98,0x19,0x80,0xF0,0x0F,0x00,0x60,
// 'w'
0x77,0x04,0x0F,0x0A,0x01,0x10,
0x63,0x8C,0xC7,0x19,0x8E,0x31,0xB6,0xC3,0x6D,0x86,0xDB,0x0F,0x1E,0x0E,0x38,0x1C,0x70,0x38,0xE0,
// 'x'
0x78,0x04,0x0A,0x0A,0x01,0x0B,
0xE1,0xD8,0x63,0x30,0xCC,0x1E,0x07,0x83,0x30,0xCC,0x61,0xB8,0x70,
// 'y'
0x79,0x04,0x0C,0x0E,0x00,0x0B,
0x60,0x66,0x06,0x30,0xC3,0x0C,0x19,0x81,0x98,0x0F,0x00,0xF0,0x06,0x00,0x60,0x06,0x00,0xC0,0x3C,0x03,0x80,
// 'z'
0x7A,0x04,0x08,0x0A,0x01,0x09,
0xFF,0xFF,0x06,0x0C,0x1C,0x38,0x30,0x70,0xFF,0xFF,
// '{'
0x7B,0x00,0x08,0x11,0x02,0x0B,
0x0F,0x1F,0x18,0x18,0x18,0x18,0x38,0xF0,0xF0,0x38,0x18,0x18,0x18,0x18,0x18,0x1F,0x0F,
// '|'
0x7C,0x00,0x02,0x12,0x02,0x06,
0xFF,0xFF,0xFF,0xFF,0xF0,
// '}'
0x7D,0x00,0x08,0x11,0x02,0x0B,
0xF0,0xF8,0x18,0x18,0x18,0x18,0x1C,0x0F,0x0F,0x1C,0x18,0x18,0x18,0x18,0x18,0xF8,0xF0,
// '~'
0x7E,0x05,0x0B,0x05,0x02,0x0F,
0x00,0x0F,0x87,0xFF,0xC3,0xE0,0x00,

// Terminator
0xFF
};

функция перекодировки символов и вывод на экран

//=====================================================================
// перекодировка русских символов и вывод на экран
void RusPrintStr(UTFT_DLB tft,char *st, int x, int y, int deg)
{
char szTextASCII[60];  
     ConvertUniToAscii(st,szTextASCII,30);     
     tft.print(szTextASCII, x, y,deg);
}

//=========================================================================
// возвращает длину получившейся строки в приемние или 0 при ошибке
// iDlPri - максимальное длина буфера
int  ConvertUniToAscii(char szIst[],char szPri[], int iDlPri)
{
int iDl = strlen(szIst);  
int iPr=0,iI;
uint8_t ui8C,ui8C2;

 
    for(iI=0;iI<iDl;iI++)
    { ui8C= szIst[iI]; 
      if(ui8C!=208&&ui8C!=209) {szPri[iPr]=ui8C; iPr++;}
      else
      {  iI++;
         ui8C2=szIst[iI];  
         if(ui8C==208)
         {  
            if(ui8C2>=144&&ui8C2<=191) {ui8C2=ui8C2-16; szPri[iPr]=ui8C2; iPr++;}
            else 
            { if(ui8C2==129) {ui8C2=240; szPri[iPr]=ui8C2; iPr++;}
            }
         }
         if(ui8C==209)
         {  if(ui8C2>=128&&ui8C2<=143||ui8C2==145) {ui8C2=ui8C2+96; szPri[iPr]=ui8C2; iPr++;}
         }
         
      }
      if(iPr>=iDlPri) {szPri[iDlPri-1]=0; return 0;}
   }  
   szPri[iPr]=0;
   return iPr;
}  
  

Пример использования

/*
Управление экраном 3.2
Вывод русских имволов
Регулировка яркости (ШИМ)



VGA_BLACK – черный, 
VGA_SILVER – серебряный
VGA_GRAY – серый
VGA_WHITE – белый
VGA_MAROON – красно-коричневый
VGA_RED – красный
VGA_PURPLE – пурпурный
VGA_FUCHSIA – фуксия
VGA_GREEN – зеленый 
VGA_LIME – лайм
VGA_NAVY – темно-синий
VGA_BLUE – синий
VGA_TEAL – сине-зеленый
VGA_AQUA – морская волна
*/

#include <UTFT.h>
#include <UTFT_DLB.h>

UTFT_DLB   myGLCD(CTE32_R2,38,39,40,41);  // инициализация дисплея

#define PIN_BLK  46     // выход включения подсветки  (мах -4 мА) я использую ШИМ для регулировки яркости

//объявление шрифта
extern uint8_t FontRusProp18[];


void setup()
{
// выключение подсветки экрана
  pinMode(PIN_BLK, OUTPUT);    
  digitalWrite(PIN_BLK, LOW); 
  analogWrite(PIN_BLK,150);  // о 5 до 255  

  myGLCD.InitLCD(LANDSCAPE);
  myGLCD.clrScr();
  myGLCD.setBackColor(VGA_WHITE);
  myGLCD.setColor(VGA_BLACK); 

}

void loop()
{
char szTextRus1[60]="АБВГДЕЁЖЗИЙКЛМНОПРСТИУФХ.";
char szTextRus2[60]="ЦЧЬЪШЩЫЭЮЯ  1234567890";
char szTextRus3[60]="абвгдеёжзийклмнопрстуфхцчшщъы";
char szTextRus4[60]="ьэюя  +-/=*_:";
char szTextASCII[60];
unsigned int i,j;

    myGLCD.clrScr();    
    myGLCD.fillScr(VGA_WHITE);   
    myGLCD.setColor(VGA_BLACK);    myGLCD.setBackColor(VGA_WHITE);      
    myGLCD.setFont(FontRusProp18);
     
     
// вариант 1
     j=ConvertUniToAscii(szTextRus1,szTextASCII,30);     
     myGLCD.print(szTextASCII, 4, 6, 0);  
// вариант 2
     RusPrintStr(myGLCD,szTextRus2,0,24,0);


     RusPrintStr(myGLCD,szTextRus3,0,42,0);


     j=ConvertUniToAscii(szTextRus4,szTextASCII,30);     
     myGLCD.print(szTextASCII, 0, 60, 0); 


     j=ConvertUniToAscii("ТЕМПЕРАТУРА +24.7гр  ",szTextASCII,30);     
     myGLCD.print(szTextASCII, 0, 80, 0);

     j=ConvertUniToAscii("Влажность-85% ",szTextASCII,30);     
     myGLCD.print(szTextASCII, 0, 100, 0);

     j=ConvertUniToAscii("Время 12:30 Дата 05.07.2017г.",szTextASCII,30);     
     myGLCD.print(szTextASCII, 50, 125, 0);

     j=ConvertUniToAscii("ВРЕМЯ 19:45  ДАТА 30.06.2087г.",szTextASCII,30);     
     myGLCD.print(szTextASCII, 0, 185, 0);


//     j=ConvertUniToAscii("ВРЕМЯ кушать ягоду!",szTextASCII,30);     
//     myGLCD.print(szTextASCII, 0, 215, 0);

     RusPrintStr(myGLCD,"ВРЕМЯ кушать ягоду!",0,215,0);



    delay(1000000);



  
}


//=====================================================================
// перекодировка кусских символов и вывод на экран
void RusPrintStr(UTFT_DLB tft,char *st, int x, int y, int deg)
{
char szTextASCII[60];  
     ConvertUniToAscii(st,szTextASCII,30);     
     tft.print(szTextASCII, x, y,deg);
}

//=========================================================================
// возвращает длину получившейся строки в приемние или 0 при ошибке
// iDlPri - максимальное длина буфера
int  ConvertUniToAscii(char szIst[],char szPri[], int iDlPri)
{
int iDl = strlen(szIst);  
int iPr=0,iI;
uint8_t ui8C,ui8C2;

 
    for(iI=0;iI<iDl;iI++)
    { ui8C= szIst[iI]; 
      if(ui8C!=208&&ui8C!=209) {szPri[iPr]=ui8C; iPr++;}
      else
      {  iI++;
         ui8C2=szIst[iI];  
         if(ui8C==208)
         {  
            if(ui8C2>=144&&ui8C2<=191) {ui8C2=ui8C2-16; szPri[iPr]=ui8C2; iPr++;}
            else 
            { if(ui8C2==129) {ui8C2=240; szPri[iPr]=ui8C2; iPr++;}
            }
         }
         if(ui8C==209)
         {  if(ui8C2>=128&&ui8C2<=143||ui8C2==145) {ui8C2=ui8C2+96; szPri[iPr]=ui8C2; iPr++;}
         }
         
      }
      if(iPr>=iDlPri) {szPri[iDlPri-1]=0; return 0;}
   }  
   szPri[iPr]=0;
   return iPr;
}  
  

А теперь интересное для тех, кто хочет ЗНАТЬ!

Проблемы с кодировками символов

Проблема с кодированием русских букв в компьютере. А точнее наличие разных кодировок (определенному символу в разных кодировках соответствует разное число и что еще хуже – разное количество байт в этом числе). Для тех кто хорошо ориентируется в ASCII и UNICODE просто скажу, что я для передачи на печать приводил русские символы к кодировке  cp866 (ее же использовал для описания шрифтов). И им данная часть не интересна. А вот остальным советую почитать – если и не разберетесь, то хоть будете иметь представление о данной теме.

Начнем с интересного факта, что если вы объявите в программе символьные строки:

char szText1[]="123";

char szText2[]="FRG";

char szText3[]="БУД";

а затем функцией strlen(); узнаете их размер, Вы будете удивлены! Первые две имеют размер равный 3 байта. А третья – 6 байт! Среда программирования ARDUINO IDE для русских символов использует кодировку UNICODE, в которой символ описывается ДВУМЯ байтами. А для цифр и английских букв использует по 1 байту. И потом  вся эта мешанина записывается в код Arduino и передается в экран для отображения.

Пример:

Символ  ‘F’ храниться в текстовой строке как байт со значением 70 (0x46)

Символ ‘У’ храниться в текстовой строке как ДВА байта со значениями  208 и 163  (0xD0 и 0xA3)

И это первая проблема которую надо решить при выводе русских букв на экран.  Решают ее довольно просто – пишут функцию которая заменяет два байта с кодом  русского символа на  один байт с кодом этого символа. На какой код менять? Я просто перевожу в код ASCII (cp866). В нем все символы кодируются 1 байтом. В рамках использования Arduino  можно использовать свою таблицу соответствия. Вместо русских букв которые аналогичны по изображению английским – подставить код таких английских. Для оставшихся букв присвоить кода которые свободные. Соответственно потом в файле шрифта описать начертание символа с этим кодом. Такой подход оправдан. Он позволяет уменьшить  затраты памяти на хранение шрифта. (https://грибовы.рф/?p=2240)

С приведением к виду – один символ – один байт разобрались. Двигаемся дальше.

Файл описания шрифта.

В таком файле хранится описание изображения символов. Каждому коду символа соответствует своя картинка. Именно эти данные библиотека вывода на экран использует при прорисовке символа на экране. В файле символы описываются по правилам той библиотеке которую вы используете (в нашем случае UTFT). Основной принцип (применительно для ардуино)– один бит – один пиксел на экране. Один байт – 8 пиксел. Символ размером 16х16 это  256 пиксел=256 бит= 32 байта. Если мы знаем какой пиксел какому биту в этих 32 байтах соответствует – то мы можем вносить изменения в изображения символа. При этом еще надо знать где эти 32 байта дня нашего символа расположены в массиве шрифта.

Хорошо расписано как шрифт храниться в библиотеке UTFT здесь:

http://devicter.blogspot.ru/2013/03/rusUTFT-SmallFont.html

Оба этих этапа реализованы и успешно работают. Весь комплект описан здесь:

http://adatum.ru/podklyuchenie-displeya-240x320-2-2-tft-spi-ili9340-k-ar...

Как я уже вначале писал меня не устроил набор шрифтов. Поиск в интернете привел к сайту

http://www.rinkydinkelectronics.com/r_fonts.php

куча разных шрифтов для UTFT – дописывай русские буквы и будет тебе счастье! Но анализ показал – все шрифты по ширине кратны 8 пикселям. Ширина 8-16-24-32 пикселей. Нет узких шрифтов. Есть 8х12 но он уже русифицирован. А типа  6х10 или 12х16 нет. Попытаться самому с нуля написать файл шрифта не имея образец – сомнительное удовольствие. А мне хотелось иметь шрифт узкий – чтоб больше символов влезло на экран. Да и закралось подозрение что  UTFT может и не поддерживать шрифты с шириной шрифта не кратной 8.

И я отложил решение  этой проблемы до лучших времен.

И вот мне попалась на глаза библиотека UTFT_DLB. Она выводит ПРОПОРЦИОНАЛЬНЫЕ шрифты. В комплекте два шрифта. Используется как надстройка над UTFT. Попробовал – полученный результат понравился. Решил – если разберусь как устроен файл шрифта – русифицирую. Оказалось что формат описания шрифта принципиально другой чем в самой UTFT (но родные шрифты тоже работают). Но разобраться не сложно – описание что и как в самом файле шрифта есть. Когда стал экспериментировать – понравилось еще больше. Формат описания шрифта очень гибкий и довольно удобный для корректировки. Я взял за основу имеющийся там шрифт «DejaVuSans18.c»  и добавил изображения русских букв. Я старался сделать их  покомпактней в ширину.   

Преимущества и недостатки данного варианта русификации

Плюсы:

- т.к. описание каждого символа начинается с кода символа – легко найти для исправления

- описание символов в произвольном  порядке и любой символ можно исключить (если не используете)– остальные не пострадают.

- без проблем можно создавать шрифты любых размеров (8*16,4*10, 7*14) причем принципиальной разницы при использовании моноширных и пропорциональных шрифтов нет. Как опишите так и отобразиться.

- отступ с верху и спереди до начала самого изображения символа задается отдельными байтами для каждого числа отдельно – легко регулировать расстояние до предыдущего и последующего символа. Причем для каждого символа в отдельности.

Минусы:

- увеличение размера массива описания шрифта (спорный вопрос) т.к. пустые байты в начале и в конце можно задать начальным смещением сверху и спереди. И это поможет экономить место. И можно описание не нужных символов безболезненно выкинуть – просто закомментировать  строчку (если эти символы не используете в проекте) При этом вернуть можно в любой момент.

Кто хочет поэкспериментировать и помочь с написанием шрифтов – пишите. Подскажу если что не понятно с форматом описания шрифта и подкину заготовку в экселе - чтоб рисовать символ и сразу получать строку байт в шестнадцатеричном коде.

Продолжаю эксперименты.

Шрифт размером 5*8  пока только цифры.

Русский шрифт размером 5*8 есть здесь:
http://arduino.ru/forum/programmirovanie/rusifikatsiya-biblioteki-adafru...

sva_khv - шикарная работа.

Сколько места в итоге занимает массив шрифта? Он весь помещается во флеш?

И чего только люди не придумают, чтобы не разбираться со стандартными fontconvert.c-ами :)

Точный размер не знаю. Примерно 4 килобайта.

Да, именно шрифты из Adafruit-GFX

(использовал в дозиметре http://arduino.ru/forum/proekty/delaem-dozimetr?page=8#comment-281176 )

меня и вдохновили на эту работу (для экрана который с Adafruit-GFX не запустился).

sva_khv, если уж решили провести ликбез, то не нужно хотя бы вводить людей в заблуждение. Иначе они точно "не разберутся", да и "представления" будут иметь весьма сомнительные.

Вы всерез считаете, что часть текста может быть представлена в одной кодировке, а часть в другой?

Кроме некоторых уж очень экзотических случаев текст всегда представлен в одной кодировке. В частности, Arduino IDE использует UTF-8. Другими словами, не только русские, но также и латинские, и даже, страшно сказать, цифры и знаки препинания - все кодируются в Unicode.

Если же под Unicode Вы подразумеваете исключительно UTF-16, то должен Вас разочаровать, ни у одного кириллического символа кодировка в UTF-8 и UTF-16 (вне зависимости от того, UTF-16LE или UTF-16BE) не совпадает.

И, кстати, в Unicode символ далеко не всегда описывается ДВУМЯ байтами: на самом деле от одного до шести. Хотя конкретно кириллица - в UTF-8 и UTF-16, действительно, - двумя (но в UTF-32 - четырьмя).

Все эти тонкости, конечно, излагать не было необходимости, но следовало бы указать, что в Arduino IDE используется UTF-8, в которой разные символы кодируются различным количеством байтов.

[quote=andriano]

ыva_khv, если уж решили провести ликбез, то не нужно хотя бы вводить людей в заблуждение. Иначе они точно "не разберутся", да и "представления" будут иметь весьма сомнительные.

Спасибо за поправики. Теорию я так глубоко не копал. Век живи - век учись.

Плохо что использовали цитирование - нельзя исправить мое сообщение.  

Или есть способы? - может модераторы от своего имени вставят ссылку на Ваше уточнение. Замечание  действительно важное.

Мелкий шрифт   FontRusProp10.c

Высота  (полная) 10, основные знаки - высота 8,

Ширина от 4 до 8

// Высота знка 10 пиксел, высота знакоместа полная- 11 пиксел 
// печатаем в строках 0, 11, 22, 33
// ширина символа от 4 до 8 символов

// This comes with no warranty, implied or otherwise

// This data structure was designed to support Proportional fonts
// on Arduinos. It can however handle any ttf font that has been converted
// using the conversion program. These could be fixed width or proportional 
// fonts. Individual characters do not have to be multiples of 8 bits wide. 
// Any width is fine and does not need to be fixed.

// The data bits are packed to minimize data requirements, but the tradeoff
// is that a header is required per character.

// FontRusProp10.c
// Point Size   : 10
// Memory usage : 
// # characters : 

// Header Format (to make Arduino UTFT Compatible):
// ------------------------------------------------
// Character Width (Used as a marker to indicate use this format. i.e.: = 0x00)
// Character Height
// First Character (Reserved. 0x00)
// Number Of Characters (Reserved. 0x00)

#include <avr/pgmspace.h>

const uint8_t FontRusProp10[] PROGMEM = 
{
0x00, 0x0A, 0x00, 0x00,

// Individual Character Format:
// ----------------------------
// Character Code             код символа
// Adjusted Y Offset          смещение по Y  - сколько срок с верху пустых
// Width                      ширина символа в пикселях (не знакоместа а имено картинки символа)
// Height                     высота символа в пикселях
// xOffset                    начальное смещение по X - сколько пикселей отступаем с лева по вертикали
// xDelta (the distance to move the cursor. Effective width of the character.)  Эффективная ширина символа - ширина самого символа и кол-во пикселей после символа
// Data[n]  // описание символа (целое кол-во байт = Width*Height/8 в хвосте забиваеи нулевыми битами до ближайщего целого числа)
// символ занимает по ширине xOffset+xDelta 
// NOTE: You can remove any of these characters if they are not needed in
// your application. The first character number in each Glyph indicates
// the ASCII character code. Therefore, these do not have to be sequential.
// Just remove all the content for a particular character to save space.

// ' '
0x20,0x04,0x00,0x00,0x00,0x02,
// '!'
0x21,0x01,0x01,0x08,0x00,0x02,
0xFD,
// '"'
0x22,0x01,0x04,0x02,0x01,0x04,
0xAA,
// '#'
0x23,0x01,0x06,0x08,0x00,0x06,
0x49,0x2F,0xD2,0x4B,0xF4,0x92,
// '$'
0x24,0x01,0x05,0x08,0x00,0x05,
0x23,0xAA,0xC3,0x55,0xC4,
// '%'
0x25,0x01,0x08,0x07,0x00,0x08,
0x42,0xA4,0x48,0x10,0x24,0x4A,0x84,
// '&'
0x26,0x01,0x05,0x08,0x00,0x05,
0x45,0x28,0x8A,0xCA,0x4D,
// '''
0x27,0x01,0x02,0x03,0x01,0x04,
0xD4,
// '('
0x28,0x01,0x04,0x08,0x01,0x05,
0x24,0x48,0x84,0x42,
// ')'
0x29,0x01,0x04,0x08,0x00,0x05,
0x84,0x42,0x24,0x48,
// '+'
0x2B,0x03,0x05,0x05,0x01,0x06,
0x21,0x3E,0x42,0x0,
// '-'
0x2D,0x05,0x05,0x01,0x01,0x06,
0xF8,
// '='
0x3D,0x04,0x05,0x03,0x01,0x06,
0xF8,0x3E,
// '*'
0x2A,0x04,0x05,0x04,0x01,0x05,
0xAB,0x9D,0x50,
// '.'
0x2E,0x07,0x02,0x02,0x00,0x03,
0xF0,
// ','
0x2C,0x07,0x02,0x03,0x00,0x03,
0xD4,
// '/'
0x2F,0x01,0x04,0x08,0x00,0x04,
0x11,0x22,0x44,0x88,
// ':'
0x3A,0x03,0x02,0x05,0x01,0x03,
0xF3,0xC0,
// ';'
0x3B,0x03,0x02,0x06,0x01,0x03,
0xF3,0x50,
// '?'
0x3F,0x01,0x05,0x08,0x00,0x05,
0x74,0x62,0x22,0x10,0x4,
// '1'
0x31,0x01,0x05,0x08,0x00,0x05,
0x23,0x28,0x42,0x10,0x8E,
// '2'
0x32,0x01,0x05,0x08,0x00,0x06,
0x74,0x42,0x11,0x11,0x3F,
// '3'
0x33,0x01,0x05,0x08,0x00,0x06,
0x74,0x42,0x60,0x86,0x2E,
// '4'
0x34,0x01,0x05,0x08,0x00,0x06,
//0x8C,0x63,0x1F,0x84,0x21,
0x19,0x53,0x1F,0x84,0x21,
// '5'
0x35,0x01,0x05,0x08,0x00,0x06,
0xFC,0x21,0xE0,0x84,0x3E,
// '6'
0x36,0x01,0x05,0x08,0x00,0x06,
0x74,0x21,0xE8,0xC6,0x2E,
// '7'
0x37,0x01,0x05,0x08,0x00,0x06,
0xF8,0x44,0x44,0x21,0x8,
// '8'
0x38,0x01,0x05,0x08,0x00,0x06,
0x74,0x62,0xE8,0xC6,0x2E,
// '9'
0x39,0x01,0x05,0x08,0x00,0x06,
0x74,0x63,0x17,0x86,0x2E,
// '0'
0x30,0x01,0x05,0x08,0x00,0x05,
0x74,0x63,0x18,0xC6,0x2E,
// 'A'
0x41,0x01,0x05,0x08,0x00,0x06,
0x22,0x94,0xA8,0xFE,0x31,
// 'B'
0x42,0x01,0x05,0x08,0x00,0x05,
0xF4,0x63,0xE8,0xC6,0x3E,
// 'С'
0x43,0x01,0x05,0x08,0x00,0x05,
0x74,0x61,0x8,0x42,0x2E,
// 'D'
0x44,0x01,0x05,0x08,0x01,0x05,
0xE4,0xA3,0x18,0xC6,0x5C,
// 'E'
0x45,0x01,0x04,0x08,0x01,0x05,
0xF8,0x8F,0x88,0x8F,
// 'F'
0x46,0x01,0x04,0x08,0x01,0x05,
0xF8,0x8E,0x88,0x88,
// 'G'
0x47,0x01,0x06,0x08,0x00,0x08,
0x7A,0x18,0x20,0x9E,0x18,0xDD,
// 'H'
0x48,0x01,0x05,0x08,0x00,0x05,
0x8C,0x63,0xF8,0xC6,0x31,
// 'I'
0x49,0x01,0x04,0x08,0x01,0x04,
0xE4,0x44,0x44,0x4E,
// 'J'
0x4A,0x01,0x04,0x08,0x01,0x05,
0x72,0x22,0x22,0xA4,
// 'K'
0x4B,0x01,0x05,0x08,0x00,0x05,
0x8C,0xA9,0x8C,0x52,0x51,
// 'L'
0x4C,0x01,0x04,0x08,0x01,0x05,
0x88,0x88,0x88,0x8F,
// 'M'
0x4D,0x01,0x08,0x08,0x00,0x08,
0x82,0xC6,0xAA,0xAA,0x92,0x82,0x82,0x82,
// 'N'
0x4E,0x01,0x05,0x08,0x00,0x05,
0x8E,0x73,0x5A,0xCE,0x71,
// 'O'
0x4F,0x01,0x05,0x08,0x00,0x05,
0x74,0x63,0x18,0xC6,0x2E,
// 'P'
0x50,0x01,0x05,0x08,0x00,0x05,
0xF4,0x63,0x1F,0x42,0x10,
// 'Q'
0x51,0x01,0x05,0x09,0x00,0x05,
0x74,0x63,0x18,0xD6,0x6E,0x8,
// 'R'
0x52,0x01,0x05,0x08,0x00,0x05,
0xF4,0x63,0x1F,0x52,0x51,
// 'S'
0x53,0x01,0x05,0x08,0x00,0x05,
0x74,0x60,0xE0,0x86,0x2E,
// 'Т'
0x54,0x01,0x05,0x08,0x00,0x05,
0xF9,0x8,0x42,0x10,0x84,
// 'U'
0x55,0x01,0x05,0x08,0x00,0x05,
0x8C,0x63,0x18,0xC6,0x2E,
// 'V'
0x56,0x01,0x05,0x08,0x00,0x05,
0x8C,0x62,0xA5,0x28,0x84,
// 'W'
0x57,0x01,0x08,0x08,0x00,0x08,
0x82,0x82,0x92,0x92,0x54,0x6C,0x6C,0x44,
// 'X'
0x58,0x01,0x06,0x08,0x00,0x06,
0x85,0x24,0x8C,0x31,0x24,0xA1,
// 'Y'
0x59,0x01,0x05,0x08,0x00,0x05,
0x8C,0x54,0xA2,0x10,0x84,
// 'Z'
0x5A,0x01,0x04,0x08,0x01,0x05,
0xF1,0x22,0x44,0x8F,
// 'a'
0x61,0x03,0x05,0x06,0x00,0x05,
0x70,0x5F,0x18,0xBC,
// 'b'
0x62,0x01,0x05,0x08,0x00,0x05,
0x84,0x21,0xE8,0xC6,0x3E,
// 'с'
0x63,0x03,0x05,0x06,0x00,0x05,
0x74,0x61,0x8,0xB8,
// 'd'
0x64,0x01,0x05,0x08,0x00,0x05,
0x8,0x42,0xF8,0xC6,0x2F,
// 'е'
0x65,0x03,0x05,0x06,0x00,0x05,
0x74,0x7F,0x8,0xB8,
// 'f'
0x66,0x01,0x02,0x08,0x00,0x03,
0x6B,0xAA,
// 'g'
0x67,0x03,0x05,0x07,0x00,0x05,
0x7C,0x63,0x17,0x87,0xC0,
// 'h'
0x68,0x01,0x04,0x08,0x00,0x05,
0x88,0x8E,0x99,0x99,
// 'i'
0x69,0x01,0x01,0x08,0x00,0x02,
0xBF,
// 'j'
0x6A,0x01,0x02,0x09,0x00,0x02,
0x45,0x55,0x80,
// 'k'
0x6B,0x01,0x04,0x08,0x00,0x04,
0x88,0x9A,0xCC,0xA9,
// 'l'
0x6C,0x01,0x01,0x08,0x00,0x02,
0xFF,
// 'm'
0x6D,0x03,0x07,0x06,0x00,0x07,
0xED,0x26,0x4C,0x99,0x32,0x40,
// 'n'
0x6E,0x03,0x05,0x06,0x00,0x05,
0xB6,0x63,0x18,0xC4,
// 'о'
0x6F,0x03,0x05,0x06,0x00,0x05,
0x74,0x63,0x18,0xB8,
// 'р'
0x70,0x03,0x05,0x08,0x00,0x05,
0xF4,0x63,0x1F,0x42,0x10,
// 'q'
0x71,0x03,0x05,0x08,0x00,0x05,
0x7C,0x63,0x17,0x84,0x21,
// 'r'
0x72,0x03,0x02,0x06,0x00,0x02,
0x6A,0xA0,
// 's'
0x73,0x03,0x04,0x06,0x00,0x04,
0x69,0x42,0x96,
// 't'
0x74,0x01,0x02,0x08,0x00,0x03,
0xAB,0xA9,
// 'u'
0x75,0x03,0x05,0x06,0x00,0x05,
0x8C,0x63,0x19,0xB4,
// 'v'
0x76,0x03,0x05,0x06,0x00,0x05,
0x8C,0x54,0xA2,0x10,
// 'w'
0x77,0x03,0x05,0x06,0x00,0x05,
0x8C,0x6B,0x55,0x28,
// 'x'
0x78,0x03,0x04,0x06,0x00,0x04,
0x99,0x66,0x99,
// 'у'
0x79,0x03,0x04,0x08,0x00,0x04,
0x99,0x99,0x71,0x1E,
// 'z'
0x7A,0x03,0x04,0x06,0x00,0x04,
0xF1,0x24,0x8F,
// 'А'
0x80,0x01,0x05,0x08,0x00,0x06,
0x22,0x94,0xA8,0xFE,0x31,
// 'Б'
0x81,0x01,0x05,0x08,0x00,0x06,
0xFC,0x61,0xE8,0xC6,0x3E,
// 'В'
0x82,0x01,0x05,0x08,0x00,0x05,
0xF4,0x63,0xE8,0xC6,0x3E,
// 'Г'
0x83,0x01,0x05,0x08,0x01,0x05,
0xF4,0xA1,0x8,0x42,0x10,
// 'Д'
0x84,0x01,0x06,0x09,0x00,0x06,
0x79,0x24,0x92,0x49,0x24,0xBF,0x84,
// 'Е'
0x85,0x01,0x04,0x08,0x01,0x05,
0xF8,0x8F,0x88,0x8F,
// 'Ё'
0xF0,0x00,0x04,0x09,0x01,0x05,
0x50,0xF8,0x8F,0x88,0xF0,
// 'Ж'
0x86,0x01,0x08,0x08,0x00,0x08,
0x92,0x54,0x54,0x38,0x38,0x54,0x54,0x92,
// 'З'
0x87,0x01,0x05,0x08,0x00,0x05,
0x74,0x42,0x20,0x86,0x2E,
// 'И'
0x88,0x01,0x05,0x08,0x01,0x06,
0x8C,0xE7,0x5A,0xE7,0x31,
// 'Й'
0x89,0x00,0x05,0x09,0x01,0x06,
0x24,0x67,0x3A,0xD7,0x39,0x88,
// 'К'
0x8A,0x01,0x05,0x08,0x00,0x05,
0x8C,0xA9,0x8C,0x52,0x51,
// 'Л'
0x8B,0x01,0x05,0x08,0x00,0x05,
0x39,0x4A,0x94,0xA5,0x39,
// 'М'
0x8C,0x01,0x08,0x08,0x00,0x08,
0x82,0xC6,0xAA,0xAA,0x92,0x82,0x82,0x82,
// 'Н'
0x8D,0x01,0x05,0x08,0x00,0x05,
0x8C,0x63,0xF8,0xC6,0x31,
// 'О'
0x8E,0x01,0x05,0x08,0x00,0x05,
0x74,0x63,0x18,0xC6,0x2E,
// 'П'
0x8F,0x01,0x05,0x08,0x00,0x05,
0xFC,0x63,0x18,0xC6,0x31,
// 'Р'
0x90,0x01,0x05,0x08,0x00,0x05,
0xF4,0x63,0x1F,0x42,0x10,
// 'С'
0x91,0x01,0x05,0x08,0x00,0x05,
0x74,0x61,0x8,0x42,0x2E,
// 'Т'
0x92,0x01,0x05,0x08,0x00,0x05,
0xF9,0x8,0x42,0x10,0x84,
// 'У'
0x93,0x01,0x06,0x08,0x00,0x06,
0x85,0x24,0x8C,0x10,0x82,0x30,
// 'Ф'
0x94,0x01,0x08,0x08,0x00,0x08,
0x7C,0x92,0x92,0x92,0x7C,0x10,0x10,0x10,
// 'Х'
0x95,0x01,0x06,0x08,0x00,0x06,
0x85,0x24,0x8C,0x31,0x24,0xA1,
// 'Ц'
0x96,0x00,0x06,0x09,0x00,0x06,
0x8A,0x28,0xA2,0x8A,0x28,0xBF,0x4,
// 'Ч'
0x97,0x01,0x05,0x08,0x00,0x05,
0x8C,0x63,0xF0,0x84,0x21,
// 'Ш'
0x98,0x01,0x08,0x08,0x00,0x08,
0x92,0x92,0x92,0x92,0x92,0x92,0x92,0xFE,
// 'Ш'
0x99,0x01,0x08,0x09,0x00,0x08,
0x92,0x92,0x92,0x92,0x92,0x92,0x92,0xFF,0x01,
// 'Ъ'
0x9A,0x01,0x06,0x08,0x00,0x06,
0xC1,0x4,0x1E,0x45,0x14,0x5E,
// 'Ы'
0x9B,0x01,0x08,0x08,0x00,0x08,
0x82,0x82,0x82,0xF2,0x8A,0x8A,0x8A,0xF2,
// 'Ь'
0x9C,0x01,0x05,0x08,0x00,0x05,
0x84,0x21,0xE8,0xC6,0x3E,
// 'Э'
0x9D,0x01,0x05,0x08,0x00,0x05,
0x74,0x42,0x70,0x86,0x2E,
// 'Ю'
0x9E,0x01,0x08,0x08,0x00,0x08,
0x8E,0x91,0x91,0xF1,0x91,0x91,0x91,0x8E,
// 'Я'
0x9F,0x01,0x05,0x08,0x00,0x06,
0x7C,0x63,0x17,0x95,0x31,
// 'a'
0xA0,0x03,0x05,0x06,0x00,0x05,
0x70,0x5F,0x18,0xBC,
// 'б'
0xA1,0x01,0x05,0x08,0x00,0x05,
0x9,0x90,0xE8,0xC6,0x2E,
// 'в'
0xA2,0x03,0x05,0x06,0x00,0x05,
0xF4,0x7D,0x18,0xF8,
// 'г'
0xA3,0x03,0x04,0x06,0x00,0x04,
0xF8,0x88,0x88,
// 'д'
0xA4,0x03,0x06,0x07,0x00,0x06,
0x39,0x24,0x92,0x4B,0xF8,0x40,
// 'е'
0xA5,0x03,0x05,0x06,0x00,0x05,
0x74,0x7F,0x8,0xB8,
// 'ё'
0xF1,0x01,0x05,0x08,0x00,0x05,
0x50,0x1D,0x1F,0xC2,0x2E,
// 'ж'
0xA6,0x03,0x07,0x06,0x00,0x07,
0x92,0xA8,0xE2,0xA5,0x52,0x40,
// 'з'
0xA7,0x03,0x05,0x06,0x00,0x05,
0x74,0x4C,0x18,0xB8,
// 'и'
0xA8,0x03,0x05,0x06,0x00,0x05,
0x8C,0x67,0x5C,0xC4,
// 'й'
0xA9,0x01,0x05,0x08,0x00,0x05,
0x51,0x23,0x19,0xD7,0x31,
// 'к'
0xAA,0x03,0x05,0x06,0x00,0x05,
0x95,0x31,0x49,0x44,
// 'л'
0xAB,0x03,0x05,0x06,0x00,0x05,
0x3A,0x52,0x94,0xC4,
// 'м'
0xAC,0x03,0x07,0x06,0x00,0x07,
0x83,0x8E,0xAC,0x99,0x30,0x40,
// 'н'
0xAD,0x03,0x05,0x06,0x00,0x05,
0x8C,0x7F,0x18,0xC4,
// 'о'
0xAE,0x03,0x05,0x06,0x00,0x05,
0x74,0x63,0x18,0xB8,
// 'п'
0xAF,0x03,0x05,0x06,0x00,0x05,
0xFC,0x63,0x18,0xC4,
// 'р'
0xE0,0x03,0x05,0x08,0x00,0x05,
0xF4,0x63,0x1F,0x42,0x10,
// 'с'
0xE1,0x03,0x05,0x06,0x00,0x05,
0x74,0x61,0x8,0xB8,
// 'т'
0xE2,0x03,0x05,0x06,0x00,0x05,
0xF9,0x8,0x42,0x10,
// 'у'
0xE3,0x03,0x04,0x08,0x00,0x04,
0x99,0x99,0x71,0x1E,
// 'ф'
0xE4,0x03,0x07,0x08,0x00,0x07,
0x10,0xFA,0x4C,0x99,0x2F,0x84,0x08,
// 'х'
0xE5,0x03,0x04,0x06,0x00,0x04,
0x99,0x66,0x99,
// 'ц'
0xE6,0x03,0x05,0x07,0x00,0x05,
0x94,0xA5,0x29,0x7C,0x20,
// ч'
0xE7,0x03,0x04,0x06,0x00,0x04,
0x99,0x97,0x11,
// 'ш'
0xE8,0x03,0x07,0x06,0x00,0x07,
0x93,0x26,0x4C,0x99,0x3F,0xC0,
// 'щ'
0xE9,0x03,0x08,0x07,0x00,0x08,
0x92,0x92,0x92,0x92,0x92,0xFF,0x01,
// 'ъ'
0xEA,0x03,0x06,0x06,0x00,0x06,
0xE2,0x83,0x89,0x24,0xE0,
// 'ы'
0xEB,0x03,0x06,0x06,0x00,0x06,
0x86,0x1E,0x65,0x97,0x90,
// ь'
0xEC,0x03,0x04,0x06,0x00,0x04,
0x88,0xE9,0x9E,
// э'
0xED,0x03,0x05,0x06,0x00,0x05,
0x74,0x4E,0x18,0xB8,
// 'ю'
0xEE,0x03,0x06,0x06,0x00,0x06,
0x9A,0x9E,0x69,0xA6,0x60,
// 'я'
0xEF,0x03,0x05,0x06,0x00,0x05,
0x7C,0x62,0xF4,0xC4,
// Terminator
0xFF,

};

Использование описано ранее

Со шрифтом FontRusProp18 не работает:

CENTER - печатает от центра строки и далее вправо, а не как в UTFT центрирует строку.

RIGHT   - выводит строку слева с потерей половины строки.

LEFT - работает.

С родными шрифтами UTFT такого не происходит.

Похоже, UTFT_DLB  ДЛБ и писал :-)

На фото первая строка - стандартный шрифт UTFT

Ниже - CENTER, RIGHT, LEFT шрифт FontRusProp18.

RIGHT должно быть пять слов, выведено два с половиной, и в последнем слове нет последней буквы,

остальное и так понятно.

Совершенно верно  подмечены ограничения.

Это  связано с тем что у пропорционального шрифта нет ФИКСИРОВАНОЙ ширины символа и расчет длины строки дело муторное.  Конечно это можно сделать - но кто бы этим занялся.  Так что что имеем, то и мучаем.

А технически это ограничение связано с тем что в модифицированых шрифтах в параметрах ширина символа указана равная нулю. И как следствие длина строки при стандартном расчете тоже нулевая и получается такое размещение строки на экране как на фото.

Жаль. Шрифт вроде простенький, но довольно симпатичный, и, главное, убористый,

в отличие от штатных шрифтов UTFT.

Но пользоваться можно, далеко не всегда нужны эти CENTER и прочие LEFT RIGHT,

а место на экране такие шрифты здорово экономят.

В Adafruit GFX со шрифтами получше, но есть свои ограничения, так что приходится выбирать.

Вот-вот.

Заниматься никто не хочет - остается только жалеть. 

Хотя просуммировать горизонтальные размеры символов в строке - не так уж и сложно. Более того, насколько я понял (извините, не пользуюсь стандартными библиотеками, поэтому наверняка не знаю), и процедура суммирования то есть, осталось лишь тупо прописать ширину символов в нужное место (я так думаю, что если бы действительно ширины символов были прописано как 0, то вывод на экран не мог бы нормально работать). Но всем лень.

ПОка писал предыдущий ответ, пришел к выводу, что это невозможно. Если бы ширина символов нигде не была бы прописана, процедура вывода на экран не смогла бы работать. И не было бы на экране никакого пропорционального шрифта. Значит - она есть. Возможно, в виде адресов начала для каждого символа. Отсюда два варианта: 

- либо подкорректировать функцию подсчета ширины строки, чтобы она брала данные не из отдельного массива, а какие есть,

- либо написать функцию, заполняющую массив ширин символов по имеющимся данным.

...два варианта: 

- либо подкорректировать функцию подсчета ширины строки, чтобы она брала данные не из отдельного массива, а какие есть,

- либо написать функцию, заполняющую массив ширин символов по имеющимся данным.

[/quote]

Ну тут я не великий специалист, скорее чайник, хоть и со свистком.

Нашёл еще один неприятный момент: не работают printNumI и printNumF - просто ничего не выводится.

Это будет похуже неработающих CENTER и RIGHT - вывод чисел очень часто нужен.

Можно, конечно, на кривой козе объехать, но нафига это надо?

Правильно рассуждаете. В моноширном (родном) шрифте ширина символа задается ОДИН раз в описании шрифта.

В файле описания модифицированого шрифта (в данном конкретном случае) для указания что он не моноширный (не стандартный) это значение задется равное 0. А в описании КАЖДОГО символа есть данные о его ширине. Это все можно увидеть в файле шрифта который я выложил в начале темы. Даже часть коментариев по русски написал, чтоб самому не запутаться.

А насчет что часть функций не работает. Жаль конечно. Но я этой темой занялся что бы решить СВОЮ конкретную проблему (размещеения максимум текстовой информации на экране).  Я ее решил. Меня имеющийся функционал устраивает боле чем. Народ мучает и находит косяки - молодцы, другие меньше мучаться будут. 

Кто захочет дальше модифицировать/дополнять функционал - спрашивайте, поясню в чем сам разобрался.

Мое личное мнение - правильнее все же в программе переводить числа в строку и потом стоку выводить на экран. Не зависишь от реализации библиотек вывода и контролируешь формат преобразования. Особенно актуально для float. Согласен что при выводе в монитор последовательного порта удобнее не заморачиваться и пихать все как есть. Пусть само конвертирует.

Всё это хорошо, если бы не одно НО:

вот кусочек кода для рисования цифр 1-5 на кнопках тачскрина (int x; объявлено заранее, принимает

значения 0-4):    

      String b =  String(x+1);
      myGLCD.print(b, 18+(x*40), 18);

UTFT_DLB  при компиляции выдаёт "НИЗЗЯ":

no matching function for call to 'UTFT_DLB::print(String&, int, int)'

UTFT выводит всё как положено, да и не нужно это, вполне себе работает стандартное

myGLCD.printNumI(x+1, 18+(x*40), 18);

В порт мне не надо данные гнать, на экран выводить надо.

Можно, конечно, тупо прописать для каждой кнопки отдельно, но там в цикле

ещё и сами кнопки рисуются - всё за один раз - и рисование, и вычисление координат, и надписи.

 Ну и память, которой и так негусто, каждая лишняя библиотека отъедает.

Попытайтесь myGLCD.print(b.c_str(), 18+(x*40), 18);

(это - из общих соображений, сам я ни той, ни другой библиотекой не пользуюсь)

Спасибо, работает, как int так и float. Век живи - век учись.

Но всё это (+доп. библиотека, переводы типов данных и т.д.) занимают изрядный кусок памяти - около 28К

При использовании только UTFT - 24К, причём без куска собственно вычислений, только вывод на экран.

Приветствую! Спасибо за вашу работу. Заготовочкой можете поделиться? Я хочу поэкспериментировать ))

UTFT тяжёлая библиотека, просится Мега.

Хоть убейте, не пойму как строится матрица символа UTFT_DLB. Может кто-нибудь пояснить?

const uint_8t utft_dlb_font[] PROGMEM =
{
    /* заголовок шрифта */
    0x00, // ширина символов шрифта, нулевое значение - это маркер, указывает на символы разной ширины
    0x12, // высота шрифта
    0x00, // зарезервировано (для чего?)
    0x00, // зарезервировано (для чего?)

    // 'Б'
    /* заголовок символа */
    0x81, // ASCSI код (HEX)
    0x01, // отступ пикселей сверху
    0x08, // ширина символа, пикселей
    0x0D, // высота символа, пикселей
    0x01, // отступ пикселей, слева
    0x0A, // дельта x - ширина символа + количество пикселей после него (отступ)
    /* матрица симвыола */
    0xFE,0xFE,0xC0,0xC0,0xC0,0xFC,0xFE,0xC3,0xC3,0xC3,0xC3,0xFE,0xFC, 
    /* .... и так далее: заголовок символа, матриза, заголовок, матрица... */
}

/* матрица симвыола */
0xFE,0xFE,0xC0,0xC0,0xC0,0xFC,0xFE,0xC3,0xC3,0xC3,0xC3,0xFE,0xFC,

0xFE = 1111 1110
0xC0 = 1100 0000
и т.д.

11111110
11111110
11000000
11000000
11000000
11111100
11111110
11000011
11000011
11000011
11000011
11111110
11111100

Спасибо за ответ.

Да, с символом шириной 8 понятно. Неудачный я пример привел. Вот, например, символ "Ж" имеет размер 20*14.

// 'Ж'
0x86,0x02,0x14,0x0E,0x00,0x13,
0x00,0x00,0x06,0x06,0x0C,0x30,0x61,0x81,0x86,0x30,0x0C,0x66,0x00,0x66,0xC0,
0x07,0x7C,0x00,0x7F,0xE0,0x0C,0xF3,0x01,0x86,0x30,0x10,0x61,0x83,0x06,0x08,
0x60,0x60,0xC6,0x06,0x06,

Еще интереснее, восклицательный знак. Размер у него 2*13

// '!'
0x21,0x01,0x02,0x0D,0x03,0x07,
0xFF,0xFF,0xC3,0xC0,

// '!'
0x21,  // ASCSI код (HEX)
0x01,  // отступ пикселей сверху
0x02,  // ширина символа, пикселей
0x0D,  // высота символа, пикселей
0x03,  // отступ пикселей, слева
0x07,  // дельта x...
0xFF,0xFF,0xC3,0xC0,

11111111
11111111
11000011
11000000

11
11
11
11
11
11
11
11
11
00
00
11
11
00 00 00 (лишние, 2*13=26 бит закончились)

Здравствуйте. Подскажите пожалуйста библиотеку для больших русских шрифтов. BigRusFont - маловаты

Спасибо Вам. Может у Вас есть уже готовый такой шрифт больше чем BigRusFont??

я начал делать, но из-за работы пока приостановил, не хватает времени :(

Отблагодарю Вас если поможете сделать большой шрифт наподобии

Arial_round_16x24

или

Calibri24x32GR

от сюда http://www.rinkydinkelectronics.com/r_fonts.php

как-то бы связаться вне форума, чтобы тему не захламлять

можете мне написать на почту pavts80@mail.ru

да, написал. вы уже разобрались в структуре данного шрифта?

Структура ясна в общем, но более детально нет опыта переделывать.

Года 4 назад когда нужен был русский шрифт в библиотеке UTFT я просто латинские символы перерисовал на русские, и писал латинскими, но выдавала русский шрифт. Не очень удобно.

в Adafruit_GFX можно создавать свои шрифты любого размера из TTF фонтов, например фонтов из комплекта Винды

так вроде в сообщениях #34 #36 negavoid все подробно обьяснил

да, я знаю. потому и спросил человека, разобрался он или нет. ведь все равно вопрос задает про большой шрифт.

я начал программу писать, которая может с любого ттф шрифта выдать формат по сабжу, с нужным размером. осталось-то не много допилить, да руки не доходят

через Адафруит fontconvert ?

нет. свое, для UTFT_DLB. Приглянулась мне почему-то эта надстройка UTFT. Рекомендуете лучше использовать Адафруит?

я и имел в виду UTFT_DLB. Просто у Адафруита уже есть программа, которая из любого TTF шрифта делает их фонт. А форматы фонтов Адафруит и UTFT_DLB. очень похожи, там буквально один-два байта поменять надо.

А вы что, начали писать конвертер TTF с чистого листа? интересно было бы посмотреть, если код не секретный