ANOLOUGE DIGITALE-B-I-N-A-R-Y-KLOK ALL IN ONE!?!? (4 / 6 stap)

Stap 4: programmeren

Hier is het programma

#platform "uLCD-32PT_GFX2"
#inherit "4DGL_16bitColours.fnc"
#inherit "FONT4.fnt"

#constant FALSE, TRUE / / FALSE = 0, TRUE = 1

#STACK 100

Afbeelding labels voor wat we in GFX2DEMO gebruiken. GCI (image control indexen)
#constant SEG7 0
#constant toetsen 1
#constant EXITBTN 4
#constant ADDBTN 8
#constant CHECKBTN 15
#constant CLOCKBTN 27

klok registers
#constant seconden 0
#constant minuten 1
#constant uur 2
#constant DS1307 0xD0
#constant WR 1
var seconden, minuten, uren;
#constant SEG7_BG_COLOUR 0x0841 / / 7 seg display achtergrondkleur

var iHndl; afbeelding van besturingsgreep
var mx, mijn; muis/touch positie
var edstate; klok bewerken staat, 1 = HH, 2 MM, 3 = = SS

var hFile;
#constant FACECOLOUR rood
#constant SECONDSCOLOUR wit
#constant MINUTESCOLOUR geel
#constant HOURSCOLOUR blauw

globale variabelen
var seconds2, minutes2, hours2;
var targetX, targetY;
var screenwidth, screenheight;
var xc, yc, r;
var n, x, y, k, colr, t, kj: = 1;
var kkl: = 1;
var exit2: = 0;
var firstx, firsty, x 2, y2, state2;
var set_timeButtonX, set_timeButtonY;

kaart van sleutelwaarden voor toetsenbord
#DATA
byte-toetsen 7,8,9,4,5,6,1,2,3,0,0,0
#END

Max tijd register waarde voor bewerken check
#DATA
byte maxval 0x59, 0x59, 0x23
#END

Translate bewerken pos vereiste register
#DATA
Word xlat HOURS, MINUTES, SECONDS

#END

func DrawHand (lengte van de var, var hoek, kleur van de var)

gfx_MoveTo (xc, yc); RE_ESTABLISH HET MIDDELPUNT MOET!!!

gfx_Set (OBJECT_COLOUR, kleur);
gfx_Orbit (hoek-90, lengte);
gfx_LineRel (targetX, targetY); VERKEERD! Picaso erfenis had een gebroken gfx_LineRel die ok hier werkte,
gfx_LineTo (targetX, targetY); maar het moet gfx_LineTo, dat is nu juist
endfunc

func toetsenblok (var staat)
var privé charpos;
var temp, r, n, x, y, k, x 1, y1, xoffs, yoffs, oldshadow;
var privé keyval;
if (!. Clock.Edit)
if(!edstate)
charpos: = 2;
oldshadow: = gfx_Set(BEVEL_SHADOW,1);
img_Darken (iHndl, toetsenbord);
img_SetAttributes (iHndl, toetsenbord, I_TOUCH_DISABLE); toetsenbord touch uitschakelen
img_SetWord (iHndl, toetsenbord, IMAGE_INDEX, 10); 10e frame instellen, knop (niet ingedrukt) toestand (omhoog)
gfx_Set(BEVEL_SHADOW,oldshadow);
anders
img_ClearAttributes (iHndl, toetsenbord, I_TOUCH_DISABLE); inschakelen van de toetsenbord touch
keyval: = 10; Aanvankelijk, nemen geen ingedrukt, selecteert u laatste keyframe
if(State == TOUCH_PRESSED)
calc welke knop is ingedrukt
x1: = 4 + img_GetWord (iHndl, toetsenbord, IMAGE_XPOS);
Y1: = 4 + img_GetWord (iHndl, toetsenbord, IMAGE_YPOS);
xoffs: = (img_GetWord(iHndl, KEYPAD, IMAGE_WIDTH)-8) / 3;
yoffs: = (img_GetWord(iHndl, KEYPAD, IMAGE_HEIGHT)-8) / 4;
x1: = 44;
Y1: = 89;
xoffs: = 16; We weten waar het toetsenbord is, gewoon gebruik maken van vaste waarden op te slaan codespace
yoffs: = 16;
voor (y: = y1; y < y1 + yoffs * 4; y += yoffs) / / nu zoeken touch co-ord
voor (x: = x1; x < x1 + xoffs * 3; x += xoffs)
n ++;
Als (mx > x & & mx < x + xoffs & & mijn > y & & mijn < y + yoffs) k: = n;
volgende
if(k) onderbreking;
volgende
if(k) / / als we te vigerend toonsoort got
keyval: = keys [k - 1]; de sleutel krijgen val
r: = xlat [edstate] - 1; Wijs juiste register
Temp: = Clock.time[r]; verplaatsen en toevoegen van nieuwe cijfers
Temp: = ((temp << 4) & 0xF0) + keyval;
Clock.time[r]: = temp;
Clock.Edit & = ~ (charpos << ((edstate-1) << 1)); de underscore wijzigen
charpos: = 1;
Clock(); 7seg weergave bijwerken
endif

