Griechische Buchstaben @ Pixeldisplay

[tibaecgn]

Hallo,
ich lese hier gerne mit und habe auch schon häufig Lösungen gefunden, vielen Dank dafür.
bei meinem aktuellen Problem habe ich aber noch keinen Ansatz finden können, vielleicht finde ich hier die Lösung:

Auf einem ws2812b Display will ich mit einem arduino uno Text anzeigen lassen, das klappte bisher auch immer. Dazu benutze ich den matrixtext aus der Adafruit Neomatrix library.

Wie kann ich dort griechischen Text (oder kyrillische Buchstaben oder gar arabische Zeichen) anzeigen lassen? Gibt es eine library, die ich dafür einbinden kann? Ich suche schon seit längerem und habe noch nicht einmal einen Ansatz.

Für einen Hinweis wäre ich dankbar!

// Adafruit_NeoMatrix example for single NeoPixel Shield.
// Scrolls 'Howdy' across the matrix in a portrait (vertical) orientation.

#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h> 
#ifndef PSTR
#define PSTR // Make Arduino Due happy
#endif

#define PIN 6

// MATRIX DECLARATION:
// Parameter 1 = width of NeoPixel matrix
// Parameter 2 = height of matrix
// Parameter 3 = pin number (most are valid)
// Parameter 4 = matrix layout flags, add together as needed:
//   NEO_MATRIX_TOP, NEO_MATRIX_BOTTOM, NEO_MATRIX_LEFT, NEO_MATRIX_RIGHT:
//     Position of the FIRST LED in the matrix; pick two, e.g.
//     NEO_MATRIX_TOP + NEO_MATRIX_LEFT for the top-left corner.
//   NEO_MATRIX_ROWS, NEO_MATRIX_COLUMNS: LEDs are arranged in horizontal
//     rows or in vertical columns, respectively; pick one or the other.
//   NEO_MATRIX_PROGRESSIVE, NEO_MATRIX_ZIGZAG: all rows/columns proceed
//     in the same order, or alternate lines reverse direction; pick one.
//   See example below for these values in action.
// Parameter 5 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_GRBW    Pixels are wired for GRBW bitstream (RGB+W NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)


// Example for NeoPixel Shield.  In this application we'd like to use it
// as a 5x8 tall matrix, with the USB port positioned at the top of the
// Arduino.  When held that way, the first pixel is at the top right, and
// lines are arranged in columns, progressive order.  The shield uses
// 800 KHz (v2) pixels that expect GRB color data.
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 8, PIN,
  NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);

const uint16_t colors[] = {
  matrix.Color(255, 255, 255), matrix.Color(0, 255, 0), matrix.Color(0, 0, 255) };

void setup() {
  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(40);
  matrix.setTextColor(colors[0]);
}

int x    = matrix.width();
int pass = 0;

void loop() {
  matrix.fillScreen(0);
  matrix.setCursor(x, 0);
  matrix.print(" Howdy");
  if(--x < -300) {
    x = matrix.width();
    if(++pass >= 3) pass = 0;
    matrix.setTextColor(colors[pass]);
  }
  matrix.show();
  delay(100);
}

[Tommy56]

In der Lib Adafruit_GFX gibt es einen Ordner fontconvert. In dem ist eine Datei fontconvert_win.md (das ist eine Textdatei). In dieser ist beschrieben, wie man FreeType-Fonts für die Nutzung mit Adafruit konvertieren kann.
Die Fontquellen für die diversen Alphabete wirst Du im Netz suchen müssen, wenn da keine dabei sind. Für griechische Fonts liefert Google über 100 Quellen.

Gruß Tommy

[tibaecgn]

Danke Tommy, das ist der Ansatz, den ich gesucht habe!
Scheint komplizierter zu sein als ich dachte – ich schaue mir das mal an...

[agmue]

@tibaecgn

Scheint komplizierter zu sein als ich dachte –

Leider muß ich @Tommy56 widersprechen, denn ich sehe fontconvert als Sackgasse:

8-bit fonts (supporting symbols and/or international characters) are not yet provided but may come later. Quelle: Using Fonts

Oder?

@tibaecgn: Wenn Du hier schon länger mitliest, kennst Du ja unsere Diskussionen

Möchtest Du ein einzelnes griechisches Zeichen nutzen oder das komplette Alphabet?

