Arduino Projekten

Tue 20-Aug-19
01:32:57




Font Functions

Datum: Sat 31 May 2014
Samenvatting: Diverse Functies die het schrijven van letters op de panelen moeten vereenvoudigen.


Nu er een Font-Definitie is, moeten er ook nog functies komen die het eenvoudig maken om letters, cijfers en andere tekens op de RGB-panelen te tonen.

Aansluitingen van de RGB-Panelen.

Het moge duidelijk zijn, dat alle aansluitingen van de RGB-Panelen op de Arduino nog precies dezelfde zijn als van alle voorgaande RGB-Paneel projecten. Daar is het opzet-printje tenslotte ook voor bedoeld geweest. Eenvoudig en eenduidig aansluiten zonder elke keer weer opnieuw uit te zoeken hoe het moet.

Alle letters tonen.

Zoals de foto's uit het project Font-Definities laat zien, is het mogelijk om alle letters op de panelen te tonen ... voor zover de panelen dat aantal letters ook kan laten zien (2 panelen tonen maximaal 8x2 tekens). Het idee is eenvoudig.

  1. Geef op op welke positie een letter moet komen.
  2. Geef de kleur op.
  3. Geef aan welk letter-nummer getoond moet worden.
  4. En doe dit voor elke letter die er moet veschijnen.

Ik had hier een functie voor "void WriteChar (int _x, int _y, word ch, word kk)". Alle benodigde getallen konden bij elke letter worden opgegeven. Op zich werkte het en voor een alfabet is dit een eenvoudige opvolging van nummers, 1 tot en met het eind. Maar ...

Maar woorden laten zien geeft op deze manier wat meer werk. Elke letter moet worden opgezocht in de Font-Tabel en elke (x;y)-coördinaat moet worden ingetikt.

Er moeten dus wat zaken worden aangepakt, met elk zijn eigen functie.

De positie van de teksten.

void GotoXY (int _x, int _y)

Allereerst is er GotoXY om de positie op te geven. De coördinaten zijn in pixels, links-boven is (x;y)=(0;0). En er moeten halve letters getoond kunnen worden, dus dit punt moet negatief kunnen zijn en tegen het rechter-onder punt van het paneel kunnen zitten.

De bedoeling van GotoXY is duidelijk, er hoort wel een tweede functie bij (niet noodzakelijk, maar wel makkelijk).

void NextXY ()

NextXY verzet de positie een aantal punten naar rechts. In dit geval 8 punten, van 8 bitjes per letter-regel. Deze functie regelt ook een veredelde <LF><CR>. Of te wel, aan het einde van de regel wordt de volgende letter op de volgende regel geplaatst.

De kleur van de tekens.

void CharColor (word _kk)
CharColor plaatst eenvoudig de kleur in de variabele "_fontcolor" waarmee de kleur van de letters wordt vastgehouden. Eenvoudiger kan het niet.

Tekens Reverse maken.

Zoals genoemd in het projekt van de Font-Definities, had de Cbm64 in zijn Character-Rom alle tekens ook als reverse staan. Om geheugen te besparen zijn al deze reverse tekens uit de definitie gehaald en dus moet er een oplossing hiervoor komen.

Er zijn twee methodes hiervoor. De eerste kost meer tijd en gooit in de uiteindelijke letter-teken functie een "IF" statement om tussen WEL kleuren en NIET kleuren.

Een tweede methode is om op het moment dat een letter uit de Font-Tabel wordt gehaald om dan alle bitjes te inverteren. Alle 1-tjes worden 0-letjes en omgekeerd. In feite komt dit neer op een Xor bewerking op alle bitjes. Het is 1 bewerking wat snel uitgevoerd is.

void ReverseChar ()
void NormalChar ()
void SetReverse (byte _bits)

  • "ReverseChar": zet de Xor waarde op $FF. Alle bitjes zullen geïnvetrteerd worden. Bitje Xor %1 geeft het omgekeerde bitje terug. Deze Xor-waarde wordt onthouden in de variabele "_fontreverse".
  • "NormalChar": zet de Xor waarde op $00. Alle bitjes zullen gewoon blijven. Bitje Xor %0 laat het bitje onveranderd.
  • "SetReverse": Met deze functie kan zelf een willekeurige Xor waarde worden opgegeven. Dit kan leuke resultaten geven.