endif
img_SetWord (iHndl, toetsenbord, IMAGE_INDEX, keyval); set vereiste frame, als 10e frame, de knop omhoog is (niet ingedrukt) staat
endif
img_Show (iHndl, toetsenbord);

endfunc

tijd weergeven als normaal bewerken == 0, anders Toon vereiste onderstrepingsteken.
elk stukje in var bewerken coresponds aan een onderstreping weergegeven, bit5 is
cijfer 1 downto bit 0 = cijfer 6
func Clock()
pause(1000);
privé var bewerken; bewerkingsmodus, selecteert stukjes 5:0 uderscores voor cijfers 6:1
var privé tijd [3]; tijd in de BCD-indeling, coresponds klok registreert seconden, minuten, uren
var k, n, xpos, regptr;

#constant X 22 / / x-positie voor tijd
#constant Y 32 / / y positie voor tijd
#constant W 22 / / cijfer breedte

img_Enable (iHndl, SEG7); inschakelen van het display van de 7seg, terwijl we weer te geven
xpos: = X; instellen vanaf x
regptr: = uur; Start in de spits
terwijl (n < 6)
img_SetPosition (iHndl, SEG7, xpos, Y); positie instellen voor cijfer
Als ((bewerken >> n) & 1) / / als het bewerken van cijfers,
k: = 11; Selecteer onderstrepingsteken
anders
k: = tijd [regptr]; anders krijg vereiste tijd registreren
Als (! () n & 1)) k: k = >> 4; HI knabbelen krijgen als HI cijfer
endif
img_SetWord (iHndl, SEG7, IMAGE_INDEX, k & 15); Selecteer de vereiste cijfers

img_Show (iHndl, SEG7); de afbeelding weergeven
xpos += W;
n ++;
Als (n == 2 || n == 4) / / wanneer vereist,
regptr--; decrement registreren aanwijzer
xpos += 4;
gfx_RectangleFilled (xpos, Y + 10, xpos + 4, Y + 14, oranje); plaats van de dikke darm
gfx_RectangleFilled (xpos, Y + 20, xpos + 4, Y + 24, oranje);
xpos += 10;
endif
wend
img_Disable (iHndl, SEG7); We zijn klaar weer te geven, de 7seg-beeldscherm uitschakelen
endfunc

Controleer of de calue die gewoon was bewerkt ok is
vragen met een korte foutbericht als buiten bereik
het instellen van het bewerkingsveld terug op dezelfde pos voor ander proberen.
retourneert nul als mislukt
func-checkRegisters()
var reg, retval: = TRUE;
if(edstate)
reg: = xlat [edstate-1];
Als (Clock.time [reg] > maxval[reg]) / / check voor verstandige waarde
gfx_MoveTo(90,3);
txt_FGcolour(Red); Als dit niet het geval is, gooien het bericht
putstr("ERROR\r");
pause(500);
putstr("");
edstate--; en back-up zodat we in huidige bewerkingsveld blijven
RetVal: = FALSE;
endif
endif
Return retval;
endfunc

func main()
var n, c, colr: = grijs;
var staat;
var afslag;

var opnieuw proberen: = 10;
terwijl (opnieuw--& &! file_Mount()); rijpaard naar de toer
Als (! opnieuw)
putstr ("Mount mislukt!");
pause(2000);
terugkeer; worden afgesloten als niet koppelen
endif

iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1); bouwen van het besturingselement van de afbeelding met behulp van de gewenste modus, een pointer terug te keren naar de toewijzing van de structuur
Als (! iHndl)
pause(2000);
terugkeer; afsluiten als afbeeldingsbesturingselement niet laden
endif

I2C_Open(I2C_SLOW); 100khz
I2C_Open(I2C_MED); 400khz
I2C_Open(I2C_FAST); 1mhz NB DS1307 kan niet worden uitgevoerd op 1mhz!!!

pause(10);

n:=readbyte(SECONDS) & 0x7F; zorgen CH bits is duidelijk anders klok niet uitgevoerd
writeByte(SECONDS, n);

pause(1000);
gfx_Cls();

img_Disable(iHndl, all); eerst omhoog, uitschakelen alle beelden

nu stellen wat we nodig hebben
img_Enable (iHndl, toetsenbord); Wij willen het toetsenblok
img_Enable (iHndl, ADDBTN);
img_Enable (iHndl, EXITBTN); Wij willen de knop Afsluiten
img_Enable (iHndl, CLOCKBTN); We willen de tijd-knop

gfx_Origin(30,15);

gfx_Panel (PANEL_RAISED, 0, 0, 200, 17, DONKERBLAUWE); titelbalk
gfx_Panel (PANEL_RAISED, 0, 18, 150, 200 GRAY); hoofdvenster van deelvenster
img_SetPosition (iHndl, EXITBTN, 184, 2); plaats van de knop Afsluiten
gfx_MoveTo(8,3);
txt_Opacity(opaque);
txt_BGcolour(DARKBLUE);
txt_FGcolour(CYAN);
putstr ("Set Time"); de titel

7 seg vertoningspaneel
gfx_Panel (PANEL_SUNKEN, 15, 24, 170, 50, GRAY);
gfx_Panel (PANEL_RAISED, 19, 28, 162, 42, SEG7_BG_COLOUR);

img_SetPosition (iHndl, toetsenbord, 40, 85); plaats het toetsenbord
img_SetPosition (iHndl, CLOCKBTN, 140, 90); plaats de tijd-knop
img_SetPosition (iHndl, CHECKBTN, 138, 130); plaats de knoop van de uitgang (verborgen tot bewerken)
img_SetPosition (iHndl, ADDBTN, 3, 100);
gfx_Button (BUTTON_UP, 3, 100, zilver, rood, FONT1, 1, 1, 'Set');

img_Show(iHndl, all); afbeeldingen bijwerken
gfx_Rectangle (140 90, 163, 111, RED); RODE rechthoek rond de klok knop (vergrendelde stand) plaats

Keypad(0);

touch_Set(TOUCH_ENABLE); inschakelen van het aanraakscherm
Clock();

while(!Exit) / / verblijf in lus til afsluiten knop hit

Als (Clock.edit == 0 & & edstate == 0) / / als we niet editie
c: = seconden; als seconden heeft rolde
if(c!=Clock.time[SECONDS])

Clock.time[SECONDS]: = seconden; Lees de klok chip
Clock.time[minutes]: = minuten;
Clock.time[hours]: = uur;
Clock();

endif
endif

staat: = touch_Get(TOUCH_STATUS); We zullen kijken voor elke activiteit van de aanraking
MX: = touch_Get(TOUCH_GETX); We zullen ook grijpen de x
mijn: = touch_Get(TOUCH_GETY); en de y-coördinaten van de aanraking

if(State == TOUCH_PRESSED) / / als er een pers
n: = img_Touched(iHndl, ALL); zien als alle beelden werden aangeraakt
Als (n! = -1)
if(n == KEYPAD) / / als toetsenbord was aangeraakt,
Keypad(State); bijwerken toetsenbord
anders
img_Lighten (iHndl, n); anders gewoon verlichten wanneer we raken
img_Show (iHndl, n);
endif
endif
gfx_Rectangle (140 90, 163, 111, colr); plaats rechthoek ronde klok btn
endif

if(State == TOUCH_MOVING) / / als er beweging
endif

if(State == TOUCH_RELEASED) / / als er een release;
Als (n! = -1)