Bei einzelnen Zeichen könntest Du glcdfont.c manipulieren, das ist die von Dir genutzte Fontdefinition. Von Dir nicht genutzte Zeichen könntest Du umdefinieren.

Original sichern und die von mir umformatierte Datei verwenden:

// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
// See gfxfont.h for newer custom bitmap font info.

#ifndef FONT5X7_H
#define FONT5X7_H

#ifdef __AVR__
#include <avr/io.h>
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
// PROGMEM is defefind for T4 to place data in specific memory section
#undef PROGMEM
#define PROGMEM
#else
#define PROGMEM
#endif

// 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, 
0x40, 0x7F, 0x05, 0x25, 0x3F, 
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 
0x7F, 0x3E, 0x1C, 0x1C, 0x08, 
0x08, 0x1C, 0x1C, 0x3E, 0x7F, 
0x14, 0x22, 0x7F, 0x22, 0x14, 
0x5F, 0x5F, 0x00, 0x5F, 0x5F, 
0x06, 0x09, 0x7F, 0x01, 0x7F, 
0x00, 0x66, 0x89, 0x95, 0x6A, 
0x60, 0x60, 0x60, 0x60, 0x60, 
0x94, 0xA2, 0xFF, 0xA2, 0x94, 
0x08, 0x04, 0x7E, 0x04, 0x08, 
0x10, 0x20, 0x7E, 0x20, 0x10, 
0x08, 0x08, 0x2A, 0x1C, 0x08, 
0x08, 0x1C, 0x2A, 0x08, 0x08, 
0x1E, 0x10, 0x10, 0x10, 0x10, 
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 
0x30, 0x38, 0x3E, 0x38, 0x30, 
0x06, 0x0E, 0x3E, 0x0E, 0x06, 
0x00, 0x00, 0x00, 0x00, 0x00, // ' '
0x00, 0x00, 0x5F, 0x00, 0x00, 
0x00, 0x07, 0x00, 0x07, 0x00, 
0x14, 0x7F, 0x14, 0x7F, 0x14, 
0x24, 0x2A, 0x7F, 0x2A, 0x12, 
0x23, 0x13, 0x08, 0x64, 0x62, 
0x36, 0x49, 0x56, 0x20, 0x50, 
0x00, 0x08, 0x07, 0x03, 0x00, 
0x00, 0x1C, 0x22, 0x41, 0x00, 
0x00, 0x41, 0x22, 0x1C, 0x00, 
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 
0x08, 0x08, 0x3E, 0x08, 0x08, 
0x00, 0x80, 0x70, 0x30, 0x00, 
0x08, 0x08, 0x08, 0x08, 0x08, 
0x00, 0x00, 0x60, 0x60, 0x00, 
0x20, 0x10, 0x08, 0x04, 0x02, 
0x3E, 0x51, 0x49, 0x45, 0x3E, // '0'
0x00, 0x42, 0x7F, 0x40, 0x00, 
0x72, 0x49, 0x49, 0x49, 0x46, 
0x21, 0x41, 0x49, 0x4D, 0x33, 
0x18, 0x14, 0x12, 0x7F, 0x10, 
0x27, 0x45, 0x45, 0x45, 0x39, 
0x3C, 0x4A, 0x49, 0x49, 0x31, 
0x41, 0x21, 0x11, 0x09, 0x07, 
0x36, 0x49, 0x49, 0x49, 0x36, 
0x46, 0x49, 0x49, 0x29, 0x1E, 
0x00, 0x00, 0x14, 0x00, 0x00, 
0x00, 0x40, 0x34, 0x00, 0x00, 
0x00, 0x08, 0x14, 0x22, 0x41, 
0x14, 0x14, 0x14, 0x14, 0x14, 
0x00, 0x41, 0x22, 0x14, 0x08, 
0x02, 0x01, 0x59, 0x09, 0x06, 
0x3E, 0x41, 0x5D, 0x59, 0x4E, 
0x7C, 0x12, 0x11, 0x12, 0x7C, // 'A'
0x7F, 0x49, 0x49, 0x49, 0x36, 
0x3E, 0x41, 0x41, 0x41, 0x22, 
0x7F, 0x41, 0x41, 0x41, 0x3E, 
0x7F, 0x49, 0x49, 0x49, 0x41, 
0x7F, 0x09, 0x09, 0x09, 0x01, 
0x3E, 0x41, 0x41, 0x51, 0x73, 
0x7F, 0x08, 0x08, 0x08, 0x7F, 
0x00, 0x41, 0x7F, 0x41, 0x00, 
0x20, 0x40, 0x41, 0x3F, 0x01, 
0x7F, 0x08, 0x14, 0x22, 0x41, 
0x7F, 0x40, 0x40, 0x40, 0x40, 
0x7F, 0x02, 0x1C, 0x02, 0x7F, 
0x7F, 0x04, 0x08, 0x10, 0x7F, 
0x3E, 0x41, 0x41, 0x41, 0x3E, 
0x7F, 0x09, 0x09, 0x09, 0x06, 
0x3E, 0x41, 0x51, 0x21, 0x5E, 
0x7F, 0x09, 0x19, 0x29, 0x46, 
0x26, 0x49, 0x49, 0x49, 0x32, 
0x03, 0x01, 0x7F, 0x01, 0x03, 
0x3F, 0x40, 0x40, 0x40, 0x3F, 
0x1F, 0x20, 0x40, 0x20, 0x1F, 
0x3F, 0x40, 0x38, 0x40, 0x3F, 
0x63, 0x14, 0x08, 0x14, 0x63, 
0x03, 0x04, 0x78, 0x04, 0x03, 
0x61, 0x59, 0x49, 0x4D, 0x43, // 'Z'
0x00, 0x7F, 0x41, 0x41, 0x41, 
0x02, 0x04, 0x08, 0x10, 0x20, 
0x00, 0x41, 0x41, 0x41, 0x7F, 
0x04, 0x02, 0x01, 0x02, 0x04, 
0x40, 0x40, 0x40, 0x40, 0x40, 
0x00, 0x03, 0x07, 0x08, 0x00, 
0x20, 0x54, 0x54, 0x78, 0x40, // 'a'
0x7F, 0x28, 0x44, 0x44, 0x38, 
0x38, 0x44, 0x44, 0x44, 0x28, 
0x38, 0x44, 0x44, 0x28, 0x7F, 
0x38, 0x54, 0x54, 0x54, 0x18, 
0x00, 0x08, 0x7E, 0x09, 0x02, 
0x18, 0xA4, 0xA4, 0x9C, 0x78, 
0x7F, 0x08, 0x04, 0x04, 0x78, 
0x00, 0x44, 0x7D, 0x40, 0x00, 
0x20, 0x40, 0x40, 0x3D, 0x00, 
0x7F, 0x10, 0x28, 0x44, 0x00, 
0x00, 0x41, 0x7F, 0x40, 0x00, 
0x7C, 0x04, 0x78, 0x04, 0x78, 
0x7C, 0x08, 0x04, 0x04, 0x78, 
0x38, 0x44, 0x44, 0x44, 0x38, 
0xFC, 0x18, 0x24, 0x24, 0x18, 
0x18, 0x24, 0x24, 0x18, 0xFC, 
0x7C, 0x08, 0x04, 0x04, 0x08, 
0x48, 0x54, 0x54, 0x54, 0x24, 
0x04, 0x04, 0x3F, 0x44, 0x24, 
0x3C, 0x40, 0x40, 0x20, 0x7C, 
0x1C, 0x20, 0x40, 0x20, 0x1C, 
0x3C, 0x40, 0x30, 0x40, 0x3C, 
0x44, 0x28, 0x10, 0x28, 0x44, 
0x4C, 0x90, 0x90, 0x90, 0x7C, 
0x44, 0x64, 0x54, 0x4C, 0x44, // 'z'
0x00, 0x08, 0x36, 0x41, 0x00, 
0x00, 0x00, 0x77, 0x00, 0x00, 
0x00, 0x41, 0x36, 0x08, 0x00, 
0x02, 0x01, 0x02, 0x04, 0x02, 
0x3C, 0x26, 0x23, 0x26, 0x3C, 
0x1E, 0xA1, 0xA1, 0x61, 0x12, 
0x3A, 0x40, 0x40, 0x20, 0x7A, 
0x38, 0x54, 0x54, 0x55, 0x59, 
0x21, 0x55, 0x55, 0x79, 0x41, 
0x22, 0x54, 0x54, 0x78, 0x42, 
0x21, 0x55, 0x54, 0x78, 0x40, 
0x20, 0x54, 0x55, 0x79, 0x40, 
0x0C, 0x1E, 0x52, 0x72, 0x12, 
0x39, 0x55, 0x55, 0x55, 0x59, 
0x39, 0x54, 0x54, 0x54, 0x59, 
0x39, 0x55, 0x54, 0x54, 0x58, 
0x00, 0x00, 0x45, 0x7C, 0x41, 
0x00, 0x02, 0x45, 0x7D, 0x42, 
0x00, 0x01, 0x45, 0x7C, 0x40, 
0x7D, 0x12, 0x11, 0x12, 0x7D, 
0xF0, 0x28, 0x25, 0x28, 0xF0, 
0x7C, 0x54, 0x55, 0x45, 0x00, 
0x20, 0x54, 0x54, 0x7C, 0x54, 
0x7C, 0x0A, 0x09, 0x7F, 0x49, 
0x32, 0x49, 0x49, 0x49, 0x32, 
0x3A, 0x44, 0x44, 0x44, 0x3A, 
0x32, 0x4A, 0x48, 0x48, 0x30, 
0x3A, 0x41, 0x41, 0x21, 0x7A, 
0x3A, 0x42, 0x40, 0x20, 0x78, 
0x00, 0x9D, 0xA0, 0xA0, 0x7D, 
0x3D, 0x42, 0x42, 0x42, 0x3D, 
0x3D, 0x40, 0x40, 0x40, 0x3D, 
0x3C, 0x24, 0xFF, 0x24, 0x24, 
0x48, 0x7E, 0x49, 0x43, 0x66, 
0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 
0xFF, 0x09, 0x29, 0xF6, 0x20, 
0xC0, 0x88, 0x7E, 0x09, 0x03, 
0x20, 0x54, 0x54, 0x79, 0x41, 
0x00, 0x00, 0x44, 0x7D, 0x41, 
0x30, 0x48, 0x48, 0x4A, 0x32, 
0x38, 0x40, 0x40, 0x22, 0x7A, 
0x00, 0x7A, 0x0A, 0x0A, 0x72, 
0x7D, 0x0D, 0x19, 0x31, 0x7D, 
0x26, 0x29, 0x29, 0x2F, 0x28, 
0x26, 0x29, 0x29, 0x29, 0x26, 
0x30, 0x48, 0x4D, 0x40, 0x20, 
0x38, 0x08, 0x08, 0x08, 0x08, 
0x08, 0x08, 0x08, 0x08, 0x38, 
0x2F, 0x10, 0xC8, 0xAC, 0xBA, 
0x2F, 0x10, 0x28, 0x34, 0xFA, 
0x00, 0x00, 0x7B, 0x00, 0x00, 
0x08, 0x14, 0x2A, 0x14, 0x22, 
0x22, 0x14, 0x2A, 0x14, 0x08, 
0x55, 0x00, 0x55, 0x00, 0x55, 
0xAA, 0x55, 0xAA, 0x55, 0xAA, 
0xFF, 0x55, 0xFF, 0x55, 0xFF, 
0x00, 0x00, 0x00, 0xFF, 0x00, 
0x10, 0x10, 0x10, 0xFF, 0x00, 
0x14, 0x14, 0x14, 0xFF, 0x00, 
0x10, 0x10, 0xFF, 0x00, 0xFF, 
0x10, 0x10, 0xF0, 0x10, 0xF0, 
0x14, 0x14, 0x14, 0xFC, 0x00, 
0x14, 0x14, 0xF7, 0x00, 0xFF, 
0x00, 0x00, 0xFF, 0x00, 0xFF, 
0x14, 0x14, 0xF4, 0x04, 0xFC, 
0x14, 0x14, 0x17, 0x10, 0x1F, 
0x10, 0x10, 0x1F, 0x10, 0x1F, 
0x14, 0x14, 0x14, 0x1F, 0x00, 
0x10, 0x10, 0x10, 0xF0, 0x00, 
0x00, 0x00, 0x00, 0x1F, 0x10, 
0x10, 0x10, 0x10, 0x1F, 0x10, 
0x10, 0x10, 0x10, 0xF0, 0x10, 
0x00, 0x00, 0x00, 0xFF, 0x10, 
0x10, 0x10, 0x10, 0x10, 0x10, 
0x10, 0x10, 0x10, 0xFF, 0x10, 
0x00, 0x00, 0x00, 0xFF, 0x14, 
0x00, 0x00, 0xFF, 0x00, 0xFF, 
0x00, 0x00, 0x1F, 0x10, 0x17, 
0x00, 0x00, 0xFC, 0x04, 0xF4, 
0x14, 0x14, 0x17, 0x10, 0x17, 
0x14, 0x14, 0xF4, 0x04, 0xF4, 
0x00, 0x00, 0xFF, 0x00, 0xF7, 
0x14, 0x14, 0x14, 0x14, 0x14, 
0x14, 0x14, 0xF7, 0x00, 0xF7, 
0x14, 0x14, 0x14, 0x17, 0x14, 
0x10, 0x10, 0x1F, 0x10, 0x1F, 
0x14, 0x14, 0x14, 0xF4, 0x14, 
0x10, 0x10, 0xF0, 0x10, 0xF0, 
0x00, 0x00, 0x1F, 0x10, 0x1F, 
0x00, 0x00, 0x00, 0x1F, 0x14, 
0x00, 0x00, 0x00, 0xFC, 0x14, 
0x00, 0x00, 0xF0, 0x10, 0xF0, 
0x10, 0x10, 0xFF, 0x10, 0xFF, 
0x14, 0x14, 0x14, 0xFF, 0x14, 
0x10, 0x10, 0x10, 0x1F, 0x00, 
0x00, 0x00, 0x00, 0xF0, 0x10, 
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 
0xFF, 0xFF, 0xFF, 0x00, 0x00, 
0x00, 0x00, 0x00, 0xFF, 0xFF, 
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 
0x38, 0x44, 0x44, 0x38, 0x44, 
0xFC, 0x4A, 0x4A, 0x4A, 0x34, 
0x7E, 0x02, 0x02, 0x06, 0x06, 
0x02, 0x7E, 0x02, 0x7E, 0x02, 
0x63, 0x55, 0x49, 0x41, 0x63, 
0x38, 0x44, 0x44, 0x3C, 0x04, 
0x40, 0x7E, 0x20, 0x1E, 0x20, 
0x06, 0x02, 0x7E, 0x02, 0x02, 
0x99, 0xA5, 0xE7, 0xA5, 0x99, 
0x1C, 0x2A, 0x49, 0x2A, 0x1C, 
0x4C, 0x72, 0x01, 0x72, 0x4C, 
0x30, 0x4A, 0x4D, 0x4D, 0x30, 
0x30, 0x48, 0x78, 0x48, 0x30, 
0xBC, 0x62, 0x5A, 0x46, 0x3D, 
0x3E, 0x49, 0x49, 0x49, 0x00, 
0x7E, 0x01, 0x01, 0x01, 0x7E, 
0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 
0x44, 0x44, 0x5F, 0x44, 0x44, 
0x40, 0x51, 0x4A, 0x44, 0x40, 
0x40, 0x44, 0x4A, 0x51, 0x40, 
0x00, 0x00, 0xFF, 0x01, 0x03, 
0xE0, 0x80, 0xFF, 0x00, 0x00, 
0x08, 0x08, 0x6B, 0x6B, 0x08, 
0x36, 0x12, 0x36, 0x24, 0x36, 
0x06, 0x0F, 0x09, 0x0F, 0x06, 
0x00, 0x00, 0x18, 0x18, 0x00, 
0x00, 0x00, 0x10, 0x10, 0x00, 
0x30, 0x40, 0xFF, 0x01, 0x01, 
0x00, 0x1F, 0x01, 0x01, 0x1E, 
0x00, 0x19, 0x1D, 0x17, 0x12, 
0x00, 0x3C, 0x3C, 0x3C, 0x3C, 
0x00, 0x00, 0x00, 0x00, 0x00 // #255 NBSP
};