Transparantie.

Er is een vorm van transparantie aanwezig. Dit wil niet zeggen dat de tekens wazig getekend worden, maar dat de achtergrond-pixels ongewijzigd blijven (en dus dat er blijft staan wat er al stond). Hiermee zijn dus op een achtergrond behang teksten te maken.

Helaas is hier geen eenvoudige methode voor, daar de (oude) achtergrond elke willekeurige waarde kan hebben. Daarom is er gekozen voor een bit-test met de TransparantieWaarde. De maskers van de bitjes staat (ook nu) in een array.

void TransparantChar ()
void SolidChar ()
void SetTransparance (_bits)

  • "TransparantChar": zet de TransparantieWaarde op $FF. Alle achtergrond-pixels blijven ongewijzigd. Deze TransparantieWaarde wordt inhouden in de variabele "_fonttransparant".
  • "SolidChar": zet de TransparantieWaarde weer op $00. Alle achtergrond-pixels worden (weer) in de achtergrondkleur getekend.
  • "SetTransparance": Met deze functie kan zelf een willekeurige TransparantieWaarde worden opgegeven. Dit kan leuke resultaten geven.

Het feitelijke character op het paneel zetten.

Nu positie, kleur en Xor vast liggen, kan eindelijk de letter op het paneel worden geplaatst. Hiervoor is de eerder genoemde "WriteChar" gestript tot:

void WriteChar (word ch)

Het idee in deze functie komt op het volgende neer:

  • Haal een teken uit de Font-Tabel.
  • Ga met een teller alle bytes (van een letter) af.
  • Doe de Xor op betreffende byte.
  • Ga met een tweede teller alle bitjes af.
  • Gebruik de functie "SetPoint" om pixels "aan" te zetten (met de kleur "_fontcolor"), of om ze uit te zetten (met de kleur "_bgcolor")
  • Wanneer de gehele letter afgewerkt is, zet de positie klaar voor de volgende letter.

Nu staat de Font-Tabel ergens in het programma-geheugen (zoals uitgelegd bij het projekt van de Font-Definitie). Om de positie in het geheugen te achterhalen, is er een truuk nodig, die bestaat uit twee delen. Het eerste deel staat in de Font-Tabel zelf (de woorden "static", "const" en "PROGMEM"):

static const unsigned char font[ fontchars * charbytes ] PROGMEM =
{ alle data van het font };

Het tweede deel staat in deze functie (het woord "pgm_read_byte_near(variabele)").

word charbyte=pgm_read_byte_near(font+character_nummer+byte_nummery)

Dit meganisme heeft te maken met pointer-adressering en indexering en het haalt 1 enkele byte uit de Font-Tabel. En nu er een byte beschikbaar is, wordt hierop meteen de Xor bewerking op gedaan.

word charbyte=pgm_read_byte_near(font+_ch+qy) xor _fontreverse;

De bitjes worden stuk voor stuk gecontroleerd door naar het hoogste bitje (nummer 7, dit geeft de waarde 128) te kijken. Bij een "1" wordt het bitje getekend (in de kleur "_fontcolor"), bij een "0" wordt dit bitje "gedoofd" (in de kleur "_bgcolor"). Na deze check wordt de gehele byte een bitje naar links geschoven.

Na alle bits bekeken te hebben, is de volgende byte aan de beurt. En na alle bytes wordt de functie "NextXY" aangeroepen, als voorbereiding voor de volgende letter.

In het begin van deze functie wordt er echter nog gecontroleerd of het letter-nummer wel voorkomt, omdat er anders willekeurige bytes uit het geheugen worden gehaald. Het letter-nummer mag daarom niet hoger zijn dan het laatste letter-nummer.

Na deze controle moet de juiste byte-nummer van de Font-Tabel worden berekend. En dit gaat eenvoudig door het nummer te vermenigvuldigen met het aantal bytes per teken.

De ASCII-Tabel.