if(n==EXITBTN) afslag: = 1; afsluiten als exit knop hit

if(n==CHECKBTN) / / als controleren knop hit
if(checkRegisters()) / / als laatste bewerking ok was
seconden: Clock.time[SECONDS =]; schrijven seconden + houden
minuten: Clock.time[MINUTES =]; schrijven minuten
uur: Clock.time[HOURS =]; uren schrijven
seconds2: = Clock.time[SECONDS]; schrijven seconden + houden
minutes2: = Clock.time[MINUTES]; schrijven minuten
hours2: = Clock.time[HOURS]; uren schrijven
n:=readbyte(SECONDS) & 0x7F; wachtruimte
writeByte(SECONDS, n);
pause(100);
Clock.Edit: = 0; nu niet bewerken, uitvoermodus
edstate: = 0;
Colr: = rood;
img_Disable (iHndl, CHECKBTN); Sortie knop uitschakelen
gfx_RectangleFilled (138, 130, 138 + 28, 130 + 28, GRAY); de sortie knop wissen
Clock();
Keypad(0);
anders
n: = CLOCKBTN; anders fout, opnieuw huidige bewerken fase
endif
endif

if(n==ADDBTN)
Als (kkl == 0)
Main();
KKL: = 1;
endif
Als (kkl == 1)
KKL: = 2;
endif
Als (kkl == 2)
gfx_Cls();
iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1);
Als (! iHndl)
pause(2000);
terugkeer;
endif
img_Disable(iHndl, all);
pause(10);

img_Enable (iHndl, ADDBTN);
img_SetPosition (iHndl, ADDBTN, 30, 10);
img_Show (iHndl, ADDBTN);
exit2: = 1;
seconds2: = Clock.time[SECONDS]; schrijven seconden + houden
minutes2: = Clock.time[MINUTES]; schrijven minuten
hours2: = Clock.time[HOURS]; uren schrijven
kJ: = 1;
endif
endif

if(n == CLOCKBTN)
img_Darken (iHndl, CLOCKBTN);
img_Show (iHndl, CLOCKBTN);
checkRegisters(); selectievakje voor geldige waarden
Als (++ edstate == 4) edstate: = 1; doorlopen van de velden bewerken
Clock.Edit: = 3 << ((edstate-1) << 1); instellen van vereist bits hoog in bewerken register
Keypad.charpos: = 2; Start bewerken op zijn minst significante cijfer
Clock.time[xlat [edstate-1]]: = 0; nul van het bedrijfsregister klaar
img_Enable (iHndl, CHECKBTN); Sortie knop inschakelen
img_Show (iHndl, CHECKBTN); weer te geven
gfx_Rectangle (138 130, 138 + 27, 130 + 27, GRAY); rechthoek om zich te ontdoen van die vervelende uitlijning stippen
Colr: = kalk;
Clock();
Keypad(State);
endif

if(n == KEYPAD) / / als toetsenbord loslaat
Keypad(State); status bijwerken
endif

endif
gfx_Rectangle (140 90, 163, 111, colr); plaats rechthoek ronde klok btn
n: = -1;
endif
Setup;
wend
setupclock();
endfunc

func Setup
Als (exit2 == 1 & & kj == 1)
kJ: = 0;
txt_Set (TEXT_OPACITY, ONDOORZICHTIG);
ScreenWidth: = gfx_Get (X_MAX);
screenheight: = gfx_Get (Y_MAX);
XC: screenwidth = >> 1;
yc: screenheight = >> 1;
r: = MIN (screenwidth, screenheight) >> 1;
gfx_Set (PEN_SIZE, solide);
gfx_Circle (xc, yc, r-16, FACECOLOUR);
gfx_Set (PEN_SIZE, OUTLINE);
n: = -8;
terwijl (n ++ < 8)
Colr: = groen;
gfx_Circle (xc, yc, r + n-8, colr);
wend

instellen van het middelpunt
gfx_MoveTo (xc, yc);

een variabele van de doelgroep voor de opdracht van de baan
gfx_OrbitInit (& targetX, & targetY);