// allow clean compilation with [-Wunused-const-variable=] and [-Wall]
static inline void avoid_unused_const_variable_compiler_warning(void) {
  (void)font;
}

#endif // FONT5X7_H

Ein Zeichen je Zeile, die Kommentare sollen Dir Anhaltspunkte innerhalb der ASCII-Tabelle geben.

Noch eine Schwierigkeit: Arduino verwendet UTF-8, nicht ASCII.

[Tommy56]

@agmue

Leider muß ich @Tommy56 widersprechen, denn ich sehe fontconvert als Sackgasse:

Da kannst Du Recht haben, wenn er aber den Bereich von > Blank bis <= ~ komplett mit (evtl. einem Teil) des griechischen Alpphabetes austauschen will, dürfte das möglich sein. Ich habe es nicht getestet, da mir ein passendes Display fehlt.

Gruß Tommy

[agmue]

Ja, da stimme ich Dir zu, hängt von der Anwendung ab.

[Tommy56]

Und über diese wissen wir, wie leider so oft, nichts.

Gruß Tommy

[tibaecgn]

Vielen Dank agmue, da hast du mir wahrscheinlich viel ausprobieren erspart...

@agmue

Ja, da stimme ich Dir zu, hängt von der Anwendung ab.

Es geht um eine Ausstellung, in der u.a. Zitate auf griechisch (und evtl. kyrillisch oder gar arabisch) auf den Matrix-Displays zu lesen sein sollen. Dazu bräuchte es schon das ganze Alphabet. In meiner Naivität dachte ich, es ginge mit einer library o.ä.