Elke letter, cijfer, teken heeft een ASCII-waarde. En deze waarde ligt vast. Zo heeft de "0" altijd de waarde 48. De "A" heeft de waarde 65 en de "a" heeft de waarde 97. Logisch opvolgende letters en cijfers zijn ook opvolgend genummerd.

Zoals eerder genoemd, liggen bij de Cbm64, de letter en cijfer Font-codes per deel van 32-tekens op een andere plek. En om de Font-Definitie wat algemener te kunnen opzetten, is ook hier weer voor een array gekozen. Het is wel veel (eenmalig) uitzoek en tikwerk, maar in het programma werkt het ook lekker snel.

Het idee wordt dan om echt een letter "A" op te kunnen geven, waar een functie dan de juiste plaats-nummer in de Font-Tabel bepaalt.

Hele woorden op het paneel zetten.

Om hele woorden makkelijk te kunnen tonen, moet er een string (= een array van characters) opgegeven kunnen worden. Uit de ASCII-Tabel moeten de juiste nummers (van de Font-Tabel) van de letters komen. En deze nummers moeten worden doorgegeven aan de "WriteChar" functie.

void PrintChar(char* ss)

Strings (en dus teken-reeksen) in C eindigen (per definitie) altijd op een NUL-character (op te geven als '\0'). Dit in tegenstelling tot (Turbo/ Borland)Pascal, waarbij het aantal tekens van een string onderdeel is van de string zelf. Op deze '\0' is te testen, wanneer een string letter voor letter wordt afgegaan.

Bij elke letter wordt eerst gecontroleerd of deze wel voorkomt in de ASCII-Tabel (met de waardes van "asctableshift" en "asctablechars"). Daarna wordt het juiste nummer in de ASCII-Tabel opgezocht. Ook hier is de dubbele truuk van "static const ... PROGMEM" met "pgm_read_byte_near()" toegepast. Vervolgens wordt het letter-nummer doorgegeven aan "WriteChar()".

Versnelling van de Interupt-Routine

Er is versnelling in de Interupt-Routine aangebracht.

PORTD = _data_serial | PanelData[rc][RowCount][BrightLayer];
// Clock the RGB
PORTB = _clock_rise;
PORTB = _clock_fall;