Mark van de uren rond de wijzerplaat
gfx_Set (PEN_SIZE, solide);
gfx_MoveTo (xc, yc);
n: =-90; 12 uur positie
terwijl (n < 270)
gfx_Orbit (n, r-6);
k: = 3;
Als (! () n % 90)) k: = 5;
gfx_Circle (targetX, targetY, k, blauw);
n: = n + 30; elke 30 degreees
wend
KKL: = 0;

setupclock();
Touch();
anders
setupclock();
endif
endfunc

func-setupclock()
seconden: = 80;
minuten: = 89;
uur: = 18;
Herhaal
Als (Clock.edit == 0 & & edstate == 0)
pause(1000);
Als (kkl == 1)
afdrukken ("The Time is", uur [DEC1Z], ":", [DEC2Z] minuten, ":", [DEC2Z] seconden);
seconden
Als (seconden == 9)
seconden: = seconden + 6;
endif / / 25, 40, 55
Als (seconden == 25)
seconden: = seconden + 6;
endif
Als (seconden == 41)
seconden: = seconden + 6;
endif
Als (seconden == 57)
seconden: = seconden + 6;
endif
Als (seconden == 73)
seconden: = seconden + 6;
endif
minuten
Als (minuten == 9)
minuten: = minuten + 7;
endif / / 25, 40, 55
Als (minuten == 25)
minuten: = minuten + 7;
endif
Als (minuten == 41)
minuten: = minuten + 7;
endif
Als (minuten == 57)
minuten: = minuten + 7;
endif
Als (minuten == 73)
minuten: = minuten + 7;
endif
uur
Als (uren == 9)
uur: = uur + 7;
endif
Als (! () seconden: = (++ seconds % 90)))
Als (! () minuten: = (++ minuten % 90)))

Als (uren == 18)
uur: = 0;
endif
uur: = (++ uur % 19);
endif
endif
endif
Clock.time[SECONDS]: = seconden; Lees de klok chip
Clock.time[minutes]: = minuten;
Clock.time[hours]: = uur;
Clock(); / / update van de tijd
terugkeer;
endif

Als (kkl == 2 & & exit2 == 1)

DrawHand (r-20, seconds2 * 6, FACECOLOUR); undraw van de tweede hand

DrawHand (r-35, minutes2 * 6 + seconds2/10, FACECOLOUR); undraw de minutenwijzer

DrawHand (r-50, hours2 * 30 + minutes2 >> 1, FACECOLOUR); undraw van de kleine wijzer

gfx_Circle (xc, yc, 5, FACECOLOUR);

berekenen van de nieuwe tijd
Merk op dat dit buggy was,
Als (! () seconds2: = (++ seconds2% 60)))
Als (! () minutes2: = (++ minutes2% 60)))
hours2: = (++ hours2% 12);
endif
endif

display_Vsync();
DrawHand (r-20, seconds2 * 6, SECONDSCOLOUR); vernieuwen van de tweede hand
DrawHand (r-35, minutes2 * 6 + seconds2/10, MINUTESCOLOUR); Ververs de minutenwijzer
DrawHand (r-50, hours2 * 30 + minutes2 >> 1, HOURSCOLOUR); de uurwijzer vernieuwen
gfx_Circle (xc, yc, 5, oranje);
terugkeer;
Touch();
terugkeer;
endif
anders
terugkeer;
terwijl (!. Clock.Edit == 0 & &! edstate == 0)
pause(100);

wend

endif
Forever
endfunc

func-touch()
touch_Set(TOUCH_ENABLE); inschakelen van het aanraakscherm
Clock();

Herhaal
var n, colr: = rood;
var staat;
staat: = touch_Get(TOUCH_STATUS); We zullen kijken voor elke activiteit van de aanraking
MX: = touch_Get(TOUCH_GETX); We zullen ook grijpen de x
mijn: = touch_Get(TOUCH_GETY); en de y-coördinaten van de aanraking

if(State == TOUCH_PRESSED) / / als er een pers
n: = img_Touched(iHndl, ALL); zien als alle beelden werden aangeraakt
if(State == TOUCH_RELEASED) / / als er een release;
Als (n! = -1)

if(n==ADDBTN)

Main();
KKL: = 0;
exit2: = 0;
endif
endif
endif
endif
terugkeer;
Forever
endfunc