Как подружить stm и spi_oled дисплей

Это электромусор. Нормальное явление для памяти типа SDRAM, так как она не имеет цепей сброса.

 

https://drive.google.com/file/d/1-uYy_R8zv2LtppR6UzCq56UnKOilmy3r/view?usp=drivesdk

 

Срисовал шрифт под названием Pecita. Начертание убойное, правда где-то Ё при конвертации похерил. Или её не было вовсе.

Надо токмо крепко подумать, как шрифты грамотно заюзать. А то сейчас всего 7 разных букв + не хитрая картинка, а мусора во флеш аж на 4 кило налезло. Выцепить тупо кириллицу конвертер не может, а вручную лопатить - ну его в пень)))

Работа с кириллицей - целая головная боль. Редактор хочется иметь с UTF-8, а в этой таблице кириллица 2-х байтная(( А если редактор переводить в Win-1251, то на гите русские комментарии в крякозябрах((

 

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

ОГРОМНОЕ ЧЕЛОВЕЧЕСКОЕ СПАСИБО ВСЕМ!!

 

решил я, что для статических строк нет абсолютно никакого смысла грузить все символы шрифта (включая неиспользуемый ангельские), а грузить надо только те символы, которые действительно нужны. Получается два варианта: либо формировать массив символов, но тогда индекс каждого символа придётся очень хитро вычислять через case (а на препроцессоре как это сделать???) и надеяться, что очень умный компилятор сделает это статически, а во FRAM загрузит только адреса. Ну и строки буду выглядеть читабельно и привычно: 'М', 'А" и т.д.
Второй вариант тупо в лоб: вместо символов писать названия переменных, содержащие в своём названии индекс символа из ASCII таблицы. Тогда это будет выглядеть так:

Код (C++):

SSD1306_gLIB_DrawChar(0, 0, (&Cyrillic_Pixel_0xcc), 15);     // М

        SSD1306_gLIB_DrawChar(14, 0, (&Cyrillic_Pixel_0xc0), 15);     // А

Брррррррр.....
Но зато во FRAM программа занимает буквально точечку байт:

Код (Text):

676 bytes of CODE  memory
160 bytes of DATA  memory (+ 22 absolute )
545 bytes of CONST memory

Не совсем разобрался, почему у "программистов" возникает проблема с кириллицей?

Шрифт зовётся Cyrillic Pixel-7
Про Ё не забыл, но на таком размере язык у неё отвалилсо...

Надо какой-то проект намутить с этим экранчеГОМ. Вот только чи шо...

 

ЧАСЫ ⌚, я вот думаю из своего наручные часы собрать, с будильником, таймером и прочим, т.к мне часто такого функционала не хватает, а телефон- неудобно. Как бы - да, можно купить, но я нихатю, к тому же это первый проект на стм.

 

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

 

Если количество используемых символов в строках ограничено и строки определены и не будут меняться, то второй способ более целесообразен.
А если объявить функцию типа:

Код (C++):

SSD1306_gLIB_DrawString(char *c_1=NULL,char *c_2=NULL,char *c_3=NULL....

){

}

Если входящие переменные отличны от NULL вызывать
SSD1306_gLIB_DrawChar

Да и назвать их по-человечески:
_A,_M...
Получится как с 4-digit 7-segment

Код (C++):

drawStr(&_H,&_E,&_Y);
 

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

 

Нарыл в закромах BME280 и решил его испробовать на вкус. Как говорится, проект на два вечера.
И вот что мне показало сиё чудо.
Давление

Температура

Влажность


Шрифт Pecita. Высоту подбирал по "красоте". Конвертер LCD Image Converter. Бесплатный и самый лучший!
Арифметика исключительно целочисленная. Точка конкатенируется уже в строку, т.к. количество знаков после запятой известно.
В памяти всё это заняло

1244 байт ОЗУ из-за видеобуфера, без которого никак. + 160 байт откушал стек.
1262 байта - это шрифты во FRAM + настройки дисплея.
Преобразование числа в строку по 5-ой методике, изложенной здесь
http://we.easyelectronics.ru/blog/Soft/2400.html
Хотя надо попробовать через умножение, т.к. есть умножитель и он должен работать быстрее, чем безумное количество сдвигов.

 

Попробуйте molot.

 

Намутим немного design



Для инверсии цвета достаточно в экранный буфер записать подложку 0xFF (сплошная заливка), а все картинки сверху сложить с ним по исключающему или. Тогда произойдёт автоматическая инверсия.

 

чем-то напоминает эпоху конструктивизма.

 

Ого!!!
Благодарю! Это зачем мне тогда все шрифты U8G2 просматривать, если я могу сам какие мне нужно сделать, так?

 

Что-то не соображу как создаваемый программой LCD Image Converter .c/.cpp/.h - файл прицепить к U8G2?

 

Через define и читать через указатель на память, чтобы не грузить в ОЗУ это все.

 

Не сильно обременю, если попрошу пример кода (кусок с подключением собственного шрифта)?

 

Под AVR у меня нету примера, но смысл тот же. Есть для MSP430FR. Разница лишь в том, что для старых AVR необходимо добавить квалификатор PROGMEM, чтобы извлекать данные из ROM не перемещая их d RAM.
Файл с данными шрифта из программы LCD Image Converter с изменениями под себя:

Спойлер: Pecita_36.h

Код (C++):

/*******************************************************************************
* font
* filename: C:/Users/Andrey/Documents/BUDDA/MCU/MSP430FR/Examples/BME280/source/Pecita_36.xml
* name: Pecita_36
* family: Pecita
* size: 48
* style: Normal
* included characters: 9876543210-°
* antialiasing: no
* type: proportional
* encoding: windows-1251
* unicode bom: no
*
* preset name: SSD1306
* data block size: 8 bit(s), uint8_t
* RLE compression enabled: no
* conversion type: Monochrome, Diffuse Dither 128
* bits per pixel: 1
*
* preprocess:
*  main scan direction: left_to_right
*  line scan direction: forward
*  inverse: no
*******************************************************************************/

#include <stdint.h>



#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x2d[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00
};
static const ImageChar_t Pecita_36_0x2d = { image_data_Pecita_36_0x2d,
    12};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x30[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xdc, 0x1e, 0x0e, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x0e, 0x1e, 0x3c, 0xf8, 0xf0, 0x80, 0xf8, 0xfe, 0xff, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xf8, 0xff, 0x3f, 0x0f, 0x00, 0x03, 0x0f, 0x0f, 0x1c, 0x1c, 0x38, 0x38, 0x38, 0x38, 0x38, 0x1c, 0x1c, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00
};
static const ImageChar_t Pecita_36_0x30 = { image_data_Pecita_36_0x30,
    21};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x31[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf8, 0xfe, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0x7c, 0x3e, 0x1f, 0x07, 0x03, 0xff, 0xff, 0xff, 0x00, 0x10, 0x38, 0x3c, 0x1e, 0x0f, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0x00
};
static const ImageChar_t Pecita_36_0x31 = { image_data_Pecita_36_0x31,
    17};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x32[] = {
    0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x3f, 0x1f, 0x03, 0x01, 0xc1, 0xf1, 0xff, 0x7f, 0x1e, 0x00, 0x00, 0x00, 0x80, 0xe0, 0xf0, 0x7c, 0x3e, 0x0f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x3f, 0x3f, 0x71, 0x70, 0x70, 0x60, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0x40
};
static const ImageChar_t Pecita_36_0x32 = { image_data_Pecita_36_0x32,
    14};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x33[] = {
    0x00, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x81, 0xc1, 0xe1, 0xf3, 0x7f, 0x3f, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x1f, 0x1f, 0x39, 0x78, 0x70, 0xe0, 0xe0, 0x80, 0x40, 0xe0, 0xe0, 0xe0, 0xe0, 0x70, 0x70, 0x70, 0x78, 0x38, 0x3c, 0x1e, 0x0f, 0x0f, 0x03
};
static const ImageChar_t Pecita_36_0x33 = { image_data_Pecita_36_0x33,
    15};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x34[] = {
    0x00, 0x00, 0x80, 0xc0, 0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xfe, 0xff, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1f, 0x3f, 0x78, 0x70, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0x70, 0xf0, 0xf8, 0xf8, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0x60
};
static const ImageChar_t Pecita_36_0x34 = { image_data_Pecita_36_0x34,
    15};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x35[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x3e, 0xff, 0xff, 0xe0, 0x80, 0x06, 0x07, 0x07, 0x07, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x3e, 0x7c, 0xf8, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x70, 0x70, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0x70, 0x78, 0x3f, 0x1f, 0x07, 0x00, 0x00, 0x00, 0x00
};
static const ImageChar_t Pecita_36_0x35 = { image_data_Pecita_36_0x35,
    19};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x36[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xe0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0x78, 0x3c, 0x1e, 0x0f, 0x07, 0x03, 0x03, 0x01, 0x00, 0x00, 0x80, 0xf0, 0xfc, 0x3f, 0x0f, 0x07, 0x31, 0x38, 0x38, 0x1c, 0x1c, 0x1c, 0x1c, 0x38, 0xf8, 0xf0, 0xe0, 0x00, 0x0f, 0x3f, 0x7f, 0x70, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0x70, 0x70, 0x78, 0x3c, 0x3e, 0x1f, 0x07, 0x03, 0x00
};
static const ImageChar_t Pecita_36_0x36 = { image_data_Pecita_36_0x36,
    18};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x37[] = {
    0x00, 0x00, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x3f, 0x3f, 0x33, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0xff, 0xfe, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0xe0, 0x60, 0x70, 0x70, 0x70, 0xf0, 0xff, 0x7f, 0x39, 0x38, 0x38, 0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfe, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const ImageChar_t Pecita_36_0x37 = { image_data_Pecita_36_0x37,
    19};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x38[] = {
    0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0xf0, 0xf8, 0xfc, 0x1d, 0x03, 0x03, 0x01, 0x01, 0x01, 0x83, 0xc3, 0xff, 0xfe, 0x3c, 0x00, 0x83, 0xc7, 0xff, 0x7e, 0x3c, 0x7c, 0xfe, 0xcf, 0x87, 0x03, 0x01, 0x00, 0x00, 0x0f, 0x3f, 0x7f, 0x71, 0xe0, 0xe0, 0xe0, 0xe1, 0xe3, 0x7f, 0x7f, 0x1e, 0x00, 0x00
};
static const ImageChar_t Pecita_36_0x38 = { image_data_Pecita_36_0x38,
    14};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0x39[] = {
    0x00, 0x00, 0x00, 0x80, 0x80, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfe, 0xff, 0x8f, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x83, 0xdc, 0xfc, 0xf8, 0xe0, 0x00, 0x03, 0x07, 0x07, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x07, 0xe3, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xe0, 0xf0, 0x7c, 0x3f, 0x1f, 0x07, 0x01, 0x00
};
static const ImageChar_t Pecita_36_0x39 = { image_data_Pecita_36_0x39,
    16};
#endif

#if (0x0 == 0x0)
static const uint8_t image_data_Pecita_36_0xb0[] = {
    0x78, 0xfc, 0xfe, 0x8e, 0x82, 0x87, 0x87, 0xc7, 0xfe, 0xfe, 0x78, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const ImageChar_t Pecita_36_0xb0 = { image_data_Pecita_36_0xb0,
    11};
#endif


static const Char_t Pecita_36_array[] = {

#if (0x0 == 0x0)
  // character: '-'
  // Code:      '0x2d'
  {&Pecita_36_0x2d},
#else
  // character: '-' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '0'
  // Code:      '0x30'
  {&Pecita_36_0x30},
#else
  // character: '0' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '1'
  // Code:      '0x31'
  {&Pecita_36_0x31},
#else
  // character: '1' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '2'
  // Code:      '0x32'
  {&Pecita_36_0x32},
#else
  // character: '2' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '3'
  // Code:      '0x33'
  {&Pecita_36_0x33},
#else
  // character: '3' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '4'
  // Code:      '0x34'
  {&Pecita_36_0x34},
#else
  // character: '4' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '5'
  // Code:      '0x35'
  {&Pecita_36_0x35},
#else
  // character: '5' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '6'
  // Code:      '0x36'
  {&Pecita_36_0x36},
#else
  // character: '6' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '7'
  // Code:      '0x37'
  {&Pecita_36_0x37},
#else
  // character: '7' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '8'
  // Code:      '0x38'
  {&Pecita_36_0x38},
#else
  // character: '8' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '9'
  // Code:      '0x39'
  {&Pecita_36_0x39},
#else
  // character: '9' == ''
  {&Pecita_36_0x},
#endif

#if (0x0 == 0x0)
  // character: '°'
  // Code:      '0xb0'
  {&Pecita_36_0xb0}
#else
  // character: '°' == ''
  {&Pecita_36_0x}
#endif

};
const Font_t Pecita_36 = { 12, 0xb0, 32, Pecita_36_array };

Как видно, здесь только те символы, которые мне нужны.

Заголовочный файл для подключения из основной программы:

Спойлер: fonts.h

Код (C++):

#ifndef FONTS_H
#define FONTS_H

#include <stdint.h>

typedef struct
{
    const uint8_t*  data;
    uint8_t         width;
} ImageChar_t;

typedef struct
{
    const ImageChar_t*  image;
} Char_t;

typedef struct
{
    uint16_t        length;
    uint8_t         FirstChar;
    uint8_t         height;
    const Char_t*   chars;
} Font_t;

uint8_t SetFont (const Font_t* f);
const Char_t* Get_Char_Data (char c);

#endif

 

Исходник с функциями для извлечения символов и выбора шрифта (в моём случае шрифт всего один):

Спойлер: fonts.c

Код (C++):

#include "Fonts.h"
#include "source/Pecita_36.h"

const Font_t    *font = 0;

uint8_t SetFont (const Font_t* f)
{
    if (f == 0)
    {
        return 0;
    }
    else
        {
            font = f;

            return font->height;
        }
   
}

const Char_t* Get_Char_Data (char c)
{
    const Char_t* char_p;

    if (font == 0)
    {
        return 0;
    }
    else
        {
            switch (c)
                {

                    case '.':
                        char_p = font->chars;
                        break;
                       
                    case 0xb0:
                        char_p = font->chars + 11;
                        break;

                    case '%':
                        char_p = font->chars;
                        break;

                    case '-':
                        char_p = font->chars + 1;
                        break;

                    default:
                        char_p = font->chars + (c - 47);
                        break;
                }

    return char_p;
        }
   
}

Функция отрисовки:

Код (C++):

Position_t SSD1306_gLIB_DrawString (uint8_t column_start, uint8_t page_start, uint8_t gap, char* string, uint8_t countchars, const Font_t* font)
{
    const Char_t* tempchar;

    Position_t pos;

    uint8_t x1, y1, x2, y2;
    uint8_t height;

    height = SetFont(font);

    if (height)
    {
        x1 = column_start;
        y1 = page_start;
        y2 = y1 + (height >> 3) - 1;

        while (countchars && *string)
        {
            countchars--;

            tempchar = Get_Char_Data(*string);

            x2 = x1 + tempchar->image->width - 1;

            SSD1306_gLIB_DrawBitmap(x1, y1, x2, y2, tempchar->image->data);

            x1 = x2 + gap;

            string++;
        }

        pos.x = x1;
        pos.y = y2;      
    }  

    return pos;
}

В этой функции есть расчёт знакоместа следующего символа, но нет расчёта выхода строки за пределы экрана. Это уже самостоятельно)

 

LCD Image Converter не умеет из коробки формировать строку данных под развёртку SSD1306 (байт данных располагается вертикально сверху вниз, строка формируется из массива таких байт). Для этого ей надо скормить такой скрипт:

Код (C++):

Алгоритм для LCD IMAGE CONVERTER

/*
* left to right
* forward
* bands
* by parovoZZ
*/

var bandY = 0;
var y =  image.bandSize - 1;

do {
    for (var x = 0; x < image.width; x++) {
      while (y >= 0) {
            image.addPoint(x, bandY + y);
            y--;
            }
       y =  image.bandSize - 1;
    }
    bandY += image.bandSize;
} while (bandY < image.height);

 

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