Stonden hier eerst nog een AND en een OR bewerking (die zo'n 256 keer per paneel wordt uitgevoerd), nu zijn deze bewerkingen naar voren gehaald.

byte _clock_rise = PORTB | B00000001; // digitalWrite(clk, HIGH);
byte _clock_fall = PORTB & B11111110; // digitalWrite(clk, LOW );
byte _data_serial = ( PORTD & B00000011 );

Hierdoor is de paneel-aansturing een stuk sneller geworden, wat weer omgezet kan worden in snellere interupts. En dit leidt weer tot een betere helderheid aansturing.

De demo van de Font Functies.

En natuurlijk moet er een demo komen van de nieuwe Font-Functies.

void font_intro()

Als eerste een intro bij het opstarten. De resultaten staan op de foto's hiernaast. En inderdaad, er kunnen letters half op het scherm worden getoond. Hier is dat elke keer de "@" in alle hoeken (plus een complete "@" in het midden). Tevens het reverse tonen van letters kan worden gedaan (hier met de bekende zin "Hello World."). Er is een set foto's met de transparantie uit (= solide) en een set foto's met de transparantie aan.

Hierna worden alle letters getoond met:

void Letters1()

Foto's hiervan staan bij het project over de Font-Definitie. En dan wordt pas duidelijk dat deze RGB-Panelen gewoon geweldig zijn om dingen op te tonen. Zelfs vanaf 10 meter zijn de letters duidelijk leesbaar.


Broncode: [1: Font Functies]

1: De broncode van Font Functies

(Sat 31 May 2014) Het RGB-Paneel programma is uitgebreid met Font-Funkties.

Deze broncode heeft 402 regels met programma-code.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
//     ---------------------------------------------------------
//     |  RGBMatrix : RGB Matrix - Font Functions              |
//     ---------------------------------------------------------

//--------[ Needed Include Files ] -------------------------------------------
// Include the beautiful Font
#include "{Drive:\Directory}\cbmfont.c"
// Next line is needed for PROGMEM and pgm_read_byte_near-function
#include <avr/pgmspace.h>

// Some Pot-vars
word pot_del    = 0;
word pot_kleur  = 0;
word pot_num    = 0;
byte wp_count   = 0;
word char_count = 0;

void setup()
{ InitPan(0x0000);
  wp_count = 0;
  Serial.begin(115200);
  font_intro();
}

void loop()
{ read_pots();
  switch (wp_count)
    { case 0 : ClrPan();
               break;
      case 1 : Letters1();
               break;
    }
  delay (pot_del);
  Setbgcolor (pot_kleur);

  switch (pot_num)
    { case 0 : wp_count = wp_count + 1;
               if (wp_count > 1)
                  { wp_count=0;
                  }
             break;
      case 1 : wp_count = 0;
               break;
      case 2 : wp_count = 1;
               break;
      case 3 : wp_count = 2;
               break;
    }
}

void read_pots()
{ const word kleurwaaier [8] = { 0x0000, 0x0001, 0x0010, 0x0011, 0x0100, 0x0101, 0x0110, 0x0111 };
  word pot_kleur_hi = 0;
  word pot_kleur_lo = 0;
  pot_del   = analogRead(5) * 16;
  word pot_kleur_pot = analogRead(4) / 16;
  pot_kleur_lo = ( pot_kleur_pot & 0x0007 );      // 0b 0000 0111
  pot_kleur_hi = ( pot_kleur_pot & 0x0038 ) >> 3; // 0b 0011 1000
  while (pot_kleur_hi == 0)
     { // When main-color is black => take a random color
       pot_kleur_hi = random(7) +1;
     }
  pot_kleur = kleurwaaier[pot_kleur_hi] * pot_kleur_lo ;
  pot_num   = analogRead(3) / 256;
}

void font_intro()
{ // Write "Cbm-Font" Diagonal
  CharColor (0x0227);
  GotoXY ( 0,0);     WriteChar (     3);
  GotoXY ( 8,1);     WriteChar (128+ 2);
  GotoXY (16,2);     WriteChar (128+13);
  GotoXY (24,3);     WriteChar (    45);
  GotoXY (32,5);     WriteChar (     6);
  GotoXY (40,6);     WriteChar (128+15);
  GotoXY (48,7);     WriteChar (128+14);
  GotoXY (56,8);     WriteChar (128+20);
  delay(1000);

  // Write "Cbm-Font" Horizontal
  CharColor (0x0272);
  GotoXY ( 0,4);
  TransparantChar();
  WriteChar (     3);
  WriteChar (128+ 2);
  WriteChar (128+13);
  WriteChar (    45);
  WriteChar (     6);
  WriteChar (128+15);
  WriteChar (128+14);
  WriteChar (128+20);
  delay(1000);

  // Write 5 times "@"
  CharColor (0x0722);
  TransparantChar();
  GotoXY (-4,-4);    WriteChar (     0);
  GotoXY (60,-4);    WriteChar (     0);
  GotoXY (-4,12);    WriteChar (     0);
  GotoXY (60,12);    WriteChar (     0);
  SetTransparance(0x3C);
  GotoXY (28, 4);    WriteChar (     0);
  SolidChar();
  delay(1000);

  // Write "Hello " & "World."
  CharColor (0x0616);
  ReverseChar();
  GotoXY (7,0);
  PrintChar ("Hello ");
  GotoXY (9,8);
  PrintChar ("World.");

  delay(2000);
}

void Letters1()
{ // Letters
  word xx = (char_count & 7) * 8;
  word yy = (char_count & 8);
  Setbgcolor(0x0000);
//  GotoXY (xx,yy);
  CharColor(pot_kleur);
  WriteChar (char_count);
  char_count = char_count + 1;
  if (char_count & 0x000F) == 0x0000)
     { delay(250);
     }
  if (char_count >= fontchars)
     { char_count = 0;
     }
}