Ich schaue, ob ich agmues Vorschlag umsetzen kann...

Zum Verständnis: Ardunio verwendet ja UTF, da sollte es doch möglich sein, non-latin Zeichen "einfach" darzustellen, oder?

Vielen Dank auf jeden Fall für euren schnellen Input!

[Tommy56]

@tibaecgn

Zum Verständnis: Ardunio verwendet ja UTF, da sollte es doch möglich sein, non-latin Zeichen "einfach" darzustellen, oder?

Die Lib für das Matrix-Display verwendet aber nur ASCII 0x20 bis 0x7f und hat überhaupt keine Ahnung, was UTF ist.
Das ist kein Problem des Arduino, sondern der Adafruit-Libs.

Gruß Tommy

[tibaecgn]

Ok, danke, das wusste ich nicht.
Wüsstest du eine andere library, die den Einsatz von non-latin Zeichen möglich macht?

[wno158]

@tibaecgn

Wüsstest du eine andere library, die den Einsatz von non-latin Zeichen möglich macht?

Das leider nicht, aber ich werfe mal als (vielleicht mögliche) Alternative ein Nextion-Display in den Ring. Da kannst Du mit dem zugehörigen Editor auch Fonts erzeugen, die direkt UTF-8 kodierten Text anzeigen können.

