Deze keer een kleine verbetering. Het lijkt zinvol voor het plaatsen van een cijfer een functie te schrijven.
Hierdoor wordt het werkelijke programma aanmerkelijk overzichtelijker.
Het resultaat is dan:
/* HamKlok One uitleg sprite
* Sure 2416 display 24*16 leds
* pa0akv 2010
* -----------------------------------
* Historie
* versie 0.0 november 2010
* -----------------------------------
*/
// Eerst even de juiste bibliotheken ophalen
// Shure libraries
#include "MatrixDisplay.h"
#include "DisplayToolbox.h"
#include <WProgram.h>
// Het display heeft nog wat aanvullende info nodig
// Easy to use function
#define setMaster(dispNum, CSPin) initDisplay(dispNum,CSPin,true)
#define setSlave(dispNum, CSPin) initDisplay(dispNum,CSPin,false)
// We hebben maar 1 display! De bibliotheek kan er meer aansturen
// 1 = Number of displays
// Data = 10
// WR == 11
// False - we dont need a shadow buffer for this example. saves 50% memory!
// Initaliseer Shure display met juiste aansluitingen!
MatrixDisplay disp(4,11,10, false);
// Pass a copy of the display into the toolbox
DisplayToolbox toolbox(&disp);
// In totaal 3 groepen van 8 leds = 24
// De eerste is positie 0 de laatste = 23
// Twee groepen hoog dus rechts boven is 0
// Rechts onder is dan 15
uint8_t X_MAX = 23;
uint8_t Y_MAX = 15;
// Dit voorbeeld heeft 1 Array Fig5 !
uint8_t Fig0[7];
uint8_t Fig1[7];
uint8_t Fig2[7];
uint8_t Fig3[7];
uint8_t Fig4[7];
uint8_t Fig5[7];
uint8_t Fig6[7];
uint8_t Fig7[7];
uint8_t Fig8[7];
uint8_t Fig9[7];
uint8_t FigT[7];
uint8_t FigD[7];
void setup()
{
disp.setMaster(0,4);
// Opbouwen van de sprite !
Fig0[0] = B01110;
Fig0[1] = B10001;
Fig0[2] = B10001;
Fig0[3] = B10001;
Fig0[4] = B10001;
Fig0[5] = B10001;
Fig0[6] = B01110;
Fig1[0] = B00110;
Fig1[1] = B00101;
Fig1[2] = B00100;
Fig1[3] = B00100;
Fig1[4] = B00100;
Fig1[5] = B00100;
Fig1[6] = B11111;
Fig2[0] = B01110;
Fig2[1] = B10001;
Fig2[2] = B10000;
Fig2[3] = B01100;
Fig2[4] = B00010;
Fig2[5] = B00001;
Fig2[6] = B11111;
Fig3[0] = B01110;
Fig3[1] = B10001;
Fig3[2] = B10000;
Fig3[3] = B01110;
Fig3[4] = B10000;
Fig3[5] = B10001;
Fig3[6] = B01110;
Fig4[0] = B00001;
Fig4[1] = B00001;
Fig4[2] = B01001;
Fig4[3] = B01001;
Fig4[4] = B11111;
Fig4[5] = B01000;
Fig4[6] = B01000;
Fig5[0] = B01111;
Fig5[1] = B00001;
Fig5[2] = B00001;
Fig5[3] = B01111;
Fig5[4] = B10000;
Fig5[5] = B10000;
Fig5[6] = B01111;
Fig6[0] = B01110;
Fig6[1] = B00001;
Fig6[2] = B00001;
Fig6[3] = B01111;
Fig6[4] = B10001;
Fig6[5] = B10001;
Fig6[6] = B01110;
Fig7[0] = B11111;
Fig7[1] = B10000;
Fig7[2] = B01000;
Fig7[3] = B00100;
Fig7[4] = B00010;
Fig7[5] = B00010;
Fig7[6] = B00010;
Fig8[0] = B01110;
Fig8[1] = B10001;
Fig8[2] = B10001;
Fig8[3] = B01110;
Fig8[4] = B10001;
Fig8[5] = B10001;
Fig8[6] = B01110;
Fig9[0] = B01110;
Fig9[1] = B10001;
Fig9[2] = B10001;
Fig9[3] = B11110;
Fig9[4] = B10000;
Fig9[5] = B10000;
Fig9[6] = B01110;
FigT[0] = B11111;
FigT[1] = B01110;
FigT[2] = B00100;
FigT[3] = B00000;
FigT[4] = B00000;
FigT[5] = B00000;
FigT[6] = B00000;
FigD[0] = B00000;
FigD[1] = B00000;
FigD[2] = B00000;
FigD[3] = B00000;
FigD[4] = B00100;
FigD[5] = B01110;
FigD[6] = B11111;
}
// Hier begint het eigenlijke programma !
void loop()
{
// Bovenste regel met "nep tijd" plaatsen
Display(1,0,1);
Display(4,6,1);
Display(5,13,1);
Display(3,19,1);
// Dubbele punt als scheiding aanbrengen
toolbox.setPixel(11,3,1,true);
toolbox.setPixel(11,6,1,true);
// Onderste regel even vullen
// Met een artistieke seconden aanduiding
Display(10,9,9);
delay(800);
Display(11,9,9);
delay(800);
}
// Hier eindigd het eigenlijke programma !
// En dan opnieuw beginnen !
/* Functie voor het opbouwen van de sprite
* deze functie wordt elke keer opgeroepen
* als we een cijfer op het display zetten
* opgave welke sprite SpriteIn
* en de plaats op het display 0,0 Xin,Yin
*/
void shiftIt(byte SpriteIn,int Xin,int Yin)
{
// Shift out 5 bits LSB first
boolean LedStatus;
// for each bit in SpriteIn test a bit
for (int i=0; i<5; i++)
{
// if the value of SpriteIn and (logical AND) a bitmask
// are true, set LedStatus to 1 (HIGH)
if ( SpriteIn & (1<<i) )
{
LedStatus = HIGH;
toolbox.setPixel(Xin+i, Yin, LedStatus, true);
}
else
{
LedStatus = LOW;
toolbox.setPixel(Xin+i, Yin, LedStatus, true);
}
}
}
/* Functie om nummer naar sprite te converteren
* en op Shure display te plaatsen
* Opgave te plaatsen cijfer Tvalue
* en plaats via kolom en rij
*/
void Display(int Tvalue,int Col,int Row)
{
switch (Tvalue)
{
case 0 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig0[i],Col,Row+i);
}
break;
case 1 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig1[i],Col,Row+i);
}
break;
case 2 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig2[i],Col,Row+i);
}
break;
case 3 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig3[i],Col,Row+i);
}
break;
case 4 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig4[i],Col,Row+i);
}
break;
case 5 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig5[i],Col,Row+i);
}
break;
case 6 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig6[i],Col,Row+i);
}
break;
case 7 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig7[i],Col,Row+i);
}
break;
case 8 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig8[i],Col,Row+i);
}
break;
case 9 :
for (int i = 0; i < 7; i ++)
{
shiftIt(Fig9[i],Col,Row+i);
}
break;
case 10 :
for (int i = 0; i < 7; i ++)
{
shiftIt(FigT[i],Col,Row+i);
}
break;
case 11 :
for (int i = 0; i < 7; i ++)
{
shiftIt(FigD[i],Col,Row+i);
}
break;
}
}
Het groen gedeelte is de nieuwe functie en het gele gedeelte is het deel waar wordt bepaald welke sprites, waar worden geplaatst.
Het resultaat op de bovenste regel 14:53 en op de onderste regel een pijl op neer in het ritme van een seconde!
Nu naderen we bijna de klok functionaliteit. Als we de RTC info inlezen en omzetten naar Sprites begint
het echt op een klok te lijken......
wordt vervolgt !
Geen opmerkingen:
Een reactie posten