//==============================================================================
//==  Matrix Panel Vars and Functions                                         ==
//==============================================================================
// Paneel Vars.
const byte MaxCol = 64;
const byte MaxRow = 16;
volatile byte PanelData [MaxCol][8][3];   // = [00..63],[0..7],[0..2] of (Rl Gl Bl Ru Gu Bu 0 0)
volatile byte RowCount = 0;
// Brightness Vars.
const byte MaxBrightCount = 9;    // Count 1..MaxBrightCount
const byte BrightRow [MaxBrightCount]  = { 0,2,2,1,2,2,1,2,2}; // Counter Conversion for Binairy Code Modulation.
volatile byte BrightCount =  0;
// BackGround-Color (format: 0x0RGB = B 0000 RRRR GGGG BBBB)
word _bgcolor = 0x0000;
// Font Vars
const byte _bitjes[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
word _fontcolor = 0x0333;
byte _fontreverse = 0;
byte _fonttransparant = 0;
int _font_x = 0;
int _font_y = 0;

// RGB Pin Definitions - All Pins are hardcoded to speed things up.
// const int a   = A0;  // Address A (A0)
// const int b   = A1;  // Address B (A1)
// const int c   = A2;  // Address C (A2)
// const int b1  =  2;  // Blue 1
// const int g1  =  3;  // Green 1
// const int r1  =  4;  // Red 1
// const int b2  =  5;  // Blue 2
// const int g2  =  6;  // Green 2
// const int r2  =  7;  // Red 2
// const int clk =  8;  // Clock
// const int oe  =  9;  // outEnable
// const int lat = 10;  // Latch

void InitPan(word _k)
// Initializing the Panel
// Input: _k = BackGround-Color (format: 0x0RGB = B 0000 0RRR 0GGG 0BBB)
{ // Put Pins to Output (A0 A1 A2 - D2 D3 D4 - D5 D6 D7 - D8 D9 D10)
  DDRC = DDRC | B00000111;    // pinMode(a  , OUTPUT); pinMode(b  , OUTPUT); pinMode(c  , OUTPUT);
  DDRD = DDRD | B11111100;    // pinMode(r1 , OUTPUT); pinMode(g1 , OUTPUT); pinMode(b1 , OUTPUT);
  // pinMode(r2 , OUTPUT); pinMode(g2 , OUTPUT); pinMode(b2 , OUTPUT);
  DDRB = DDRB | B00000111;    // pinMode(clk, OUTPUT); pinMode(oe , OUTPUT); pinMode(lat, OUTPUT);
  Setbgcolor(_k);
  ClrPan();
  InitTimer();
}

void InitTimer()
{ // Initialize Timer1
  cli();                        // Disable Interrupts
  // Timer Counter Control Registers 1A & 1B
  TCCR1A = 0;                   // Make all bits of this register to 0
  TCCR1B = 0;                   // Make all bits of this register to 0

  OCR1A = 3900;                 // set Output Compare Register 1 to the desired timer count
  TCCR1B = TCCR1B | B00001000;  // turn on CTC mode (WGM12 = bit 3 - Waveform Generation Mode)
  TCCR1B = TCCR1B | B00000001;  // Set the Prescaler (CS12 CS11 CS10 = bit 2..0 - Clock Select)

  TIMSK1 = TIMSK1 | B00000010;  // set Timer Interupt MaSK 1 to compare interrupt
  // (OCIE1A = bit 1 - Output Compare match Interrupt Enable 1A)
  sei();                        // Enable Interrupts
}

void Setbgcolor(word _k)
// Set the BackGround-Color (format: 0x0RGB = B 0000 0RRR 0GGG 0BBB)
{ _bgcolor = _k & 0x0777;
}

word bgcolor(void)
{ return _bgcolor;
}

void ClrPan()
// Clear the Panel with bgcolor
{ byte _lc = (  LowColor(bgcolor()) * 9 ) << 2;
  byte _mc = (  MidColor(bgcolor()) * 9 ) << 2;
  byte _hc = ( HighColor(bgcolor()) * 9 ) << 2;
  for (byte ww=0; ww<8; ww=ww+1)
      { for (byte qq=0; qq<MaxCol; qq=qq+1)
            { PanelData [qq][ww][0] = _lc;
              PanelData [qq][ww][1] = _mc;
              PanelData [qq][ww][2] = _hc;
            }
      }
_fontreverse = 0;
_fonttransparant = 0;
_font_x = 0;
_font_y = 0;
}

byte LowColor (word _k)
// Get the LowColor rgb from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0100 ) >> 6 ) + (( _k & 0x0010 ) >> 3 ) + (( _k & 0x0001 )      );
}