[my_xy_projekt]

@tibaecgn

Wüsstest du eine andere library, die den Einsatz von non-latin Zeichen möglich macht?

Nur als Gedankengang - ohne jegliche Kompatibilität mit Deiner Fragestellung!

Du wirst irgendwie eine Übersetzungstabelle bauen müssen....

[tibaecgn]

@wno158

Das leider nicht, aber ich werfe mal als (vielleicht mögliche) Alternative ein Nextion-Display in den Ring.

Oha, danke, schaue ich mir an...

@my_xy_projekt

Du wirst irgendwie eine Übersetzungstabelle bauen müssen....

Ja, in diese Richtungen gehen meine Gedanken auch...

Trotzdem erscheint mir das alles sehr umständlich und von Hand gestrickt.
Ich werde diese Frage im internatonalen Teil des Forums stellen, das betrifft doch jeden, der im türkischen, russischen, griechischen etc. Sprachraum was mit Schrift und Arduino machen will... I’ll let you know...

[noiasca]

imho machen sich die english-native speaker wenig gedanken über mehr-Byte Zeichen in UTF-8. Aber probiert mal.

meines Erachtens ist der Weg aber klar:
die Adafruit_GFX erbt von print.
Die Ausgabe erfolgt somit über Adafruit_GFX::write
diese adapierst du, dass jedes hereinkommende Zeichen analysiert wird ob das Zeichen ausgeben werden soll oder es sich um ein Startbyte mit Folgebytes handelt.
Ist es ein Startbyte mit Folgebyte speicherst dir das Zeichen in einem Puffer.
Auf Grund des Startbytes weist du wie viele Folgebytes kommen.
Erst mit dem letzten Folgebyte siehst in deiner Zeichensatztabelle nach welches Zeichen auszugeben ist.

