Русские символы LCD 5110

inhelp
inhelp аватар
Offline
Зарегистрирован: 23.09.2012

Подключил дисплейчик LCD 5110  к нано , все работает, использую библиотеку Adafruit_PCD8544, но там нет русских символов, подскажите как допилить самому ...

inhelp
inhelp аватар
Offline
Зарегистрирован: 23.09.2012

Точнее библиотека Adafruit_GFX  https://github.com/adafruit/Adafruit-GFX-Library

inhelp
inhelp аватар
Offline
Зарегистрирован: 23.09.2012

Как вывести русские символы на дисплее NOKIA LCD 5110 (PCD8544) . при использовании библиотеки Adafruit-GFX-Library ???

Или хотя бы подскажите как самому дорисовать руссские символы ...

В библиотеке латинские символы прописани так

// Standard ASCII 5x7 font

static const unsigned char font[] PROGMEM = {
    0x00, 0x00, 0x00, 0x00, 0x00,
	0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
	0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
	0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
	0x18, 0x3C, 0x7E, 0x3C, 0x18,
	0x1C, 0x57, 0x7D, 0x57, 0x1C,
	0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
	0x00, 0x18, 0x3C, 0x18, 0x00,
	0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
	0x00, 0x18, 0x24, 0x18, 0x00,
	0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
	0x30, 0x48, 0x3A, 0x06, 0x0E,
	0x26, 0x29, 0x79, 0x29, 0x26,
	0x40, 0x7F, 0x05, 0x05, 0x07,

ну и так далее ....  

Хотелось бы узнать как самому прописать русские символи или "куда копать" ... 

inhelp
inhelp аватар
Offline
Зарегистрирован: 23.09.2012

Нашел статью http://robocraft.ru/blog/892.html буду разруливать...

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

в правильную сторону копаете. даже символы не придется рисовать

 

bolotin.denis
bolotin.denis аватар
Offline
Зарегистрирован: 15.09.2013
{ 0x7C, 0x12, 0x11, 0x12, 0x7C },  // c0 А
  { 0x7F, 0x49, 0x49, 0x49, 0x31 },  // c1 Б
  { 0x7F, 0x49, 0x49, 0x49, 0x36 },  // c2 В
  { 0x7F, 0x01, 0x01, 0x01, 0x01 },  // c3 Г
  { 0x60, 0x3F, 0x21, 0x3F, 0x60 },  // c4 Д
  { 0x7F, 0x49, 0x49, 0x49, 0x41 },  // c5 Е
  { 0x77, 0x08, 0x7F, 0x08, 0x77 },  // c6 Ж
  { 0x22, 0x41, 0x49, 0x49, 0x36 },  // c7 З
  { 0x7F, 0x10, 0x08, 0x04, 0x7F },  // c8 И
  { 0x7E, 0x10, 0x09, 0x04, 0x7E },  // c9 Й
  { 0x7F, 0x08, 0x14, 0x22, 0x41 },  // ca К
  { 0x40, 0x3E, 0x01, 0x01, 0x7F },  // cb Л
  { 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // cc М
  { 0x7F, 0x08, 0x08, 0x08, 0x7F },  // cd Н
  { 0x3E, 0x41, 0x41, 0x41, 0x3E },  // ce О
  { 0x7F, 0x01, 0x01, 0x01, 0x7F },  // cf П
  { 0x7F, 0x09, 0x09, 0x09, 0x06 },  // d0 Р
  { 0x3E, 0x41, 0x41, 0x41, 0x22 },  // d1 С
  { 0x01, 0x01, 0x7F, 0x01, 0x01 },  // d2 Т
  { 0x07, 0x48, 0x48, 0x48, 0x3F },  // d3 У
  { 0x0E, 0x11, 0x7F, 0x11, 0x0E },  // d4 Ф
  { 0x63, 0x14, 0x08, 0x14, 0x63 },  // d5 Х
  { 0x3F, 0x20, 0x20, 0x3F, 0x60 },  // d6 Ц
  { 0x07, 0x08, 0x08, 0x08, 0x7F },  // d7 Ч
  { 0x7F, 0x40, 0x7E, 0x40, 0x7F },  // d8 Ш
  { 0x3F, 0x20, 0x3F, 0x20, 0x7F },  // d9 Щ
  { 0x01, 0x7F, 0x48, 0x48, 0x30 },  // da Ъ
  { 0x7F, 0x48, 0x30, 0x00, 0x7F },  // db Ы
  { 0x00, 0x7F, 0x48, 0x48, 0x30 },  // dc Ь
  { 0x22, 0x41, 0x49, 0x49, 0x3E },  // dd Э
  { 0x7F, 0x08, 0x3E, 0x41, 0x3E },  // de Ю
  { 0x46, 0x29, 0x19, 0x09, 0x7F },  // df Я
  { 0x20, 0x54, 0x54, 0x54, 0x78 },  // e0 а
  { 0x3C, 0x4A, 0x4A, 0x4A, 0x31 },  // e1 б
  { 0x7C, 0x54, 0x54, 0x28, 0x00 },  // e2 в
  { 0x7C, 0x04, 0x04, 0x0C, 0x00 },  // e3 г
  { 0x60, 0x3C, 0x24, 0x3C, 0x60 },  // e4 д
  { 0x38, 0x54, 0x54, 0x54, 0x18 },  // e5 е
  { 0x6C, 0x10, 0x7C, 0x10, 0x6C },  // e6 ж
  { 0x00, 0x44, 0x54, 0x54, 0x28 },  // e7 з
  { 0x7C, 0x20, 0x10, 0x08, 0x7C },  // e8 и
  { 0x7C, 0x21, 0x12, 0x09, 0x7C },  // e9 й
  { 0x7C, 0x10, 0x28, 0x44, 0x00 },  // ea к
  { 0x40, 0x38, 0x04, 0x04, 0x7C },  // eb л
  { 0x7C, 0x08, 0x10, 0x08, 0x7C },  // ec м
  { 0x7C, 0x10, 0x10, 0x10, 0x7C },  // ed н
  { 0x38, 0x44, 0x44, 0x44, 0x38 },  // ee о
  { 0x7C, 0x04, 0x04, 0x04, 0x7C },  // ef п
  { 0x7C, 0x14, 0x14, 0x14, 0x08 },  // f0 р
  { 0x38, 0x44, 0x44, 0x44, 0x00 },  // f1 с
  { 0x04, 0x04, 0x7C, 0x04, 0x04 },  // f2 т
  { 0x0C, 0x50, 0x50, 0x50, 0x3C },  // f3 у
  { 0x08, 0x14, 0x7C, 0x14, 0x08 },  // f4 ф
  { 0x44, 0x28, 0x10, 0x28, 0x44 },  // f5 х
  { 0x3C, 0x20, 0x20, 0x3C, 0x60 },  // f6 ц
  { 0x0C, 0x10, 0x10, 0x10, 0x7C },  // f7 ч
  { 0x7C, 0x40, 0x7C, 0x40, 0x7C },  // f8 ш
  { 0x3C, 0x20, 0x3C, 0x20, 0x7C },  // f9 щ
  { 0x04, 0x7C, 0x50, 0x50, 0x20 },  // fa ъ
  { 0x7C, 0x50, 0x20, 0x00, 0x7C },  // fb ы
  { 0x00, 0x7C, 0x50, 0x50, 0x20 },  // fc ь
  { 0x28, 0x44, 0x54, 0x54, 0x38 },  // fd э
  { 0x7C, 0x10, 0x38, 0x44, 0x38 },  // fe ю
  { 0x48, 0x54, 0x34, 0x14, 0x7C }   // ff я
 
 
Может чемто поможит. Но сам еще не игрался.
Coder
Coder аватар
Offline
Зарегистрирован: 04.03.2012

У кого-то получилось подгрузить русский шрифт?

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

так ссылку ТС привел. там написано

Казалось бы, добавляем наш двоичный массив в хвост шрифта, корректируем заголовок и вот оно — счастье! Не тут-то было!
Меня осенила здравая идея — проверить в какой кодировке работает Arduino IDE. Для этого был спешно набросан кусочек кода:

...

Выяснилось — работаем в UTF-8. Берем таблицу кодировки и получается что:
диапазону 0x80 — 0x8F соответствуют маленькие буквы от «р» до «я»
с 0x90 и до 0xAF идут заглавные по порядку «А» — «Я» исключая «Ё»
и в хвосте с 0xB0 до 0xBF маленькие от «а» до «п». 

 

Coder
Coder аватар
Offline
Зарегистрирован: 04.03.2012

Спасиб. Не совсем правда все понятно, но щас попробую разобраться. Я думал мот есть готовое уже :) Как всегда, хочется быстро и без гемора :))

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

ну пример можешь посмотреть для пиков, но си он и в африке си

 

void low_init()
{
	CMCON = 0x07;	//	отключение компаратора

	TRISB = 0x00;
	PORTB = 0;
}

#define SetBit(x,y) (x|=(1<<y))
#define ClrBit(x,y) (x&=~(1<<y))
#define ToggleBit(x,y) (x^=(1<<y))
#define TestBit(x,y) (x&(1<<y))  

void delay(unsigned int p)
{
	unsigned int i;
	for(i=0;i<p;i++){asm("NOP");}
}

void delay1000(unsigned int p)
{
	while(p>0){delay(1000);p--;}
}

//	LCD NOKIA1100
#define SCLK_on 	SetBit(PORTB,7)
#define SDA_on 		SetBit(PORTB,6)
#define CS_on 		SetBit(PORTB,5)
#define RST_on 		SetBit(PORTB,4)
#define SCLK_off 	ClrBit(PORTB,7)
#define SDA_off 	ClrBit(PORTB,6)
#define CS_off 		ClrBit(PORTB,5)
#define RST_off 	ClrBit(PORTB,4)

#define lcd_CMD		0
#define lcd_DATA	1

unsigned char X,Y;//	Две глобальные переменные расположения курсора