byte MidColor (word _k)
// Get the MidColor RGB from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0200 ) >> 7 ) + (( _k & 0x0020 ) >> 4 ) + (( _k & 0x0002 ) >> 1 );
}

byte HighColor (word _k)
// Get the HighColor RGB from 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x0400 ) >> 8 ) + (( _k & 0x0040 ) >> 5 ) + (( _k & 0x0004 ) >> 2 );
}

word Dec2RGB (word _k)
// Convert a decimal color into a hex RGB-color 0000 0RRR 0GGG 0BBB
{ return (( _k & 0x01C0 ) << 2 ) + (( _k & 0x0038 ) << 1 ) + ( _k & 0x0007 );
}

void SetPoint (int _x, int _y, word _k)
// Let one Led lit at the (x;y) position
{ if (( _x < 0 ) || ( _x >= MaxCol ))   { return; }   // _x is outside the panel
  if (( _y < 0 ) || ( _y >= MaxRow ))   { return; }   // _y is outside the panel
  _y = _y ^ 0x0F;
  byte _y7 = _y & 0x07;
  _k = _k & 0x0777;
  byte _lc =  LowColor(_k);
  byte _mc =  MidColor(_k);
  byte _hc = HighColor(_k);
  // Put The Pixel On The Right Spot.
  if (( _y & 0x08 ) == 0 )
     { // This is the Upper-half
       PanelData[_x][_y7][0] = ( PanelData[_x][_y7][0] & B11100000 ) | ( _lc << 2 );
       PanelData[_x][_y7][1] = ( PanelData[_x][_y7][1] & B11100000 ) | ( _mc << 2 );
       PanelData[_x][_y7][2] = ( PanelData[_x][_y7][2] & B11100000 ) | ( _hc << 2 );
     }
  else
     { // This is the Lower half.
       PanelData[_x][_y7][0] = ( PanelData[_x][_y7][0] & B00011100 ) | ( _lc << 5 );
       PanelData[_x][_y7][1] = ( PanelData[_x][_y7][1] & B00011100 ) | ( _mc << 5 );
       PanelData[_x][_y7][2] = ( PanelData[_x][_y7][2] & B00011100 ) | ( _hc << 5 );
     }
}

//--------[ Font Functions ]---------------------------------------------------

void GotoXY (int _x, int _y)
{ _font_x = _x;
  _font_y = _y;
}

void NextXY ()
{ // Set the (_font_x;_font_y) to the next char-position.
  // Do an <LF><CR> at the end of the line;
  _font_x = _font_x + 8;
  if ( _font_x >= MaxCol )
     { _font_x = _font_x - MaxCol;
       _font_y = _font_y + charbytes;
       if (_font_y >= MaxRow)
          { _font_y = _font_y - MaxRow;
          }
     }
}

void ReverseChar ()
{ _fontreverse = 0xFF;
}

void NormalChar ()
{ _fontreverse = 0;
}

void SetReverse (byte _bits)
{ _fontreverse = (_bits & 0xFF);
}

void TransparantChar ()
{ _fonttransparant = 0xFF;
}

void SolidChar ()
{ _fonttransparant = 0;
}

void SetTransparance (byte _bits)
{ _fonttransparant = (_bits & 0xFF);
}

void CharColor (word _kk)
{ _fontcolor = _kk;
}