Ich habe das mal für LCD's gemacht. Hier musste ich auf die verschieden LCD-Zeichensätze mappen .
[url]https://werner.rothschopf.net/202003_arduino_liquid_crystal_umlaute.htm[/url]

In meiner Lib ist es nur so, dass ich in der write() Funktion mit einem Function Pointer einen converter aufrufe der zurück gibt, ob das Zeichen gespeichert, oder (mit eventuellen vorherigen Zeichen) ausgegeben werden soll.

[agmue]

Hast Du Erfahrung mit U8g2_for_Adafruit_GFX? U8g2 unterstützt Unicode.

Das hier kompiliert für den Mega2560, tut aber bei mir nichts:

/*

  Demonstrates how to connect U8g2_for_Adafruit_GFX to Adafruit SSD1306 library.

  U8g2_for_Adafruit_GFX:
    - Use U8g2 fonts with Adafruit GFX
    - Support for UTF-8 in print statement
    - 90, 180 and 270 degree text direction
  
  List of all U8g2 fonts: https://github.com/olikraus/u8g2/wiki/fntlistall
      
*/
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h> 
#include <U8g2_for_Adafruit_GFX.h>
#define PIN 6
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(16, 8, PIN,
  NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);
U8G2_FOR_ADAFRUIT_GFX u8g2_for_adafruit_gfx;