static const char lcd_font[][5] =
{
	{ 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
	{ 0x00, 0x00, 0x2f, 0x00, 0x00 },  // !
	{ 0x00, 0x07, 0x00, 0x07, 0x00 },  // "
	{ 0x14, 0x7f, 0x14, 0x7f, 0x14 },  // #
	{ 0x24, 0x2a, 0x7f, 0x2a, 0x12 },  // $
	{ 0x23, 0x13, 0x08, 0x64, 0x62 },  // %				

	{ 0x36, 0x49, 0x55, 0x22, 0x50 },  // &
	{ 0x00, 0x05, 0x03, 0x00, 0x00 },  // '
	{ 0x00, 0x1c, 0x22, 0x41, 0x00 },  // (
	{ 0x00, 0x41, 0x22, 0x1c, 0x00 },  // )
	{ 0x14, 0x08, 0x3E, 0x08, 0x14 },  // *
	{ 0x08, 0x08, 0x3E, 0x08, 0x08 },  // +
	{ 0x00, 0x00, 0x50, 0x30, 0x00 },  // ,
	{ 0x10, 0x10, 0x10, 0x10, 0x10 },  // -
	{ 0x00, 0x60, 0x60, 0x00, 0x00 },  // .
	{ 0x20, 0x10, 0x08, 0x04, 0x02 },  // /
	{ 0x3E, 0x51, 0x49, 0x45, 0x3E },  // 0
	{ 0x00, 0x42, 0x7F, 0x40, 0x00 },  // 1
	{ 0x42, 0x61, 0x51, 0x49, 0x46 },  // 2
	{ 0x21, 0x41, 0x45, 0x4B, 0x31 },  // 3
	{ 0x18, 0x14, 0x12, 0x7F, 0x10 },  // 4
	{ 0x27, 0x45, 0x45, 0x45, 0x39 },  // 5
	{ 0x3C, 0x4A, 0x49, 0x49, 0x30 },  // 6
	{ 0x01, 0x71, 0x09, 0x05, 0x03 },  // 7
	{ 0x36, 0x49, 0x49, 0x49, 0x36 },  // 8
	{ 0x06, 0x49, 0x49, 0x29, 0x1E },  // 9
	{ 0x00, 0x36, 0x36, 0x00, 0x00 },  // :
	{ 0x00, 0x56, 0x36, 0x00, 0x00 },  // ;
	{ 0x08, 0x14, 0x22, 0x41, 0x00 },  // <
	{ 0x14, 0x14, 0x14, 0x14, 0x14 },  // =
	{ 0x00, 0x41, 0x22, 0x14, 0x08 },  // >
	{ 0x02, 0x01, 0x51, 0x09, 0x06 },  // ?
	{ 0x32, 0x49, 0x59, 0x51, 0x3E },  // @
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // A
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // B
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // C
	{ 0x7F, 0x41, 0x41, 0x22, 0x1C },  // D
	{ 0x7F, 0x49, 0x49, 0x49, 0x41 },  // E
	{ 0x7F, 0x09, 0x09, 0x09, 0x01 },  // F
	{ 0x3E, 0x41, 0x49, 0x49, 0x7A },  // G
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // H
	{ 0x00, 0x41, 0x7F, 0x41, 0x00 },  // I
	{ 0x20, 0x40, 0x41, 0x3F, 0x01 },  // J
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // K
	{ 0x7F, 0x40, 0x40, 0x40, 0x40 },  // L
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // M
	{ 0x7F, 0x04, 0x08, 0x10, 0x7F },  // N
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // O
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // P
	{ 0x3E, 0x41, 0x51, 0x21, 0x5E },  // Q
	{ 0x7F, 0x09, 0x19, 0x29, 0x46 },  // R
	{ 0x46, 0x49, 0x49, 0x49, 0x31 },  // S
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // T
	{ 0x3F, 0x40, 0x40, 0x40, 0x3F },  // U
	{ 0x1F, 0x20, 0x40, 0x20, 0x1F },  // V
	{ 0x3F, 0x40, 0x38, 0x40, 0x3F },  // W
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // X
	{ 0x07, 0x08, 0x70, 0x08, 0x07 },  // Y
	{ 0x61, 0x51, 0x49, 0x45, 0x43 },  // Z
	{ 0x00, 0x7F, 0x41, 0x41, 0x00 },  // [
	{ 0x55, 0x2A, 0x55, 0x2A, 0x55 },  // 55
	{ 0x00, 0x41, 0x41, 0x7F, 0x00 },  // ]
	{ 0x04, 0x02, 0x01, 0x02, 0x04 },  // ^
	{ 0x40, 0x40, 0x40, 0x40, 0x40 },  // _
	{ 0x00, 0x01, 0x02, 0x04, 0x00 },  // '
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // a
	{ 0x7F, 0x48, 0x44, 0x44, 0x38 },  // b
	{ 0x38, 0x44, 0x44, 0x44, 0x20 },  // c
	{ 0x38, 0x44, 0x44, 0x48, 0x7F },  // d
	{ 0x38, 0x54, 0x54, 0x54, 0x18 },  // e
	{ 0x08, 0x7E, 0x09, 0x01, 0x02 },  // f
	{ 0x0C, 0x52, 0x52, 0x52, 0x3E },  // g
	{ 0x7F, 0x08, 0x04, 0x04, 0x78 },  // h
	{ 0x00, 0x44, 0x7D, 0x40, 0x00 },  // i
	{ 0x20, 0x40, 0x44, 0x3D, 0x00 },  // j
	{ 0x7F, 0x10, 0x28, 0x44, 0x00 },  // k
	{ 0x00, 0x41, 0x7F, 0x40, 0x00 },  // l
	{ 0x7C, 0x04, 0x18, 0x04, 0x78 },  // m
	{ 0x7C, 0x08, 0x04, 0x04, 0x78 },  // n
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // o
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // p
	{ 0x08, 0x14, 0x14, 0x18, 0x7C },  // q
	{ 0x7C, 0x08, 0x04, 0x04, 0x08 },  // r
	{ 0x48, 0x54, 0x54, 0x54, 0x20 },  // s
	{ 0x04, 0x3F, 0x44, 0x40, 0x20 },  // t
	{ 0x3C, 0x40, 0x40, 0x20, 0x7C },  // u
	{ 0x1C, 0x20, 0x40, 0x20, 0x1C },  // v
	{ 0x3C, 0x40, 0x30, 0x40, 0x3C },  // w
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // x
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // y
	{ 0x44, 0x64, 0x54, 0x4C, 0x44 },  // z

	{ 0x08, 0x08, 0x36, 0x41, 0x41 },  // {
	{ 0x00, 0x00, 0x7F, 0x00, 0x00 },  // |
	{ 0x41, 0x41, 0x36, 0x08, 0x08 },   // }
	{ 0x02, 0x01, 0x02, 0x02, 0x01 },   // ~
   
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // А
	{ 0x7F, 0x49, 0x49, 0x49, 0x33 },  // Б
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // В
	{ 0x7F, 0x01, 0x01, 0x01, 0x03 },  // Г
	{ 0xE0, 0x51, 0x4F, 0x41, 0xFF },  // Д
	{ 0x7F, 0x49, 0x49, 0x49, 0x49 },  // Е
	{ 0x77, 0x08, 0x7F, 0x08, 0x77 },  // Ж
	{ 0x49, 0x49, 0x49, 0x49, 0x36 },  // З
	{ 0x7F, 0x10, 0x08, 0x04, 0x7F },  // И
	{ 0x7C, 0x21, 0x12, 0x09, 0x7C },  // Й
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // К
	{ 0x20, 0x41, 0x3F, 0x01, 0x7F },  // Л
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // М
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // Н
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // О
	{ 0x7F, 0x01, 0x01, 0x01, 0x7F },  // П
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // Р
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // С
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // Т
	{ 0x27, 0x48, 0x48, 0x48, 0x3F },  // У
	{ 0x1C, 0x22, 0x7F, 0x22, 0x1C },  // Ф
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // Х
	{ 0x7F, 0x40, 0x40, 0x40, 0xFF },  // Ц
	{ 0x07, 0x08, 0x08, 0x08, 0x7F },  // Ч
	{ 0x7F, 0x40, 0x7F, 0x40, 0x7F },  // Ш
	{ 0x7F, 0x40, 0x7F, 0x40, 0xFF },  // Щ
	{ 0x01, 0x7F, 0x48, 0x48, 0x30 },  // Ъ
	{ 0x7F, 0x48, 0x30, 0x00, 0x7F },  // Ы
	{ 0x7F, 0x48, 0x48, 0x30, 0x00 },  // Ь
	{ 0x22, 0x41, 0x49, 0x49, 0x3E },  // Э
	{ 0x7F, 0x08, 0x3E, 0x41, 0x3E },  // Ю
	{ 0x46, 0x29, 0x19, 0x09, 0x7F },  // Я
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // а
	{ 0x3C, 0x4A, 0x4A, 0x49, 0x31 },  // б
	{ 0x7C, 0x54, 0x54, 0x28, 0x00 },  // в
	{ 0x7C, 0x04, 0x04, 0x04, 0x0C },  // г
	{ 0xE0, 0x54, 0x4C, 0x44, 0xFC },  // д
	{ 0x38, 0x54, 0x54, 0x54, 0x08 },  // е
	{ 0x6C, 0x10, 0x7C, 0x10, 0x6C },  // ж
	{ 0x44, 0x44, 0x54, 0x54, 0x28 },  // з
	{ 0x7C, 0x20, 0x10, 0x08, 0x7C },  // и
	{ 0x78, 0x42, 0x24, 0x12, 0x78 },  // й
	{ 0x7C, 0x10, 0x28, 0x44, 0x00 },  // к
	{ 0x20, 0x44, 0x3C, 0x04, 0x7C },  // л
	{ 0x7C, 0x08, 0x10, 0x08, 0x7C },  // м
	{ 0x7C, 0x10, 0x10, 0x10, 0x7C },  // н
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // о
	{ 0x7C, 0x04, 0x04, 0x04, 0x7C },  // п
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // р
	{ 0x38, 0x44, 0x44, 0x44, 0x44 },  // с
	{ 0x04, 0x04, 0x7C, 0x04, 0x04 },  // т
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // у
	{ 0x18, 0x24, 0x7E, 0x24, 0x18 },  // ф
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // х
	{ 0x7C, 0x40, 0x40, 0x40, 0xFC },  // ц
	{ 0x0C, 0x10, 0x10, 0x10, 0x7C },  // ч
	{ 0x7C, 0x40, 0x7C, 0x40, 0x7C },  // ш
	{ 0x7C, 0x40, 0x7C, 0x40, 0xFC },  // щ
	{ 0x04, 0x7C, 0x50, 0x50, 0x20 },  // ъ
	{ 0x7C, 0x50, 0x20, 0x00, 0x7C },  // ы
	{ 0x7C, 0x50, 0x50, 0x20, 0x00 },  // ь
	{ 0x28, 0x44, 0x54, 0x54, 0x38 },  // э
	{ 0x7C, 0x10, 0x38, 0x44, 0x38 },  // ю
	{ 0x08, 0x54, 0x34, 0x14, 0x7C }  // я
};

void lcd_write(char cd,unsigned char c)
{
	char i;
	CS_off;
	SCLK_off;
	if(cd)
	{
		SDA_on;
	}
	else
	{
		SDA_off;
	}
	SCLK_on;

	for(i=0;i<8;i++)
	{
		SCLK_off;
		if(c & 0x80)
			SDA_on;
		else
			SDA_off;
		SCLK_on;
		c <<= 1;
		delay(2);
	}
	CS_on;
}

void lcd_clear(void)
{
	unsigned int i;
	lcd_write(lcd_CMD,0x40);
	lcd_write(lcd_CMD,0xb0);
	lcd_write(lcd_CMD,0x10);
	lcd_write(lcd_CMD,0x00);
	lcd_write(lcd_CMD,0xae);
	for(i=0;i<864;i++)
		lcd_write(lcd_DATA,0x00);
	lcd_write(lcd_CMD,0xaf);
}

void lcd_init(void)
{
	CS_off;
	RST_off;
	delay(100);
	RST_on;
	lcd_write(lcd_CMD,0x20);
	lcd_write(lcd_CMD,0x90); 
	lcd_write(lcd_CMD,0xA4);
	lcd_write(lcd_CMD,0x2F);
	lcd_write(lcd_CMD,0x40);
	lcd_write(lcd_CMD,0xb0);
	lcd_write(lcd_CMD,0x10);
	lcd_write(lcd_CMD,0x0);
	lcd_write(lcd_CMD,0xC8);
	lcd_write(lcd_CMD,0xa1);
	lcd_write(lcd_CMD,0xac);
	lcd_write(lcd_CMD,0x07);
	//lcd_write(CMD,0xF9); // 
	lcd_write(lcd_CMD,0xaf);

	lcd_clear();
	lcd_write(lcd_CMD,0xa7);
	delay(1000);
	lcd_write(lcd_CMD,0xa6);
	delay(2000);
}

void lcd_gotoxy(unsigned char x,unsigned char y)
{
	X=x;
	Y=y;
	x=x*6;
	lcd_write(lcd_CMD,(0xB0|(y&0x0F)));	
	lcd_write(lcd_CMD,(0x00|(x&0x0F)));
	lcd_write(lcd_CMD,(0x10|((x>>4)&0x07)));
}

unsigned char lcd_symbol_decode(unsigned char c)
{
	if(32<=c&&c<='~')
	{
		c=c-32;
	}
	else
	{
		if(192<=c&&c<=255)
		{
			c=c-97;
		}
		else
		{
			c=255;
		}
	}
	return c;
}

void lcd_putch(unsigned char c)
{
	c=lcd_symbol_decode(c);
	if(c==255)
	{
		return;
	}
	lcd_write(lcd_DATA,lcd_font[c][0]);
	lcd_write(lcd_DATA,lcd_font[c][1]);
	lcd_write(lcd_DATA,lcd_font[c][2]);
	lcd_write(lcd_DATA,lcd_font[c][3]);
	lcd_write(lcd_DATA,lcd_font[c][4]);
	lcd_write(lcd_DATA,0x00);
	X++;
	if(X==16)
	{
		if(Y==7)
		{
			lcd_gotoxy(0,0);
		}
		else
		{
			lcd_gotoxy(0,Y+1);
		}
	}
}

void lcd_puts(const char *s)
{
	while (*s) 
	{
		lcd_putch(*s);
		++s;
	}
}

void lcd_test(void)
{
	unsigned char i;    
    lcd_gotoxy(0,0);
	for(i=32;i<127;i++) 
    {
		lcd_putch(i);
	}
	for(i=192;i<=224;i++) 
    {
		lcd_putch(i);
	}
}

//	-LCD NOKIA1100


void main()
{
	low_init();
	lcd_init();
	while(1==1)
	{
		lcd_gotoxy(1,1);
		lcd_puts("LCD nokia 1100");
		lcd_gotoxy(3,3);
		lcd_puts("Графический");
		lcd_gotoxy(5,4);
		lcd_puts("дисплей");
		lcd_gotoxy(3,5);
		lcd_puts("96x65 точек");
		lcd_gotoxy(1,7);
		lcd_puts("alex-exe.net.ru");
		delay1000(3000);
		lcd_clear();
		lcd_gotoxy(1,0);
		lcd_puts("^   РАЗМЕРЫ");
		lcd_gotoxy(1,1);
		lcd_puts("|  ширина 16");
		lcd_gotoxy(0,2);
		lcd_puts("<+------------->");
		lcd_gotoxy(1,3);
		lcd_puts("|8 высота");
		lcd_gotoxy(1,4);
		lcd_puts("|");
		lcd_gotoxy(1,5);
		lcd_puts("|   дисплей");
		lcd_gotoxy(1,6);
		lcd_puts("|   вмещает");
		lcd_gotoxy(1,7);
		lcd_puts("v 128 символов");
		delay1000(3000);
		lcd_clear();
		lcd_test();
		delay1000(3000);
		lcd_clear();
		lcd_gotoxy(2, 3);
		lcd_puts("Hello, World");
		delay1000(3000);
		lcd_clear();
	}
}

 

Coder
Coder аватар
Offline
Зарегистрирован: 04.03.2012

Для меня это слишком сложно. Я так понимаю что эти процедуры декодируют введенный русский символ и найдя по коду его новое представление в массиве рисуют его по новому.

Я просто хочу руссифицировать библиотеку LCD_5110_Graph для Arduino. Там в комплекте есть файл со шрифтами (в самой библиотеке можно пользоваться разными шрифтами, это предусмотренно). Сам файл со шрифтами вот:

#if defined(__AVR__)
	#include <avr/pgmspace.h>
	#define fontdatatype uint8_t
#elif defined(__PIC32MX__)
	#define PROGMEM
	#define fontdatatype const unsigned char
#elif defined(__arm__)
	#define PROGMEM
	#define fontdatatype const unsigned char
#endif

fontdatatype SmallFont[] PROGMEM =
{
0x06, 0x08, 0x20, 0x5f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // sp
0x00, 0x00, 0x00, 0x2f, 0x00, 0x00,   // !
0x00, 0x00, 0x07, 0x00, 0x07, 0x00,   // "
0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14,   // #
0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12,   // $
0x00, 0x23, 0x13, 0x08, 0x64, 0x62,   // %
0x00, 0x36, 0x49, 0x55, 0x22, 0x50,   // &
0x00, 0x00, 0x05, 0x03, 0x00, 0x00,   // '
0x00, 0x00, 0x1c, 0x22, 0x41, 0x00,   // (
0x00, 0x00, 0x41, 0x22, 0x1c, 0x00,   // )
0x00, 0x14, 0x08, 0x3E, 0x08, 0x14,   // *
0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,   // +
0x00, 0x00, 0x00, 0xA0, 0x60, 0x00,   // ,
0x00, 0x08, 0x08, 0x08, 0x08, 0x08,   // -
0x00, 0x00, 0x60, 0x60, 0x00, 0x00,   // .
0x00, 0x20, 0x10, 0x08, 0x04, 0x02,   // /

0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,   // 0
0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,   // 1
0x00, 0x42, 0x61, 0x51, 0x49, 0x46,   // 2
0x00, 0x21, 0x41, 0x45, 0x4B, 0x31,   // 3
0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,   // 4
0x00, 0x27, 0x45, 0x45, 0x45, 0x39,   // 5
0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,   // 6
0x00, 0x01, 0x71, 0x09, 0x05, 0x03,   // 7
0x00, 0x36, 0x49, 0x49, 0x49, 0x36,   // 8
0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,   // 9
0x00, 0x00, 0x36, 0x36, 0x00, 0x00,   // :
0x00, 0x00, 0x56, 0x36, 0x00, 0x00,   // ;
0x00, 0x08, 0x14, 0x22, 0x41, 0x00,   // <
0x00, 0x14, 0x14, 0x14, 0x14, 0x14,   // =
0x00, 0x00, 0x41, 0x22, 0x14, 0x08,   // >
0x00, 0x02, 0x01, 0x51, 0x09, 0x06,   // ?

0x00, 0x32, 0x49, 0x59, 0x51, 0x3E,   // @
0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C,   // A
0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,   // B
0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,   // C
0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C,   // D
0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,   // E
0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,   // F
0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,   // G
0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,   // H
0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,   // I
0x00, 0x20, 0x40, 0x41, 0x3F, 0x01,   // J
0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,   // K
0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,   // L
0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F,   // M
0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F,   // N
0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,   // O

0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,   // P
0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,   // Q
0x00, 0x7F, 0x09, 0x19, 0x29, 0x46,   // R
0x00, 0x46, 0x49, 0x49, 0x49, 0x31,   // S
0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,   // T
0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,   // U
0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,   // V
0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F,   // W
0x00, 0x63, 0x14, 0x08, 0x14, 0x63,   // X
0x00, 0x07, 0x08, 0x70, 0x08, 0x07,   // Y
0x00, 0x61, 0x51, 0x49, 0x45, 0x43,   // Z
0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,   // [
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55,   // Backslash (Checker pattern)
0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,   // ]
0x00, 0x04, 0x02, 0x01, 0x02, 0x04,   // ^
0x00, 0x40, 0x40, 0x40, 0x40, 0x40,   // _

0x00, 0x00, 0x03, 0x05, 0x00, 0x00,   // `
0x00, 0x20, 0x54, 0x54, 0x54, 0x78,   // a
0x00, 0x7F, 0x48, 0x44, 0x44, 0x38,   // b
0x00, 0x38, 0x44, 0x44, 0x44, 0x20,   // c
0x00, 0x38, 0x44, 0x44, 0x48, 0x7F,   // d
0x00, 0x38, 0x54, 0x54, 0x54, 0x18,   // e
0x00, 0x08, 0x7E, 0x09, 0x01, 0x02,   // f
0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,   // g
0x00, 0x7F, 0x08, 0x04, 0x04, 0x78,   // h
0x00, 0x00, 0x44, 0x7D, 0x40, 0x00,   // i
0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,   // j
0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,   // k
0x00, 0x00, 0x41, 0x7F, 0x40, 0x00,   // l
0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,   // m
0x00, 0x7C, 0x08, 0x04, 0x04, 0x78,   // n
0x00, 0x38, 0x44, 0x44, 0x44, 0x38,   // o

0x00, 0xFC, 0x24, 0x24, 0x24, 0x18,   // p
0x00, 0x18, 0x24, 0x24, 0x18, 0xFC,   // q
0x00, 0x7C, 0x08, 0x04, 0x04, 0x08,   // r
0x00, 0x48, 0x54, 0x54, 0x54, 0x20,   // s
0x00, 0x04, 0x3F, 0x44, 0x40, 0x20,   // t
0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C,   // u
0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,   // v
0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C,   // w
0x00, 0x44, 0x28, 0x10, 0x28, 0x44,   // x
0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C,   // y
0x00, 0x44, 0x64, 0x54, 0x4C, 0x44,   // z
0x00, 0x00, 0x10, 0x7C, 0x82, 0x00,   // {
0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,   // |
0x00, 0x00, 0x82, 0x7C, 0x10, 0x00,   // }
0x00, 0x00, 0x06, 0x09, 0x09, 0x06    // ~ (Degrees)
};

fontdatatype MediumNumbers[] PROGMEM =
{
0x0c, 0x10, 0x2d, 0x0d,
0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00,   // -
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,   // .
0x00, 0x00, 0x02, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x02, 0x00, 0x00, 0x00, 0x00, 0x81, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x81, 0x00, 0x00,   // /
0x00, 0xfc, 0x7a, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x7a, 0xfc, 0x00, 0x00, 0x7e, 0xbc, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xbc, 0x7e, 0x00,   // 0
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0x00,   // 1
0x00, 0x00, 0x02, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x7a, 0xfc, 0x00, 0x00, 0x7e, 0xbd, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x81, 0x00, 0x00,   // 2
0x00, 0x00, 0x02, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x7a, 0xfc, 0x00, 0x00, 0x00, 0x81, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xbd, 0x7e, 0x00,   // 3
0x00, 0xfc, 0x78, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x78, 0xfc, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x3d, 0x7e, 0x00,   // 4
0x00, 0xfc, 0x7a, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x02, 0x00, 0x00, 0x00, 0x00, 0x81, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xbd, 0x7e, 0x00,   // 5
0x00, 0xfc, 0x7a, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x02, 0x00, 0x00, 0x00, 0x7e, 0xbd, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xbd, 0x7e, 0x00,   // 6
0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x7a, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x7e, 0x00,   // 7
0x00, 0xfc, 0x7a, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x7a, 0xfc, 0x00, 0x00, 0x7e, 0xbd, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xbd, 0x7e, 0x00,   // 8
0x00, 0xfc, 0x7a, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x7a, 0xfc, 0x00, 0x00, 0x00, 0x81, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xbd, 0x7e, 0x00,   // 9
};

fontdatatype BigNumbers[] PROGMEM =
{
0x0e, 0x18, 0x2d, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   // -
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xe0, 0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,   // .
0x00, 0x00, 0x02, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xc0, 0x80, 0x00, 0x00,   // /
0x00, 0xfc, 0xfa, 0xf6, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0xef, 0xc7, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc7, 0xef, 0x00, 0x00, 0x7f, 0xbf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 0
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc7, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x3f, 0x7f, 0x00,   // 1
0x00, 0x00, 0x02, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0xe0, 0xd0, 0xb8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x3b, 0x17, 0x0f, 0x00, 0x00, 0x7f, 0xbf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xc0, 0x80, 0x00, 0x00,   // 2
0x00, 0x00, 0x02, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xbb, 0xd7, 0xef, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 3
0x00, 0xfc, 0xf8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x00, 0x00, 0x0f, 0x17, 0x3b, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xbb, 0xd7, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x3f, 0x7f, 0x00,   // 4
0x00, 0xfc, 0xfa, 0xf6, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x17, 0x3b, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xb8, 0xd0, 0xe0, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 5
0x00, 0xfc, 0xfa, 0xf6, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0xef, 0xd7, 0xbb, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xb8, 0xd0, 0xe0, 0x00, 0x00, 0x7f, 0xbf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 6
0x00, 0x00, 0x02, 0x06, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc7, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x3f, 0x7f, 0x00,   // 7
0x00, 0xfc, 0xfa, 0xf6, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0xef, 0xd7, 0xbb, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xbb, 0xd7, 0xef, 0x00, 0x00, 0x7f, 0xbf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 8
0x00, 0xfc, 0xfa, 0xf6, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0xf6, 0xfa, 0xfc, 0x00, 0x00, 0x0f, 0x17, 0x3b, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0xbb, 0xd7, 0xef, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xbf, 0x7f, 0x00,   // 9
};

fontdatatype TinyFont[] PROGMEM =
{
0x04, 0x06, 0x20, 0x5f,
0x00, 0x00, 0x00, 0x03, 0xa0, 0x00, 0xc0, 0x0c, 0x00, 0xf9, 0x4f, 0x80, 0x6b, 0xeb, 0x00, 0x98, 0x8c, 0x80, 0x52, 0xa5, 0x80, 0x03, 0x00, 0x00,  // Space, !"#$%&'
0x01, 0xc8, 0x80, 0x89, 0xc0, 0x00, 0x50, 0x85, 0x00, 0x21, 0xc2, 0x00, 0x08, 0x40, 0x00, 0x20, 0x82, 0x00, 0x00, 0x20, 0x00, 0x18, 0x8c, 0x00,  // ()*+,-./
0xfa, 0x2f, 0x80, 0x4b, 0xe0, 0x80, 0x5a, 0x66, 0x80, 0x8a, 0xa5, 0x00, 0xe0, 0x8f, 0x80, 0xea, 0xab, 0x00, 0x72, 0xa9, 0x00, 0x9a, 0x8c, 0x00,  // 01234567
0xfa, 0xaf, 0x80, 0x4a, 0xa7, 0x00, 0x01, 0x40, 0x00, 0x09, 0x40, 0x00, 0x21, 0x48, 0x80, 0x51, 0x45, 0x00, 0x89, 0x42, 0x00, 0x42, 0x66, 0x00,  // 89:;<=>?
0x72, 0xa6, 0x80, 0x7a, 0x87, 0x80, 0xfa, 0xa5, 0x00, 0x72, 0x25, 0x00, 0xfa, 0x27, 0x00, 0xfa, 0xa8, 0x80, 0xfa, 0x88, 0x00, 0x72, 0x2b, 0x00,  // @ABCDEFG
0xf8, 0x8f, 0x80, 0x8b, 0xe8, 0x80, 0x8b, 0xe8, 0x00, 0xf8, 0x8d, 0x80, 0xf8, 0x20, 0x80, 0xf9, 0x0f, 0x80, 0xf9, 0xcf, 0x80, 0x72, 0x27, 0x00,  // HIJKLMNO
0xfa, 0x84, 0x00, 0x72, 0x27, 0x40, 0xfa, 0x85, 0x80, 0x4a, 0xa9, 0x00, 0x83, 0xe8, 0x00, 0xf0, 0x2f, 0x00, 0xe0, 0x6e, 0x00, 0xf0, 0xef, 0x00,  // PQRSTUVW
0xd8, 0x8d, 0x80, 0xc0, 0xec, 0x00, 0x9a, 0xac, 0x80, 0x03, 0xe8, 0x80, 0xc0, 0x81, 0x80, 0x8b, 0xe0, 0x00, 0x42, 0x04, 0x00, 0x08, 0x20, 0x80,  // XYZ[\]^_
0x02, 0x04, 0x00, 0x31, 0x23, 0x80, 0xf9, 0x23, 0x00, 0x31, 0x24, 0x80, 0x31, 0x2f, 0x80, 0x31, 0x62, 0x80, 0x23, 0xea, 0x00, 0x25, 0x53, 0x80,  // `abcdefg
0xf9, 0x03, 0x80, 0x02, 0xe0, 0x00, 0x06, 0xe0, 0x00, 0xf8, 0x42, 0x80, 0x03, 0xe0, 0x00, 0x79, 0x87, 0x80, 0x39, 0x03, 0x80, 0x31, 0x23, 0x00,  // hijklmno
0x7d, 0x23, 0x00, 0x31, 0x27, 0xc0, 0x78, 0x84, 0x00, 0x29, 0x40, 0x00, 0x43, 0xe4, 0x00, 0x70, 0x27, 0x00, 0x60, 0x66, 0x00, 0x70, 0x67, 0x00,  // pqrstuvw
0x48, 0xc4, 0x80, 0x74, 0x57, 0x80, 0x59, 0xe6, 0x80, 0x23, 0xe8, 0x80, 0x03, 0x60, 0x00, 0x8b, 0xe2, 0x00, 0x61, 0x0c, 0x00                     // zyx{|}~
};

Пробовал добавлять сюда те шрифты что находил, пишет крокозябрами. Видать, либо соотношение не то, либо адресация. Но не могу нигде найти документацию по этой библиотеке. :(

Coder
Coder аватар
Offline
Зарегистрирован: 04.03.2012

А вот пример работы со шрифтами и вобще в этой библиотеке:

#include <LCD5110_Graph.h> // Подключение библиотек
#include <DS1302.h>
DS1302 rtc(2, 3, 4); // Инициализация библиотеки с указанием
LCD5110 myGLCD(8,9,10,11,12); // пинов подключения к Arduino
extern uint8_t TinyFont[]; // Объявление трех внешних
extern uint8_t SmallFont[]; // массивов символов
extern uint8_t BigNumbers[];
Time t; // Инициализация структуры 

void setup()
{
  myGLCD.InitLCD(); // Инициализация дисплея
  rtc.halt(false); // Установка режимов 
  rtc.writeProtect(false); // работы часов
  // Следующих три строки нужно закомментировать после 
  // установки времени и загрузить скетч в плату повторно 
  rtc.setDOW(MONDAY);        // Установка дня недели
  rtc.setTime(10, 59, 10);  // Установка времени 10:59:10 
  rtc.setDate(20, 7, 2013);   // Установка даты 20 июля 2013
}

void loop()
{
  t = rtc.getTime(); // Получение времени и его запись в структуру t
  myGLCD.setFont(BigNumbers); // Установка набора символов
  myGLCD.clrScr(); // Очистка экрана
  myGLCD.printNumI(int(t.hour), 7, 0); // Вывод часов
  myGLCD.print("-", 35, 0);
  myGLCD.printNumI(int(t.min), 49, 0); // Вывод минут
  myGLCD.setFont(SmallFont); // Установка набора символов
  myGLCD.printNumI(int(t.sec), CENTER, 0); // Вывод секунд
  myGLCD.print(rtc.getDOWStr(), CENTER, 25); // Вывод дня недели
  myGLCD.print(rtc.getDateStr(), CENTER, 33); // Вывод даты
  myGLCD.setFont(TinyFont); // Установка набора символов
  myGLCD.print("Chronos by Mini-Tech", CENTER, 42);
  myGLCD.update(); // Вывод вместимого буфера на дисплей
  delay (1000); // Задержка 1 с
}

Вот так выглядит все на экране с этой программой:

Сюда просто просится русский шрифт, все вроде для этого приспособлено, но....у меня пока не получается. Мот кто подмогнет?:)

stels
Offline
Зарегистрирован: 03.01.2014

я все пытаюсь библиотеку PCD8544 русифицировать, второй день голову ломаю, никак не пойму, что ей надо(

Maverik
Offline
Зарегистрирован: 12.09.2012

Нужно использовать библиотеку U8Glib - в ней больше возможностей и русские шрифты есть.

Адафруит - фигня.

zid
Offline
Зарегистрирован: 22.01.2014

Что так никто и не руссифицировал?

Coder
Coder аватар
Offline
Зарегистрирован: 04.03.2012

Вроде как нет.

zid
Offline
Зарегистрирован: 22.01.2014

Печально(((

 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

так давал же уже как раскодировать русские символы

вот самое главное что нужно


static const char lcd_font[][5] =
{
	{ 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
	{ 0x00, 0x00, 0x2f, 0x00, 0x00 },  // !
	{ 0x00, 0x07, 0x00, 0x07, 0x00 },  // "
	{ 0x14, 0x7f, 0x14, 0x7f, 0x14 },  // #
	{ 0x24, 0x2a, 0x7f, 0x2a, 0x12 },  // $
	{ 0x23, 0x13, 0x08, 0x64, 0x62 },  // %				

	{ 0x36, 0x49, 0x55, 0x22, 0x50 },  // &
	{ 0x00, 0x05, 0x03, 0x00, 0x00 },  // '
	{ 0x00, 0x1c, 0x22, 0x41, 0x00 },  // (
	{ 0x00, 0x41, 0x22, 0x1c, 0x00 },  // )
	{ 0x14, 0x08, 0x3E, 0x08, 0x14 },  // *
	{ 0x08, 0x08, 0x3E, 0x08, 0x08 },  // +
	{ 0x00, 0x00, 0x50, 0x30, 0x00 },  // ,
	{ 0x10, 0x10, 0x10, 0x10, 0x10 },  // -
	{ 0x00, 0x60, 0x60, 0x00, 0x00 },  // .
	{ 0x20, 0x10, 0x08, 0x04, 0x02 },  // /
	{ 0x3E, 0x51, 0x49, 0x45, 0x3E },  // 0
	{ 0x00, 0x42, 0x7F, 0x40, 0x00 },  // 1
	{ 0x42, 0x61, 0x51, 0x49, 0x46 },  // 2
	{ 0x21, 0x41, 0x45, 0x4B, 0x31 },  // 3
	{ 0x18, 0x14, 0x12, 0x7F, 0x10 },  // 4
	{ 0x27, 0x45, 0x45, 0x45, 0x39 },  // 5
	{ 0x3C, 0x4A, 0x49, 0x49, 0x30 },  // 6
	{ 0x01, 0x71, 0x09, 0x05, 0x03 },  // 7
	{ 0x36, 0x49, 0x49, 0x49, 0x36 },  // 8
	{ 0x06, 0x49, 0x49, 0x29, 0x1E },  // 9
	{ 0x00, 0x36, 0x36, 0x00, 0x00 },  // :
	{ 0x00, 0x56, 0x36, 0x00, 0x00 },  // ;
	{ 0x08, 0x14, 0x22, 0x41, 0x00 },  // <
	{ 0x14, 0x14, 0x14, 0x14, 0x14 },  // =
	{ 0x00, 0x41, 0x22, 0x14, 0x08 },  // >
	{ 0x02, 0x01, 0x51, 0x09, 0x06 },  // ?
	{ 0x32, 0x49, 0x59, 0x51, 0x3E },  // @
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // A
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // B
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // C
	{ 0x7F, 0x41, 0x41, 0x22, 0x1C },  // D
	{ 0x7F, 0x49, 0x49, 0x49, 0x41 },  // E
	{ 0x7F, 0x09, 0x09, 0x09, 0x01 },  // F
	{ 0x3E, 0x41, 0x49, 0x49, 0x7A },  // G
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // H
	{ 0x00, 0x41, 0x7F, 0x41, 0x00 },  // I
	{ 0x20, 0x40, 0x41, 0x3F, 0x01 },  // J
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // K
	{ 0x7F, 0x40, 0x40, 0x40, 0x40 },  // L
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // M
	{ 0x7F, 0x04, 0x08, 0x10, 0x7F },  // N
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // O
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // P
	{ 0x3E, 0x41, 0x51, 0x21, 0x5E },  // Q
	{ 0x7F, 0x09, 0x19, 0x29, 0x46 },  // R
	{ 0x46, 0x49, 0x49, 0x49, 0x31 },  // S
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // T
	{ 0x3F, 0x40, 0x40, 0x40, 0x3F },  // U
	{ 0x1F, 0x20, 0x40, 0x20, 0x1F },  // V
	{ 0x3F, 0x40, 0x38, 0x40, 0x3F },  // W
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // X
	{ 0x07, 0x08, 0x70, 0x08, 0x07 },  // Y
	{ 0x61, 0x51, 0x49, 0x45, 0x43 },  // Z
	{ 0x00, 0x7F, 0x41, 0x41, 0x00 },  // [
	{ 0x55, 0x2A, 0x55, 0x2A, 0x55 },  // 55
	{ 0x00, 0x41, 0x41, 0x7F, 0x00 },  // ]
	{ 0x04, 0x02, 0x01, 0x02, 0x04 },  // ^
	{ 0x40, 0x40, 0x40, 0x40, 0x40 },  // _
	{ 0x00, 0x01, 0x02, 0x04, 0x00 },  // '
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // a
	{ 0x7F, 0x48, 0x44, 0x44, 0x38 },  // b
	{ 0x38, 0x44, 0x44, 0x44, 0x20 },  // c
	{ 0x38, 0x44, 0x44, 0x48, 0x7F },  // d
	{ 0x38, 0x54, 0x54, 0x54, 0x18 },  // e
	{ 0x08, 0x7E, 0x09, 0x01, 0x02 },  // f
	{ 0x0C, 0x52, 0x52, 0x52, 0x3E },  // g
	{ 0x7F, 0x08, 0x04, 0x04, 0x78 },  // h
	{ 0x00, 0x44, 0x7D, 0x40, 0x00 },  // i
	{ 0x20, 0x40, 0x44, 0x3D, 0x00 },  // j
	{ 0x7F, 0x10, 0x28, 0x44, 0x00 },  // k
	{ 0x00, 0x41, 0x7F, 0x40, 0x00 },  // l
	{ 0x7C, 0x04, 0x18, 0x04, 0x78 },  // m
	{ 0x7C, 0x08, 0x04, 0x04, 0x78 },  // n
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // o
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // p
	{ 0x08, 0x14, 0x14, 0x18, 0x7C },  // q
	{ 0x7C, 0x08, 0x04, 0x04, 0x08 },  // r
	{ 0x48, 0x54, 0x54, 0x54, 0x20 },  // s
	{ 0x04, 0x3F, 0x44, 0x40, 0x20 },  // t
	{ 0x3C, 0x40, 0x40, 0x20, 0x7C },  // u
	{ 0x1C, 0x20, 0x40, 0x20, 0x1C },  // v
	{ 0x3C, 0x40, 0x30, 0x40, 0x3C },  // w
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // x
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // y
	{ 0x44, 0x64, 0x54, 0x4C, 0x44 },  // z

	{ 0x08, 0x08, 0x36, 0x41, 0x41 },  // {
	{ 0x00, 0x00, 0x7F, 0x00, 0x00 },  // |
	{ 0x41, 0x41, 0x36, 0x08, 0x08 },   // }
	{ 0x02, 0x01, 0x02, 0x02, 0x01 },   // ~
   
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // А
	{ 0x7F, 0x49, 0x49, 0x49, 0x33 },  // Б
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // В
	{ 0x7F, 0x01, 0x01, 0x01, 0x03 },  // Г
	{ 0xE0, 0x51, 0x4F, 0x41, 0xFF },  // Д
	{ 0x7F, 0x49, 0x49, 0x49, 0x49 },  // Е
	{ 0x77, 0x08, 0x7F, 0x08, 0x77 },  // Ж
	{ 0x49, 0x49, 0x49, 0x49, 0x36 },  // З
	{ 0x7F, 0x10, 0x08, 0x04, 0x7F },  // И
	{ 0x7C, 0x21, 0x12, 0x09, 0x7C },  // Й
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // К
	{ 0x20, 0x41, 0x3F, 0x01, 0x7F },  // Л
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // М
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // Н
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // О
	{ 0x7F, 0x01, 0x01, 0x01, 0x7F },  // П
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // Р
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // С
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // Т
	{ 0x27, 0x48, 0x48, 0x48, 0x3F },  // У
	{ 0x1C, 0x22, 0x7F, 0x22, 0x1C },  // Ф
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // Х
	{ 0x7F, 0x40, 0x40, 0x40, 0xFF },  // Ц
	{ 0x07, 0x08, 0x08, 0x08, 0x7F },  // Ч
	{ 0x7F, 0x40, 0x7F, 0x40, 0x7F },  // Ш
	{ 0x7F, 0x40, 0x7F, 0x40, 0xFF },  // Щ
	{ 0x01, 0x7F, 0x48, 0x48, 0x30 },  // Ъ
	{ 0x7F, 0x48, 0x30, 0x00, 0x7F },  // Ы
	{ 0x7F, 0x48, 0x48, 0x30, 0x00 },  // Ь
	{ 0x22, 0x41, 0x49, 0x49, 0x3E },  // Э
	{ 0x7F, 0x08, 0x3E, 0x41, 0x3E },  // Ю
	{ 0x46, 0x29, 0x19, 0x09, 0x7F },  // Я
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // а
	{ 0x3C, 0x4A, 0x4A, 0x49, 0x31 },  // б
	{ 0x7C, 0x54, 0x54, 0x28, 0x00 },  // в
	{ 0x7C, 0x04, 0x04, 0x04, 0x0C },  // г
	{ 0xE0, 0x54, 0x4C, 0x44, 0xFC },  // д
	{ 0x38, 0x54, 0x54, 0x54, 0x08 },  // е
	{ 0x6C, 0x10, 0x7C, 0x10, 0x6C },  // ж
	{ 0x44, 0x44, 0x54, 0x54, 0x28 },  // з
	{ 0x7C, 0x20, 0x10, 0x08, 0x7C },  // и
	{ 0x78, 0x42, 0x24, 0x12, 0x78 },  // й
	{ 0x7C, 0x10, 0x28, 0x44, 0x00 },  // к
	{ 0x20, 0x44, 0x3C, 0x04, 0x7C },  // л
	{ 0x7C, 0x08, 0x10, 0x08, 0x7C },  // м
	{ 0x7C, 0x10, 0x10, 0x10, 0x7C },  // н
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // о
	{ 0x7C, 0x04, 0x04, 0x04, 0x7C },  // п
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // р
	{ 0x38, 0x44, 0x44, 0x44, 0x44 },  // с
	{ 0x04, 0x04, 0x7C, 0x04, 0x04 },  // т
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // у
	{ 0x18, 0x24, 0x7E, 0x24, 0x18 },  // ф
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // х
	{ 0x7C, 0x40, 0x40, 0x40, 0xFC },  // ц
	{ 0x0C, 0x10, 0x10, 0x10, 0x7C },  // ч
	{ 0x7C, 0x40, 0x7C, 0x40, 0x7C },  // ш
	{ 0x7C, 0x40, 0x7C, 0x40, 0xFC },  // щ
	{ 0x04, 0x7C, 0x50, 0x50, 0x20 },  // ъ
	{ 0x7C, 0x50, 0x20, 0x00, 0x7C },  // ы
	{ 0x7C, 0x50, 0x50, 0x20, 0x00 },  // ь
	{ 0x28, 0x44, 0x54, 0x54, 0x38 },  // э
	{ 0x7C, 0x10, 0x38, 0x44, 0x38 },  // ю
	{ 0x08, 0x54, 0x34, 0x14, 0x7C }  // я
};


unsigned char lcd_symbol_decode(unsigned char c)
{
	if(32<=c&&c<='~')
	{
		c=c-32;
	}
	else
	{
		if(192<=c&&c<=255)
		{
			c=c-97;
		}
		else
		{
			c=255;
		}
	}
	return c;
}

void lcd_putch(unsigned char c)
{
	c=lcd_symbol_decode(c);
	if(c==255)
	{
		return;
	}
	lcd_write(lcd_DATA,lcd_font[c][0]);
	lcd_write(lcd_DATA,lcd_font[c][1]);
	lcd_write(lcd_DATA,lcd_font[c][2]);
	lcd_write(lcd_DATA,lcd_font[c][3]);
	lcd_write(lcd_DATA,lcd_font[c][4]);
	lcd_write(lcd_DATA,0x00);
	X++;
	if(X==16)
	{
		if(Y==7)
		{
			lcd_gotoxy(0,0);
		}
		else
		{
			lcd_gotoxy(0,Y+1);
		}
	}
}

 

NeiroN
NeiroN аватар
Offline
Зарегистрирован: 15.06.2013

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

zid
Offline
Зарегистрирован: 22.01.2014

А как это применить в библиотеке LCD5110_Basic library?

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

вставить массив. в функции вывода символа использовать данные функции, переделав под свои названия функций вывода данных

zid
Offline
Зарегистрирован: 22.01.2014

Ээээм... Что? Я не так силён((( 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

ну если будет время может переделаю. сейчас времени нет

zid
Offline
Зарегистрирован: 22.01.2014

Эх((( Подскажи, если знаешь конечно, какой библиотекой воспользоваться?

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

в смысле? чтобы уже русские буквы работали?

zid
Offline
Зарегистрирован: 22.01.2014

да)))

 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013
zid
Offline
Зарегистрирован: 22.01.2014

Может сморожу глупость... а для duinы?

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

ардуина это авр. код для авр, мега8. может хоть что то сделаешь. там переделать нефиг делать, просто полчаса времени потратить (полчаса грубо)

zid
Offline
Зарегистрирован: 22.01.2014

нееет(((( я ленивая задница и хочу всё готовое!

 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

а я тебе не мама о тебе тут заботится, особенно если ты ленивая задница

zid
Offline
Зарегистрирован: 22.01.2014

Нууу Мааааааам!

 

zid
Offline
Зарегистрирован: 22.01.2014

Я же наверное не один такой((((

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

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

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

вот сделал. хз работает или нет. по крайней мере компилируется

http://yadi.sk/d/CXjuENmaEEwun

в папке дисплеи 5110

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

Droni
Offline
Зарегистрирован: 12.10.2014

наваял простенький редактор шрифта для Adafruit_GFX. Может кому пригодится (для работы нужен .NET 4.5).

https://www.dropbox.com/s/y0v3t08qsm0wsuv/FontEditor.exe?dl=0

и поправил русские симолы

https://www.dropbox.com/s/plybyfh8045s5eg/glcdfont-rus.c?dl=0

подкопируйте этот файлик в папку с Adafruit_GFX и поправьте в файле Adafruit_GFX.cpp строку

#include "glcdfont.c"

на

#include "glcdfont-rus.c"

 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

просто интересно чем простая смеша таблицы поможет?

русские символы и английские находятся в разных местах в ASCII

Droni
Offline
Зарегистрирован: 12.10.2014

не совсем понял вопроса. Вот как выглядит поправленый файл:

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

смена таблицы)))

я про кодировку ASCII. нельзя же просто поменять массив для символов и все заработает. просто будет вместо английских букв русскиие, причем как попало

вот этот кусок следует сначала смотреть

unsigned char lcd_symbol_decode(unsigned char c)
{
	if(32<=c&&c<='~')
	{
		c=c-32;
	}
	else
	{
		if(192<=c&&c<=255)
		{
			c=c-97;
		}
		else
		{
			c=255;
		}
	}
	return c;
}

 

Droni
Offline
Зарегистрирован: 12.10.2014

может у меня либа не такая, никаких манипуляций с char не нахожу. Все предельно просто:

#if ARDUINO >= 100
size_t Adafruit_GFX::write(uint8_t c) {
#else
void Adafruit_GFX::write(uint8_t c) {
#endif
  if (c == '\n') {
    cursor_y += textsize*8;
    cursor_x  = 0;
  } else if (c == '\r') {
    // skip em
  } else {
    drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
    cursor_x += textsize*6;
    if (wrap && (cursor_x > (_width - textsize*6))) {
      cursor_y += textsize*8;
      cursor_x = 0;
    }
  }
#if ARDUINO >= 100
  return 1;
#endif
}

// Draw a character
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
			    uint16_t color, uint16_t bg, uint8_t size) {

  if((x >= _width)            || // Clip right
     (y >= _height)           || // Clip bottom
     ((x + 6 * size - 1) < 0) || // Clip left
     ((y + 8 * size - 1) < 0))   // Clip top
    return;

  for (int8_t i=0; i<6; i++ ) {
    uint8_t line;
    if (i == 5) 
      line = 0x0;
    else 
      line = pgm_read_byte(font+(c*5)+i);
    for (int8_t j = 0; j<8; j++) {
      if (line & 0x1) {
        if (size == 1) // default size
          drawPixel(x+i, y+j, color);
        else {  // big size
          fillRect(x+(i*size), y+(j*size), size, size, color);
        } 
      } else if (bg != color) {
        if (size == 1) // default size
          drawPixel(x+i, y+j, bg);
        else {  // big size
          fillRect(x+i*size, y+j*size, size, size, bg);
        }
      }
      line >>= 1;
    }
  }
}

Единственное условие, файл должен быть в ASCII кодировке. Вот это пока не победил :( и Visual Studio и Arduino норовят сконвертить его в UTF-8 а там наш родной по два байта на символ...

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

у тебя русские символы показывает правильно? при условии что в массиве только русские буквы?

Droni
Offline
Зарегистрирован: 12.10.2014

при таком условии не будут показываться правильно. В массиве все 255 символов.

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

вот мы и вернулись к изначальному

Droni пишет:

подкопируйте этот файлик в папку с Adafruit_GFX и поправьте в файле Adafruit_GFX.cpp строку

#include "glcdfont.c"

на

#include "glcdfont-rus.c"

 

что простая замена таблицы не поможет. либо править либо делать весь массив

Droni
Offline
Зарегистрирован: 12.10.2014

jeka_tm пишет:

вот мы и вернулись к изначальному

Droni пишет:

подкопируйте этот файлик в папку с Adafruit_GFX и поправьте в файле Adafruit_GFX.cpp строку

#include "glcdfont.c"

на

#include "glcdfont-rus.c"

 

что простая замена таблицы не поможет. либо править либо делать весь массив

стоп стоп стоп. А кто сказал, что представленный мною файл содержит ТОЛЬКО русские символы? Картинку видели? Изначальный массив содержит 255 символов, но на месте русских там кракозяблы. А в предоставленном мною файле кракозяблы поправлены на русские буквы.

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

ну тогда другое дело. файл не качал. програмку только

Droni
Offline
Зарегистрирован: 12.10.2014

В общем дело плохо. В скретч русские буквы вкомпиливаются в ненужной нам кодировке. Написал консольную прилагу, которая конвертит русские буквы в 866 кодировку, которая представлена на скриншоте сверху.

https://www.dropbox.com/s/xntiswn97k7rhr6/AsciiConverter.exe?dl=0

таким образом, чтобы вывести текст "Проверка дисплея" строка в скретче должна выглядеть так "\x8F\xE0\xAE\xA2\xA5\xE0\xAA\xA0\x20\xA4\xA8\xE1\xAF\xAB\xA5\xEF"

Попутно, возможно, кому-нибудь пригодятся методы для вывода не только символа, а строки и числа:

Adafruit_PCD8544 display = Adafruit_PCD8544(5, 6, 7, 8, 9); // здесь ваши пины естественно
void write(float value)
{
  write(String(value));
}
void write(String str)
{
  for (int i = 0; i < str.length(); i++)
    display.write(str.charAt(i));
}
void write(byte b)
{
  write(String(b));
}

 

gppsoft
Offline
Зарегистрирован: 13.10.2014

jeka_tm пишет:

просто интересно чем простая смеша таблицы поможет?

русские символы и английские находятся в разных местах в ASCII

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


#define SSD1306_LCDWIDTH     128
#define SSD1306_LCDHEIGHT     64
#define SSD1306_OLED_ADDRESS 0x3C
#define SSD1306_COLUMNADDR   0x21
#define SSD1306_PAGEADDR     0x22
#define SSD1306_COMMAND_MODE 0x80
#define SSD1306_DATA_MODE	 0x40
#define SSD1306_DISPLAYOFF   0xAE
#define SSD1306_DISPLAYON    0xAF
#define SSD1306_SETDISPLAYCLOCKDIV 0xD5
#define SSD1306_SETMULTIPLEX 0xA8
#define SSD1306_SETDISPLAYOFFSET 0xD3
#define SSD1306_SETSTARTLINE 0x40
#define SSD1306_CHARGEPUMP 0x8D

#define SSD1306_MEMORYMODE 0x20
#define SSD1306_COLUMNADDR 0x21
#define SSD1306_PAGEADDR   0x22
#define SSD1306_COMSCANINC 0xC0
#define SSD1306_COMSCANDEC 0xC8

#define SSD1306_SEGREMAP 0xA0
#define SSD1306_SETCONTRAST 0x81
#define SSD1306_SETCOMPINS 0xDA
#define SSD1306_SETPRECHARGE 0xD9
#define SSD1306_SETVCOMDETECT 0xDB
#define SSD1306_DISPLAYALLON_RESUME 0xA4
#define SSD1306_NORMALDISPLAY 0xA6
#define SSD1306_INVERTDISPLAY 0xA7

#define BLACK 0
#define WHITE 1
#define INVERSE 2

#define I2C_400KHZ 1

#include <Wire.h>


static const char lcd_font[][5] PROGMEM =
{
	{ 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
	{ 0x00, 0x00, 0x2f, 0x00, 0x00 },  // !
	{ 0x00, 0x07, 0x00, 0x07, 0x00 },  // "
	{ 0x14, 0x7f, 0x14, 0x7f, 0x14 },  // #
	{ 0x24, 0x2a, 0x7f, 0x2a, 0x12 },  // $
	{ 0x23, 0x13, 0x08, 0x64, 0x62 },  // %				

	{ 0x36, 0x49, 0x55, 0x22, 0x50 },  // &
	{ 0x00, 0x05, 0x03, 0x00, 0x00 },  // '
	{ 0x00, 0x1c, 0x22, 0x41, 0x00 },  // (
	{ 0x00, 0x41, 0x22, 0x1c, 0x00 },  // )
	{ 0x14, 0x08, 0x3E, 0x08, 0x14 },  // *
	{ 0x08, 0x08, 0x3E, 0x08, 0x08 },  // +
	{ 0x00, 0x00, 0x50, 0x30, 0x00 },  // ,
	{ 0x10, 0x10, 0x10, 0x10, 0x10 },  // -
	{ 0x00, 0x60, 0x60, 0x00, 0x00 },  // .
	{ 0x20, 0x10, 0x08, 0x04, 0x02 },  // /
	{ 0x3E, 0x51, 0x49, 0x45, 0x3E },  // 0
	{ 0x00, 0x42, 0x7F, 0x40, 0x00 },  // 1
	{ 0x42, 0x61, 0x51, 0x49, 0x46 },  // 2
	{ 0x21, 0x41, 0x45, 0x4B, 0x31 },  // 3
	{ 0x18, 0x14, 0x12, 0x7F, 0x10 },  // 4
	{ 0x27, 0x45, 0x45, 0x45, 0x39 },  // 5
	{ 0x3C, 0x4A, 0x49, 0x49, 0x30 },  // 6
	{ 0x01, 0x71, 0x09, 0x05, 0x03 },  // 7
	{ 0x36, 0x49, 0x49, 0x49, 0x36 },  // 8
	{ 0x06, 0x49, 0x49, 0x29, 0x1E },  // 9
	{ 0x00, 0x36, 0x36, 0x00, 0x00 },  // :
	{ 0x00, 0x56, 0x36, 0x00, 0x00 },  // ;
	{ 0x08, 0x14, 0x22, 0x41, 0x00 },  // <
	{ 0x14, 0x14, 0x14, 0x14, 0x14 },  // =
	{ 0x00, 0x41, 0x22, 0x14, 0x08 },  // >
	{ 0x02, 0x01, 0x51, 0x09, 0x06 },  // ?
	{ 0x32, 0x49, 0x59, 0x51, 0x3E },  // @
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // A
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // B
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // C
	{ 0x7F, 0x41, 0x41, 0x22, 0x1C },  // D
	{ 0x7F, 0x49, 0x49, 0x49, 0x41 },  // E
	{ 0x7F, 0x09, 0x09, 0x09, 0x01 },  // F
	{ 0x3E, 0x41, 0x49, 0x49, 0x7A },  // G
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // H
	{ 0x00, 0x41, 0x7F, 0x41, 0x00 },  // I
	{ 0x20, 0x40, 0x41, 0x3F, 0x01 },  // J
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // K
	{ 0x7F, 0x40, 0x40, 0x40, 0x40 },  // L
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // M
	{ 0x7F, 0x04, 0x08, 0x10, 0x7F },  // N
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // O
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // P
	{ 0x3E, 0x41, 0x51, 0x21, 0x5E },  // Q
	{ 0x7F, 0x09, 0x19, 0x29, 0x46 },  // R
	{ 0x46, 0x49, 0x49, 0x49, 0x31 },  // S
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // T
	{ 0x3F, 0x40, 0x40, 0x40, 0x3F },  // U
	{ 0x1F, 0x20, 0x40, 0x20, 0x1F },  // V
	{ 0x3F, 0x40, 0x38, 0x40, 0x3F },  // W
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // X
	{ 0x07, 0x08, 0x70, 0x08, 0x07 },  // Y
	{ 0x61, 0x51, 0x49, 0x45, 0x43 },  // Z
	{ 0x00, 0x7F, 0x41, 0x41, 0x00 },  // [
	{ 0x55, 0x2A, 0x55, 0x2A, 0x55 },  // 55
	{ 0x00, 0x41, 0x41, 0x7F, 0x00 },  // ]
	{ 0x04, 0x02, 0x01, 0x02, 0x04 },  // ^
	{ 0x40, 0x40, 0x40, 0x40, 0x40 },  // _
	{ 0x00, 0x01, 0x02, 0x04, 0x00 },  // '
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // a
	{ 0x7F, 0x48, 0x44, 0x44, 0x38 },  // b
	{ 0x38, 0x44, 0x44, 0x44, 0x20 },  // c
	{ 0x38, 0x44, 0x44, 0x48, 0x7F },  // d
	{ 0x38, 0x54, 0x54, 0x54, 0x18 },  // e
	{ 0x08, 0x7E, 0x09, 0x01, 0x02 },  // f
	{ 0x0C, 0x52, 0x52, 0x52, 0x3E },  // g
	{ 0x7F, 0x08, 0x04, 0x04, 0x78 },  // h
	{ 0x00, 0x44, 0x7D, 0x40, 0x00 },  // i
	{ 0x20, 0x40, 0x44, 0x3D, 0x00 },  // j
	{ 0x7F, 0x10, 0x28, 0x44, 0x00 },  // k
	{ 0x00, 0x41, 0x7F, 0x40, 0x00 },  // l
	{ 0x7C, 0x04, 0x18, 0x04, 0x78 },  // m
	{ 0x7C, 0x08, 0x04, 0x04, 0x78 },  // n
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // o
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // p
	{ 0x08, 0x14, 0x14, 0x18, 0x7C },  // q
	{ 0x7C, 0x08, 0x04, 0x04, 0x08 },  // r
	{ 0x48, 0x54, 0x54, 0x54, 0x20 },  // s
	{ 0x04, 0x3F, 0x44, 0x40, 0x20 },  // t
	{ 0x3C, 0x40, 0x40, 0x20, 0x7C },  // u
	{ 0x1C, 0x20, 0x40, 0x20, 0x1C },  // v
	{ 0x3C, 0x40, 0x30, 0x40, 0x3C },  // w
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // x
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // y
	{ 0x44, 0x64, 0x54, 0x4C, 0x44 },  // z

	{ 0x08, 0x08, 0x36, 0x41, 0x41 },  // {
	{ 0x00, 0x00, 0x7F, 0x00, 0x00 },  // |
	{ 0x41, 0x41, 0x36, 0x08, 0x08 },   // }
	{ 0x02, 0x01, 0x02, 0x02, 0x01 },   // ~
   
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },  // А
	{ 0x7F, 0x49, 0x49, 0x49, 0x33 },  // Б
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },  // В
	{ 0x7F, 0x01, 0x01, 0x01, 0x03 },  // Г
	{ 0xE0, 0x51, 0x4F, 0x41, 0xFF },  // Д
	{ 0x7F, 0x49, 0x49, 0x49, 0x49 },  // Е
	{ 0x77, 0x08, 0x7F, 0x08, 0x77 },  // Ж
	{ 0x49, 0x49, 0x49, 0x49, 0x36 },  // З
	{ 0x7F, 0x10, 0x08, 0x04, 0x7F },  // И
	{ 0x7C, 0x21, 0x12, 0x09, 0x7C },  // Й
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },  // К
	{ 0x20, 0x41, 0x3F, 0x01, 0x7F },  // Л
	{ 0x7F, 0x02, 0x0C, 0x02, 0x7F },  // М
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },  // Н
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },  // О
	{ 0x7F, 0x01, 0x01, 0x01, 0x7F },  // П
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },  // Р
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },  // С
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },  // Т
	{ 0x27, 0x48, 0x48, 0x48, 0x3F },  // У
	{ 0x1C, 0x22, 0x7F, 0x22, 0x1C },  // Ф
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },  // Х
	{ 0x7F, 0x40, 0x40, 0x40, 0xFF },  // Ц
	{ 0x07, 0x08, 0x08, 0x08, 0x7F },  // Ч
	{ 0x7F, 0x40, 0x7F, 0x40, 0x7F },  // Ш
	{ 0x7F, 0x40, 0x7F, 0x40, 0xFF },  // Щ
	{ 0x01, 0x7F, 0x48, 0x48, 0x30 },  // Ъ
	{ 0x7F, 0x48, 0x30, 0x00, 0x7F },  // Ы
	{ 0x7F, 0x48, 0x48, 0x30, 0x00 },  // Ь
	{ 0x22, 0x41, 0x49, 0x49, 0x3E },  // Э
	{ 0x7F, 0x08, 0x3E, 0x41, 0x3E },  // Ю
	{ 0x46, 0x29, 0x19, 0x09, 0x7F },  // Я
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },  // а
	{ 0x3C, 0x4A, 0x4A, 0x49, 0x31 },  // б
	{ 0x7C, 0x54, 0x54, 0x28, 0x00 },  // в
	{ 0x7C, 0x04, 0x04, 0x04, 0x0C },  // г
	{ 0xE0, 0x54, 0x4C, 0x44, 0xFC },  // д
	{ 0x38, 0x54, 0x54, 0x54, 0x08 },  // е
	{ 0x6C, 0x10, 0x7C, 0x10, 0x6C },  // ж
	{ 0x44, 0x44, 0x54, 0x54, 0x28 },  // з
	{ 0x7C, 0x20, 0x10, 0x08, 0x7C },  // и
	{ 0x78, 0x42, 0x24, 0x12, 0x78 },  // й
	{ 0x7C, 0x10, 0x28, 0x44, 0x00 },  // к
	{ 0x20, 0x44, 0x3C, 0x04, 0x7C },  // л
	{ 0x7C, 0x08, 0x10, 0x08, 0x7C },  // м
	{ 0x7C, 0x10, 0x10, 0x10, 0x7C },  // н
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },  // о
	{ 0x7C, 0x04, 0x04, 0x04, 0x7C },  // п
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },  // р
	{ 0x38, 0x44, 0x44, 0x44, 0x44 },  // с
	{ 0x04, 0x04, 0x7C, 0x04, 0x04 },  // т
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },  // у
	{ 0x18, 0x24, 0x7E, 0x24, 0x18 },  // ф
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },  // х
	{ 0x7C, 0x40, 0x40, 0x40, 0xFC },  // ц
	{ 0x0C, 0x10, 0x10, 0x10, 0x7C },  // ч
	{ 0x7C, 0x40, 0x7C, 0x40, 0x7C },  // ш
	{ 0x7C, 0x40, 0x7C, 0x40, 0xFC },  // щ
	{ 0x04, 0x7C, 0x50, 0x50, 0x20 },  // ъ
	{ 0x7C, 0x50, 0x20, 0x00, 0x7C },  // ы
	{ 0x7C, 0x50, 0x50, 0x20, 0x00 },  // ь
	{ 0x28, 0x44, 0x54, 0x54, 0x38 },  // э
	{ 0x7C, 0x10, 0x38, 0x44, 0x38 },  // ю
	{ 0x08, 0x54, 0x34, 0x14, 0x7C }  // я
};

unsigned char lcd_symbol_decode(unsigned char c)
{
	if(32<=c&&c<='~')
	{
		c=c-32;
	}
	else
	{
		if(192<=c&&c<=255)
		{
			c=c-97;
		}
		else
		{
			c=255;
		}
	}
	return c;
}



void setup(){
	initDisplay();
	printString("Hello!",0,0,6);
	printString("Привет!",0,1,7);
}

void loop(){
	
}

//Инициализация дисплея
void initDisplay(){

	if (I2C_400KHZ){
		// save I2C bitrate (default 100Khz)
		byte twbrbackup = TWBR;
		TWBR = 12; 
		//TWBR = twbrbackup;
		//Serial.println(TWBR, DEC);
		//Serial.println(TWSR & 0x3, DEC);
	}

	sendCommand(SSD1306_DISPLAYOFF);//Выключаем дисплей
	sendCommand(SSD1306_SETDISPLAYCLOCKDIV);//Синхронизация тактирования походу :)
	sendCommand(SSD1306_COMMAND_MODE);//Drk.xftv ht;bv 
	sendCommand(SSD1306_SETMULTIPLEX);
	sendCommand(0x3F);
	sendCommand(SSD1306_SETDISPLAYOFFSET);  
	sendCommand(0x00);
	sendCommand(SSD1306_SETSTARTLINE | 0x0);            // line #0
	sendCommand(SSD1306_CHARGEPUMP);                    // 0x8D
	sendCommand(0x14); // [2] charge pump setting (p62): 0x014 enable, 0x010 disable 
	sendCommand(SSD1306_MEMORYMODE);                    // 0x20
	sendCommand(0x00);                                  // 0x0 act like ks0108
	sendCommand(SSD1306_SEGREMAP | 0x1);
	sendCommand(SSD1306_COMSCANDEC);

	sendCommand(SSD1306_SETCOMPINS);                    // 0xDA
	sendCommand(0x12);

	sendCommand(SSD1306_SETCONTRAST);
	sendCommand(0xCF);

	sendCommand(SSD1306_SETPRECHARGE); 
	sendCommand(0xF1);

	sendCommand(SSD1306_SETVCOMDETECT);                 // 0xDB
	sendCommand(0x40);
	sendCommand(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
	sendCommand(SSD1306_NORMALDISPLAY);                 // 0xA6

	sendCommand(SSD1306_DISPLAYON);

}


void printChar(unsigned char c, byte X, byte Y){

	c=lcd_symbol_decode(c);

	setCursor(X,Y);
    
	for(byte i=0; i<5; i++) {
       sendData(pgm_read_byte(&lcd_font[c][i]));
    }
}

void printString(const char *String, byte X, byte Y, byte numChar){
	byte cursor = X;
	byte count=0;
    while(String[count] && count<numChar){
		setCursor(cursor, Y);
		printChar(String[count++],cursor,Y);
		cursor+=6;
	}
}




void setCursor(byte x, byte y){
	sendCommand(SSD1306_COLUMNADDR);
	sendCommand(x);   
	sendCommand(x+6);

	sendCommand(SSD1306_PAGEADDR);
	sendCommand(y);
	sendCommand(y);
}


void invertDisplay(uint8_t i) {
	if (i) {
		sendCommand(SSD1306_INVERTDISPLAY);
	} else {
		sendCommand(SSD1306_NORMALDISPLAY);
	}
}

void sendCommand(byte command){
	Wire.beginTransmission(SSD1306_OLED_ADDRESS);
	Wire.write(0x00);
	Wire.write(command);
	Wire.endTransmission();
}

void sendData(byte command){
	Wire.beginTransmission(SSD1306_OLED_ADDRESS);
	Wire.write(0x40);
	Wire.write(command);
	Wire.endTransmission();
}

 

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

ты меня раскусил. я сижу тут всех обманываю)))

Droni
Offline
Зарегистрирован: 12.10.2014

На сколько я разобрался в теме это и не получится с русскими. Т.к. они в чип компилятся не как

printString("Привет!",0,1,7);

а как 

printString("\xD0\x9F\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82!",0,1,7);

каждая русская буква кодируется двумя байтами в кодировка UTF8, а данный скретч предполагает ASCII кодировку.

gppsoft
Offline
Зарегистрирован: 13.10.2014

Droni пишет:

На сколько я разобрался в теме это и не получится с русскими. Т.к. они в чип компилятся не как

printString("Привет!",0,1,7);

а как 

printString("\xD0\x9F\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82!",0,1,7);

каждая русская буква кодируется двумя байтами в кодировка UTF8, а данный скретч предполагает ASCII кодировку.

Все равно крякозябры.

jeka_tm
jeka_tm аватар
Offline
Зарегистрирован: 19.05.2013

может хоть фото для примера приложишь что получается