void WriteChar (word ch)
{ // Writes 1 character ch at position (_font_x;_font_y) in the color _fontcolor
  // If nescesary, xor it with _fontreverse
  // move _font_x to 8 point to the right
  if ( ch>=fontchars )
     { return; }    // Char does not exist in font.
  word _ch=ch*charbytes;
  for (byte qy=0; qy<charbytes; qy=qy+1)
      { word charbyte=pgm_read_byte_near(font+_ch+qy)  xor _fontreverse;
        for (byte qx=0; qx<8; qx=qx+1)
            { if ((charbyte & 128)>0)        // Look at MSB-point of charbyte
                 { // if (1) then draw pixel
                   SetPoint (_font_x+qx,_font_y+qy,_fontcolor);
                 }
              else
                 { // if (0) then draw bgcolor
                   if (_fonttransparant & _bitjes[qx]) == 0)
                      { // But only if not Transparant (= 0)
                        SetPoint (_font_x+qx,_font_y+qy,_bgcolor);
                      }
                 }
              charbyte=charbyte<<1;
            }
      }
  NextXY();
}

void PrintChar(char* ss)
{ // Print a character, after conversing it from ascii to font-character
  byte qq = 0;
  while ( ss[qq] != '\0' )
    { // chech every char if it is in the table.
      char cc=ss[qq];
      if (( cc>=asctableshift ) &&         // Char is above the bottom
          ( cc< asctablechars+asctableshift ) // Char is below the top
         )

         { // Find the char in the ascii-table to get the right number in the font.
           word _cc=pgm_read_byte_near(asc2font+cc - asctableshift);
           WriteChar (_cc);
         }
      qq=qq+1;
    }
}

//--------[ The Interupt Function ]--------------------------------------------

ISR(TIMER1_COMPA_vect)
// De Interrupt Service Routine
// The main interupt-routine. Do One Row (at each Interupt)
{
  byte rc = MaxCol;
  byte BrightLayer = BrightRow[BrightCount];
  byte _clock_rise = PORTB | B00000001;  // digitalWrite(clk, HIGH);
  byte _clock_fall = PORTB & B11111110;  // digitalWrite(clk, LOW );
  byte _data_serial = ( PORTD & B00000011 );
  do { rc=rc-1;
       // Send the RGB to the RGB-lines
       PORTD = _data_serial | PanelData[rc][RowCount][BrightLayer];
       // Clock the RGB
       PORTB = _clock_rise;
       PORTB = _clock_fall;
     }
  while (rc>0);
  // Make it Invisible
  PORTB = PORTB | B00000010;             // digitalWrite(oe , HIGH);
  // Select the Row on the panels.
  PORTC = ( PORTC & B11111000 ) | RowCount;
  // Latch the Data
  PORTB = PORTB | B00000100;             // digitalWrite(lat, HIGH);
  PORTB = PORTB & B11111011;             // digitalWrite(lat, LOW );
  // Make it Visible again
  PORTB = PORTB & B11111101;             // digitalWrite(oe , LOW );
  // Next Row
  RowCount = RowCount + 1;     // Count the Row
  if ( RowCount >= 8 )
     { RowCount = 0;
       BrightCount = BrightCount + 1;    // Inc the Brightness counter
       if ( BrightCount >= MaxBrightCount )
          { BrightCount = 0;
          }
     }
}


Broncode: [1: Font Functies] 

Afbeeldingen

fontfunc_1.jpg
1/8: fontfunc_1.jpg.
fontfunc_2.jpg
2/8: fontfunc_2.jpg.
fontfunc_3.jpg
3/8: fontfunc_3.jpg.
fontfunc_4.jpg
4/8: fontfunc_4.jpg.
fontfunc_5.jpg
5/8: fontfunc_5.jpg.
fontfunc_6.jpg
6/8: fontfunc_6.jpg.
fontfunc_7.jpg
7/8: fontfunc_7.jpg.
fontfunc_8.jpg
8/8: fontfunc_8.jpg.

De aansluitingen van Font Functies

Arduino Uno

Pwr USB ?
 
?
aref
gnd Gnd's (4x)
? d13
ioreff d12
reset d11
+3.3v d10 Latch
+5v d9 Oe
Gnd's (4x) gnd d8 Clock
Gnd's (4x) gnd
Vin d7 R2
d6 G2
A  (A0) a0 d5 B2
B  (A1) a1 d4 R1
C  (A2) a2 d3 G1
Behangpot   (4) a3 d2 B1
Kleurpot    (5) a4 d1
Snelheidpot (6) a5 d0