void setup() {
  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(40);
  matrix.setTextColor(matrix.Color(255, 255, 255));
  u8g2_for_adafruit_gfx.begin(matrix);                 // connect u8g2 procedures to Adafruit GFX
}

void loop() {  
  matrix.fillScreen(0);
  u8g2_for_adafruit_gfx.setFontDirection(0);            // left to right (this is default)
  
  u8g2_for_adafruit_gfx.setFont(u8g2_font_t0_11_tf);  // extended font
  u8g2_for_adafruit_gfx.setFontMode(1);                 // use u8g2 transparent mode (this is default)
  u8g2_for_adafruit_gfx.setCursor(0,8);                // start writing at this position
  u8g2_for_adafruit_gfx.print("AB");            // UTF-8 string: "<" 550 448 664 ">"
  matrix.show();
  delay(2000);
} 

Die Bibliothek unterstützt chinesische Zeichen, siehe Shennong.ino, dann sollten andere Schriften auch darstellbar sein.

Möglicherweise weiß auch @olikraus einen Rat.

[olikraus]

Am Besten immer die Buchstaben des Fonts auf der u8g2 Webseite prüfen, also in diesem Falle hier: fntgrpttyp0 · olikraus/u8g2 Wiki · GitHub

In deinem Fall wäre wohl der u8g2_font_t0_11_te Font der richtige.

Oliver

[agmue]

Ich habe zunächst die hinsichtlich Fontwahl wohl unkritischen Buchstaben "AB" probiert, allerdings bleiben die Pixel dunkel. Ich vermute daher ein tiefliegenderes Problem im Zusammenspiel von U8g2_for_Adafruit_GFX und Adafruit_NeoPixel bzw. Adafruit_NeoMatrix. Da ich kein Beispiel finden konnte, habe ich mir selbst was zusammengestellt.

Was habe ich falsch gemacht, weißt Du Rat?

[olikraus]

Es könnte sein, dass noch die Vordergrundfarbe fehlt:

u8g2_for_adafruit_gfx.setForegroundColor(RED);

[agmue]

@olikraus

Vordergrundfarbe

Danke, es leuchten LEDs!

Die Vordergrundfarbe setForegroundColor möchte 16 Bit vermutlich 5/6/5, gibt es auch eine Variante für 24 Bit der LED-Streifen?

Ich fände ein Beispiel in Deiner Bibliothek, die die Dinge etwas europäischer betrachtet, hilfreich. Du darfst Dich gerne bei mir bedienen, meine Erwähnung ist wegen meines geringen Anteils nicht notwendig.

@tibaecgn

Trotzdem erscheint mir das alles sehr umständlich und von Hand gestrickt.

Die Kombination aus U8g2 und Adafruit_NeoMatrix scheint mir vielversprechend, da U8g2 viele Fonts und auch UTF-8 unterstützt.

Zeigt dieses Programm bei Dir etwas Sinnvolles an?

#include <Wire.h>                //fuer I2C Kommunikation  
#include <Adafruit_SSD1306.h>

#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h> 
#include <U8g2_for_Adafruit_GFX.h>
#define PIN 6
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 8, PIN,
  NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);
U8G2_FOR_ADAFRUIT_GFX neopixel_gfx;

void setup() {
  matrix.begin();
  neopixel_gfx.begin(matrix);                 // connect u8g2 procedures to Adafruit GFX
}

