Ich muss mich hier nun nochmal melden. Irgendwie komme ich leider nicht
weiter.
Die Lib habe ich derweilen nun erfolgreich in mein C-Projekt in Ecplise
eingebunden. Textausgaben sind auch ohne Probleme mit folgendem Aufruf
möglich:
Der Text wird so natürlich nur in der Farbe ausgegeben, die ich vorher
angegeben haben.
Doch wie geben ich denn ein buntes Zeichen aus? So wie zB in der
clock20x37
Und wo finde ich die glcd_Colors[]? Wenn ich die Farben im Font-Editor
angepasst habe, muss ich diese doch auch irgendwie meinem Projekt
mitteilen - oder?
Möchte gerne einfache farbige Symbole über das Font-Tool erstellen und
dann auf dem Display ausgeben. Doch irgendwie scheitere ich daran.
Vielleicht mache ich den Fehler ja schon beim einbinden der Schriftart:
Torsten Giese schrieb:
> Der Text wird so natürlich nur in der Farbe ausgegeben, die ich vorher> angegeben haben.
Ja, Fonts sind einfarbig, es gibt daher nur eine schwarze oder rote
Schrift, aber keine bunte. Die kleinste Einheit für die gewählte Farbe
ist ein Buchstabe. Das ist in allen Systemen so, die ich kenne, egal ob
Linux oder Windows, egal ob Postscript oder TrueType.
Bunt sind nur Icons, aber das ist ein ganz anderes Thema.
Gruss Reinhard
Aber nicht bei dieser Lib, sie unterstützt Mehrfarben-, proporionale und
fixed Pitch Font.
@Torsten:
1.) glcd.Colors[] ist das Array das du suchst. Standardmäßig sind
4-farbige Fonts eingestellt. Möchtest du mehr ändere vor dem Kompilieren
GLCD_COLORTABLE_BITS auf zb. 3 für 8 Farben, 4 für 16 Farben usw. Du
gibts damit also die Farbtiefe in Bits an, eg. BPP = Bits Per Pixel.
Das glcd.Colors[] array ist dabei Index-synchon zu deinen Farben im Font
Editor. glcd.Coors[0] ist also die 1. Farbe im FontEditor usw.
2.) erzeuge mit dem Font Editor deine Mehrfarben Fonts. Benutze dabei
immer die Farben aus der Farbauswahl lückenlos beginnend mit dem ersten
Farbeintrag. Es werden intern in den Fonts nicht die realen Farben
gespeichert sondern nur die Indizes der Farben in der Farbauswahl.
Somit musst du diese Farbauswahl als eine virtuelle Liste betrachten.
Erst zur Laufzeit gibts du also über glcd.Colors[] die real zu zechnende
Farbe zu einem Farbindex im Zeichen an. Angneommen deine glcd.Colors[]
Indizes hast du per Definition so benutzt:
glcd.Colors[0] = Hintergrundfarbe deines Fonts
glcd.Colors[1] = Schattenfarbe der Symbole, Antialiasing
glcd.Colors[2] = 1. Vordergrundfarbe
glcd.Colors[3] = 2. Vordergrundfarbe
Wenn glcd.Colors[] nun auf {white, silver, black, black} setzt so
zeichnest du eine schwarze Schrift auf weißem Hintergrund und die
Kanten/Antialiasing sind hellgrau.
Wenn du glcd.Colors[0] = TRANSPARENT setzt so zeichnest du schwarze
Schrift mit hellgrauem Antialiasing auf Trensparentem Hintergrund, dh.
du stanzt aus dem aktuellen Bild nur die schwarze Schrift aus.
Gruß Hagen
Übrigens, mit einem Doppelklick in die Farbauswahl im Fonteditor öffnet
sich ein Farbauswahl Dialog. Mit diesem kanst du für diesen Farbindex
eine andere virtuelle Farbe einstellen.
glcdSetBkColor(Farbwert) -> glcd.Colors[0] = Farbwert;
glcdSetFgColor(Farbwert) -> glcd.Colors[1] = Farbwert;
glcdSetColor(Index, Farbwert) -> glcd.Colors[Index] = Farbwert;
Farbwert = RGB(R, G, B) -> R,G,B sind Bytes
Die Definition was in deinem Font, also welcher Index in glcd.Colors[]
und damit in der Farbauswahl im Fonteditor welche Bedetung hat, also
Hintergrund, Schatten, Schriftfarben ist komplett dir überlassen. Die
obigen Makros und damit die Definiton das glcd.Colors[0] zb. Hintergrund
ist ist eine Festlegung meinerseits an die du dich nicht halten musst.
Es liegt also in deiner Verantwortung und deinem Gusto mit wievielen
Farben du im Font arbeitest, wie diese auf die Farbindizes verteilt
werden und welche reale Farben du dann zur Laufzeit in glcd.Colors[] zur
Darstellung definierst.
Übrigens gelten änliche Regeln für alle anderen Fontroutinen. zb.
glcdEllipse(x,y,Radius1,Radius2, TRANSPARENT, WHITE) würde eine nicht
gefüllte also transarante Ellipse mit weißen Rahmen zeichnen. Nutzt du
statt TRANSPARENT zb. RED so würde diese Ellipse rot gefüllt mit weißem
Rahmen sein. Setzt du Vorderundfarbe auf TRANSPARENT dann würde diese
Ellipse ohne Rahmen aber rot gefüllt gezeichnet. Gleiches gilt für
glcdFillRect() und glcdRoundRect() um abgerundete, bzw. tonnenförmige
Objekte zu zeichnen.
Noch einen Tipp von mir: möchtest du einen Fließtext zeichnen, also
einen Text mit Zeilenumruch innerhalb eines Fensterausschittes dann geht
das so
glcdSetWindow(10,10,80,80);
glcdMoveTo(10,10);
glcd.Flags.LineFeed = 1;
glcdDrawText("Mein Text mit Zeilenumbruch in einem Fensterausschnitt",
-1, 0);
Zuerst setzen wir diesen Ausschnittsbereich auf die X,Y Koordinaten
10,10 linke obere Ecke bis 80,80 rechte untere Ecke. Wir verschieben den
Cursor auf 10,10.
Dann setzen wir das LineFeed Flag damit der Text innerhalb des
Ausschnittes gezeichnet wird.
Schlußendlich zeichnen wir unseren Text. Wird in glcdDrawText() der Size
Paramater auf -1 = 0xFFFF angegeben so ermittelt das System den
Nullterminator aus deinem Text und zeichnet nur bis dahin.
Der letzte Paramater, 0 oder 1, gibt ab ob dein Text im SRAM oder FLASH
gespeichert ist. Du kannst also feste Texte auch direkt aus dem FLASH
zeichnen lassen:
glcdDrawText(PSTR("Text im FLASH Speicher"), -1, 1);
Das optimiert die Speicherverwaltung bei Textkonstanten da diese im
Grunde immer im FLASH gespeichert werden aber normalerwiese zum Startup
durch den WinAVR GCC Startup Code in den RAM kopiert würden, wenn du sie
als globale RAM Konstanten festgelegt hast.
Gruß Hagen
Über glcd.Flags.Fixed = 0 oder 1 legst du fest ob beim Zeichnen eines
Textes dieser mit fixed oder proportinal Pitch, also fester oder
variabler Zeichnebreite gezeichnet wird. Das I zb. ist schmaler als das
M. Mit fixed Pitch haben alle Zeichen die gleiche Breite von
glcd.FontWidth Breite.
Mit .fixed = 0 würde dageben das I wesentlich schmaler gezeichnet als
das M.
Mit glcd.FontCharSpace = 4 setzt du zb. den Zeichenabstand zueinander
auf 4 Pixel.
Schau dir in GLCD.h die Struktur glcdData -> globale Variable glcd
genauer an. Sie enthält alle Infos wie Colors[], Fontdaten, Cursor,
Flags usw.
Für komplexere Symbole, also Icons oder Bitmaps empfehle ich dir die
glcdDrawBitmap() Funktion und meine Bild Konverter Anwendung für PCs zu
benutzen. Gerade bei Virlfarbigen Icons/Bitmaps sind diese besser
geeignet da sich eine besser abgestimmte Komprimierung benutzen. Für
glcdDrawBitmap() sind folgende Flags von Interesse ->
GLCD_BMP_TRANSPARENT: zeichnet das Bitmap/Icon transparent. Der links
oben also 1. Pixel in der Bitmap gibt dabei an was die reale
Hintergrundfarbe des Bitmaps ist die nicht, also transparent gezeichnet
werden soll. Nach dem Zeichnen sind alle Pixel in dieser Farbe nicht
gezeichnet worden, dh. der ursprüngliche Inhalt des Displays bleibt an
diesen Stelle erhalten. Das ist sinnvoll für Symbole/Icons die ja oft
transparent sind.
GLCD_BMP_SWAPCOLORS und GLCD_BMP_USECOLORS: nutz die monochrome
Bitmaps/Icons, also Bilder mit nur 2 Farben dann sind diese Flags von
Relevanz. Solche Bilder sind also Schwarzweiß und benutzten auch eine
sehr effiziente Komprimierung. Mit GLCD_BMP_SWAPCOLORS wird die
Bedeutung von Schwarz zu Weiß vertauscht. Mit GLCD_BMP_USE_COLORS teilst
du dem System mit das er statt Schwarz/Weiß bzw. die beiden monchromen
Farben der Bitmap, es die Farben aus glcd.Colors[0] undf glcd.Colors[1]
benutzen soll. Er benutzt also beim Zeichnen der monochromen Bitmap die
Farben die du in glcd.Colors[] angegeben hast statt denjenigen die du in
der Bitmap hinterlegt hast. Zb. benutzt du glcd.Colors[0] = TRANSPARENT
und glcd.Colors[1] = BLUE. Mit glcgDrawBitmap(X, Y, @MyBitmap,
GLCD_BMP_USE_COLORS); zeichnest du also diese monochome Bitmap mit
transparentem Hintergund über den aktuellen Displayinhalt mit blauen
Muster je nachdem was du im Bitmap gezeichnet hast.
Mit dem beliegendem Window Program Convert.exe kannst du beliebige
Bilder in den Formaten, JPEG, BMP, PCX, WMF, GIF, ICO, ANI und PNG in
das Format meiner Library konvertieren und als C Header Dateien
exportieren. Mit diesem Tool kannst du auch die Bilder skalieren, deren
Farbanzahl reduzieren, sie spiegeln und rotieren.
So das sollte eigentlich alles gewesen sein was du brauchst.
Gruß Hagen
Hallo Hagen,
ein DICKES Danke Schön für die ausführliche Erklärung. Einen Teil hatte
ich mir schon aus der glcd.h an Informationen gezogen. Hatte ja auch
schon den "Verdacht" das glcd_Colors[] dafür verantwortlich ist. Nur war
meine Annahme, dass ich die Farbwerte aus dem Font-Editor, welche er
wunderbar in die Font.ini schreibt, ich irgendwie noch als #include
einbinden muss.
Nun habe ich es aber verstanden.
Deine Erläuterungen mache einiges einfacher :) Hatte das
glcd.Flags.Fixed bisher gar nicht beachtet und die Schriftzeichen dann
im Editor gleich breit (mit zusätzlichen Leerreihen) gemacht. Was
natürlich dann auch mehr Speicher verbraucht.
Danke auch für Deine Mail!
Gruß
Torsten
Thread beobachten
Seitenaufteilung abschalten