void loop() {  
  matrix.fillScreen(0);
  neopixel_gfx.setFontDirection(0);            // left to right (this is default)
  neopixel_gfx.setForegroundColor(0x001F);     // Rot 0xF800, Grün 0x07E0, Blau 0x001F, Weiß 0xFFFF
  neopixel_gfx.setFont(u8g2_font_t0_11_te);    // extended font
  neopixel_gfx.setFontMode(1);                 // use u8g2 transparent mode (this is default)
  neopixel_gfx.setCursor(0,8);                 // start writing at this position
  neopixel_gfx.print("A");                    // UTF-8 string
  neopixel_gfx.setForegroundColor(0xF800);     // Rot 0xF800, Grün 0x07E0, Blau 0x001F, Weiß 0xFFFF
  neopixel_gfx.print("A");                    // UTF-8 string
  matrix.show();
  delay(2000);
} 

Fontdefinitionen benötigen viel Speicher, weshalb ein Beispiel mit dem UTF-8 Font u8g2_font_t0_11_t_all für den UNO nicht mehr geeignet ist. Ich bin daher auf einen ESP32 umgestiegen. Im Programm lasse ich "Θφ" anzeigen. Als Kontrolle habe ich noch ein I²C-OLED ergänzt. So sehe ich, ob die Zeichen auch im Font enthalten sind.

#include <Wire.h>                //fuer I2C Kommunikation  
#include <Adafruit_SSD1306.h>

#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h> 
#include <U8g2_for_Adafruit_GFX.h>
#define PIN 23
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(32, 8, PIN,
  NEO_MATRIX_TOP     + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);
U8G2_FOR_ADAFRUIT_GFX neopixel_gfx;

Adafruit_SSD1306 display(128, 64);
U8G2_FOR_ADAFRUIT_GFX ssd1306_gfx;

void setup() {
  matrix.begin();
  neopixel_gfx.begin(matrix);                 // connect u8g2 procedures to Adafruit GFX

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  ssd1306_gfx.begin(display);                 // connect u8g2 procedures to Adafruit GFX
}

void loop() {  
  matrix.fillScreen(0);
  neopixel_gfx.setFontDirection(0);            // left to right (this is default)
  neopixel_gfx.setForegroundColor(0x001F);     // Rot 0xF800, Grün 0x07E0, Blau 0x001F, Weiß 0xFFFF
  neopixel_gfx.setFont(u8g2_font_t0_11_t_all); // extended font
  neopixel_gfx.setFontMode(1);                 // use u8g2 transparent mode (this is default)
  neopixel_gfx.setCursor(0,8);                 // start writing at this position
  neopixel_gfx.print("Θφ");                    // UTF-8 string
  matrix.show();

  display.clearDisplay();                               // clear the graphcis buffer  
  ssd1306_gfx.setFontDirection(0);             // left to right (this is default)
  ssd1306_gfx.setForegroundColor(WHITE);       // apply Adafruit GFX color
  ssd1306_gfx.setFont(u8g2_font_t0_11_t_all);  // extended font
  ssd1306_gfx.setFontMode(1);                  // use u8g2 transparent mode (this is default)
  ssd1306_gfx.setCursor(0,40);                 // start writing at this position
  ssd1306_gfx.print("<Θφ>");                   // UTF-8 string
  display.display();                                    // make everything visible
  delay(2000);
} 

[olikraus]

@agmue

Ich fände ein Beispiel in Deiner Bibliothek, die die Dinge etwas europäischer betrachtet, hilfreich.

Auf der Projektseite GitHub - olikraus/U8g2_for_Adafruit_GFX: Add U8g2 fonts to any Adafruit GFX based graphics library. ist das "setForegroundColor" sowohl im Beispielcode als auch unten in der (zugegebenermaßen kurzen) Referenz erklärt.

Das "color"-Argument ist das gleiche wie bei der Adafruit GFX lib: Coordinate System and Units | Adafruit GFX Graphics Library | Adafruit Learning System

U8g2_for_Adafruit_GFX ist eine Adaption der Font Render Engine meiner eigenen Graphic Lib (U8g2) an die Adafruit Lib.
Ich meine, anstelle von Adafruit_SSD1306.h und U8g2_for_Adafruit_GFX wäre wohl die Einbindung von U8g2 Speicherplatz sparender (U8g2 unterstützt SSD1306). Und für die U8g2 gibt es auch eine vollständige Anleitung (u8g2reference · olikraus/u8g2 Wiki · GitHub) mit vielen Beispielen (https://github.com/olikraus/u8g2/tree/master/sys/arduino/u8g2_page_buffer).

Grüße,
Oliver