ANOLOUGE DIGITAL-B-I-N-A-R-Y-KLOCKA ALLT I ETT!?!? (4 / 6 steg)

Steg 4: programmering

Här är programmet

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

#constant falskt, sant / / FALSE = 0, sant = 1

#STACK 100

bild etiketter för vad vi använder i GFX2DEMO. GCI (bild kontroll indexvärden)
#constant SEG7 0
#constant knappsats 1
#constant EXITBTN 4
#constant ADDBTN 8
#constant CHECKBTN 15
#constant CLOCKBTN 27

klockan register
#constant sekunder 0
#constant minuter 1
#constant timmar 2
#constant DS1307 0xD0
#constant WR 1
var sekunder, minuter, timmar.
#constant SEG7_BG_COLOUR 0x0841 / / 7 seg display bakgrundsfärg

var iHndl; bild kontrollhandtag
var mx, min; mus/touch position
var edstate; klockan redigera stat, 1 = HH, 2 = MM, 3 = SS

var hFile;
#constant FACECOLOUR röd
#constant SECONDSCOLOUR vitt
#constant MINUTESCOLOUR gul
#constant HOURSCOLOUR blå

globala variabler
var seconds2, minutes2, timmar2;
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;

karta över nyckelvärden för knappsatsen
#DATA
byte nycklar 7,8,9,4,5,6,1,2,3,0,0,0
#END

Max tid register värde för redigera kontroll
#DATA
byte maxval 0x59, 0x59, 0x23
#END

Översätt redigera pos till krävs register
#DATA
ordet xlat timmar, minuter, sekunder

#END

FUNC DrawHand (var längd, var vinkel, var färg)

gfx_MoveTo (OLC, yc); MÅSTE RE_ESTABLISH MITTPUNKTEN!

gfx_Set (OBJECT_COLOUR, färg);
gfx_Orbit (vinkel -90, längd);
gfx_LineRel (targetX, targetY); FEL! Picaso arv hade en trasig gfx_LineRel som fungerade ok här,
gfx_LineTo (targetX, targetY); men det bör vara gfx_LineTo, detta är nu korrekt
endfunc

FUNC knappsatsen (var staten)
var privat charpos;
var temp, r, n, x, y, k, x 1, y1, xoffs, yoffs, oldshadow;
var privat keyval;
IF (!. Clock.Edit)
IF(!edstate)
charpos: = 2;
oldshadow: = gfx_Set(BEVEL_SHADOW,1);
img_Darken (iHndl, knappsats);
img_SetAttributes (iHndl, knappsats, I_TOUCH_DISABLE); Inaktivera tangentbordet touch
img_SetWord (iHndl, knappsats, IMAGE_INDEX, 10); Ange 10. ram, knappen upp (opressad) tillstånd
gfx_Set(BEVEL_SHADOW,oldshadow);
annat
img_ClearAttributes (iHndl, knappsats, I_TOUCH_DISABLE); Aktivera knappsatsen touch
keyval: = 10; till en början anta ingen nyckel pressat, Välj sista bildrutan
IF(State == TOUCH_PRESSED)
calc vilken knapp trycks
x1: = 4 + img_GetWord (iHndl, knappsats, IMAGE_XPOS);
Y1: = 4 + img_GetWord (iHndl, knappsats, 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. Vi vet var knappsatsen är, använda bara fasta värden för att spara codespace
yoffs: = 16.
för (y: = y1; y < y1 + yoffs * 4; y += yoffs) / / nu hitta touch co-ord
för (x: = x1; x < x1 + xoffs * 3; x += xoffs)
n ++;
om (mx > x & & mx < x + xoffs & & min > y & & min < y + yoffs) k: = n;
Nästa
IF(k) semester.
Nästa
IF(k) / / om vi fick en giltig nyckel
keyval: = nycklar [k - 1]; få nyckeln val
r: = xlat [edstate - 1]; Peka på rätt register
Temp: = Clock.time[r]; flytta och lägga till nya siffran
Temp: = ((temp << 4) & 0xF0) + keyval;
Clock.Time[r]: = härda;
Clock.Edit & = ~ (charpos << ((edstate-1) << 1)); ändra understreck
charpos: = 1;
Clock(); uppdatera 7seg exempel
endif

endif
img_SetWord (iHndl, knappsats, IMAGE_INDEX, keyval); Set krävs ram, om 10 ram, det är knappen upp (opressad) staten
endif
img_Show (iHndl, knappsats);

endfunc

Visa tid normalt om redigera == 0, annars visar krävs understreck.
varje bit i var edit coresponds till en understrykning visas, bit5 är
siffran 1 CEN. bit 0 = siffran 6
FUNC Clock()
PAUSE(1000);
var privat redigera; i redigeringsläget, väljer bitar 5:0 uderscores för siffrorna 6:1
var privat tid [3]. tid i BCD-format, coresponds att klocka registrerar sekunder, minuter, timmar
var k, n, xpos, regptr;

#constant X 22 / / x-position för tiden
#constant Y 32 / / y läge för tiden
#constant W 22 / / siffra bredd

img_Enable (iHndl, SEG7); Aktivera 7seg visning medan vi Visa det
Xpos: = X; Ange start x
regptr: = timmar; börja på timmar
medan (n < 6)
img_SetPosition (iHndl, SEG7, xpos, Y); Ange position för siffra
om ((Redigera >> n) & 1) / / om redigering siffra,
k: = 11; Välj understreck
annat
k: = tid [regptr]; annars få krävs tid register
om (! () n & 1)) k: = k >> 4. få HI nibble om Hej siffra
endif
img_SetWord (iHndl, SEG7, IMAGE_INDEX, k & 15); Välj krävs siffror

img_Show (iHndl, SEG7); Visa bild
Xpos += W;
n ++;
om (n == 2 || n == 4) / / vid behov
regptr--; dekrement registrera pekaren
Xpos += 4.
gfx_RectangleFilled (xpos, Y + 10, xpos + 4, Y + 14, ORANGE); Placera kolon
gfx_RectangleFilled (xpos, Y + 20, xpos + 4, Y + 24, ORANGE);
Xpos += 10.
endif
wend
img_Disable (iHndl, SEG7); Vi är klar visar, inaktivera 7seg visning
endfunc

Kontrollera att fiskens som redigerats bara är ok
snabb med ett kort meddelande om utanför intervallet,
ställa in redigeringsfältet tillbaka till samma pos för ett nytt försök.
Returnerar noll om misslyckades
FUNC checkRegisters()
var reg, retval: = TRUE;
IF(edstate)
REG: = xlat [edstate-1].
om (Clock.time [reg] > maxval[reg]) / / kolla för förnuftiga värde
gfx_MoveTo(90,3);
txt_FGcolour(Red); om inte, kasta meddelandet
putstr("ERROR\r");
PAUSE(500);
putstr("");
edstate--; och backup så vi stanna i nuvarande redigeringsfältet
retval: = FALSE;
endif
endif
returnera retval;
endfunc

FUNC main)
var n, c, colr: = grå;
var staten.
var utresa.

var igen: = 10;
medan (försök igen--& &! file_Mount()); montera enheten
om (! igen)
putstr ("Mount misslyckades!");
PAUSE(2000);
hemkomst. avsluta om inte montera
endif

iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1); bygga bildkontrollen hjälp krävs läge, returnerar en pekare till struktur fördelningen
om (! iHndl)
PAUSE(2000);
hemkomst. avsluta om kan inte ladda bild-kontroll
endif

I2C_Open(I2C_SLOW); 100khz
I2C_Open(I2C_MED); 400khz
I2C_Open(I2C_FAST); 1mhz NB DS1307 kan inte köra på 1mhz!

PAUSE(10);

n:=readbyte(seconds) & 0x7F; se CH bit är klart annars klocka kommer inte att köra
WriteByte(seconds, n);

PAUSE(1000);
gfx_Cls();

img_Disable(iHndl, all); först upp, inaktivera alla bilder

nu möjligt behöver vi
img_Enable (iHndl, knappsats); Vi vill att knappsatsen
img_Enable (iHndl, ADDBTN);
img_Enable (iHndl, EXITBTN); Vi vill på exit-knappen
img_Enable (iHndl, CLOCKBTN); Vi vill ha knappen tid

gfx_Origin(30,15);

gfx_Panel (PANEL_RAISED, 0, 0, 200, 17, mörkblå); namnlist
gfx_Panel (PANEL_RAISED, 0, 18, 200, 150, grå); huvudfönstret i panelen
img_SetPosition (iHndl, EXITBTN, 184, 2); Placera på exit-knappen
gfx_MoveTo(8,3);
txt_Opacity(OPAQUE);
txt_BGcolour(DARKBLUE);
txt_FGcolour(cyan);
putstr ("Set tid"); Placera titeln

7 seg uppvisning panel
gfx_Panel (PANEL_SUNKEN, 15, 24, 170, 50, grå);
gfx_Panel (PANEL_RAISED, 19, 28, 162, 42, SEG7_BG_COLOUR);

img_SetPosition (iHndl, knappsats, 40, 85); Placera knappsatsen
img_SetPosition (iHndl, CLOCKBTN, 140, 90); Placera knappen tid
img_SetPosition (iHndl, CHECKBTN, 138, 130); Placera på exit-knappen (dold till redigering)
img_SetPosition (iHndl, ADDBTN, 3, 100);
gfx_Button (BUTTON_UP, 3, 100, SILVER, röd, FONT1, 1, 1, "Set");

img_Show(iHndl, all); uppdatera bilder
gfx_Rectangle (90-140, 163, 111, röd); Placera röd rektangel runt tidsknappen (låst tillstånd)

Keypad(0);

touch_Set(TOUCH_ENABLE); Aktivera pekskärmen
Clock();

While(!Exit) / / bo i slinga til avsluta knappen hit

om (Clock.edit == 0 & & edstate == 0) / / om vi inte edition
c: = sekunder. om sekunder har rullat
IF(c!=Clock.Time[seconds])

Clock.Time[seconds]: = sekunder. Läs klocka chip
Clock.Time[Minutes]: = minuter;
Clock.Time[hours]: = timmar;
Clock();

endif
endif

staten: = touch_Get(TOUCH_STATUS); Vi ska se för någon touch verksamhet
MX: = touch_Get(TOUCH_GETX); Vi ska också ta tag i x
min: = touch_Get(TOUCH_GETY); och y-koordinaterna för beröring

IF(State == TOUCH_PRESSED) / / om det finns en press
n: = img_Touched(iHndl, ALL); se om någon profilen berördes
om (n! = -1)
IF(n == KEYPAD) / / om knappsatsen var rörd,
Keypad(State); uppdatera knappsats
annat
img_Lighten (iHndl, n); annars bara ljusare när vi berör
img_Show (iHndl, n);
endif
endif
gfx_Rectangle (90-140, 163, 111, colr); Placera rektangel runt klockan btn
endif

IF(State == TOUCH_MOVING) / / om det finns rörelse
endif

IF(State == TOUCH_RELEASED) / / om det finns en utgåva;
om (n! = -1)

IF(n==EXITBTN) utgång: = 1; avsluta om exit knappen hit

IF(n==CHECKBTN) / / om check knappen hit
IF(checkRegisters()) / / om senaste redigeringen var ok
sekunder: = Clock.time[SECONDS]; Skriv sekunder + håll
minuter: = Clock.time[MINUTES]; skriva minuter
timmar: = Clock.time[HOURS]; Skriv timmar
seconds2: = Clock.time[SECONDS]; Skriv sekunder + håll
minutes2: = Clock.time[MINUTES]; skriva minuter
timmar2: = Clock.time[HOURS]; Skriv timmar
n:=readbyte(seconds) & 0x7F; utgivnings håll
WriteByte(seconds, n);
PAUSE(100);
Clock.Edit: = 0; inte redigering nu, kör mode
edstate: = 0;
Colr: = röd;
img_Disable (iHndl, CHECKBTN); Inaktivera check knappen
gfx_RectangleFilled (138, 130, 138 + 28, 130 + 28, grå); radera knappen Kontrollera
Clock();
Keypad(0);
annat
n: = CLOCKBTN; annat fel, gör om nuvarande redigera fas
endif
endif

IF(n==ADDBTN)
om (kkl == 0)
Main ();
KKL: = 1;
endif
om (kkl == 1)
KKL: = 2;
endif
om (kkl == 2)
gfx_Cls();
iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1);
om (! iHndl)
PAUSE(2000);
hemkomst.
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]; Skriv sekunder + håll
minutes2: = Clock.time[MINUTES]; skriva minuter
timmar2: = Clock.time[HOURS]; Skriv timmar
kJ: = 1;
endif
endif

IF(n == CLOCKBTN)
img_Darken (iHndl, CLOCKBTN);
img_Show (iHndl, CLOCKBTN);
checkRegisters(); Kontrollera om det finns rättsliga värden
om (++ edstate == 4) edstate: = 1; Bläddra igenom redigeringsfält
Clock.Edit: = 3 << ((edstate-1) << 1); anger krävs bitar hög i Redigera register
Keypad.charpos: = 2; börja redigera minst siffran
Clock.Time[xlat [edstate-1]]: = 0; noll Anläggningsregister redo
img_Enable (iHndl, CHECKBTN); Aktivera check knappen
img_Show (iHndl, CHECKBTN); Visa den
gfx_Rectangle (138, 130, 138 + 27, 130 + 27, grå); rektangeln bli av dessa irriterande justering prickar
Colr: = kalk;
Clock();
Keypad(State);
endif

IF(n == KEYPAD) / / om knappsatsen släpper
Keypad(State); uppdatera tillstånd
endif

endif
gfx_Rectangle (90-140, 163, 111, colr); Placera rektangel runt klockan btn
n: = -1;
endif
Setup();
wend
setupclock();
endfunc

FUNC setup()
om (exit2 == 1 & & kj == 1)
kJ: = 0;
txt_Set (TEXT_OPACITY, OGENOMSKINLIG);
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, SOLID);
gfx_Circle (xc, yc, r-16, FACECOLOUR);
gfx_Set (PEN_SIZE, disposition);
n: = -8;
medan (n ++ < 8)
Colr: = grön,
gfx_Circle (xc yc, r + n-8, colr);
wend

Ställ in mittpunkten
gfx_MoveTo (OLC, yc);

en variabel som mål för kommandot orbit
gfx_OrbitInit (& targetX, & targetY);

Markera timmarna runt clockface
gfx_Set (PEN_SIZE, SOLID);
gfx_MoveTo (OLC, yc);
n: = -90; klockan 12 position
medan (n < 270)
gfx_Orbit n, r-6.
k: = 3;
om (! () n % 90)) k: = 5;
gfx_Circle (targetX, targetY, k, blå);
n: = n + 30. varje 30 degreees
wend
KKL: = 0;

setupclock();
Touch();
annat
setupclock();
endif
endfunc

FUNC setupclock()
sekunder: = 80.
minuter: = 89.
timmar: = 18;
Upprepa
om (Clock.edit == 0 & & edstate == 0)
PAUSE(1000);
om (kkl == 1)
skriva ut ("The Time", [DEC1Z] timmar, ":", [DEC2Z] minuter, ":", [DEC2Z] sekunder);
sekunder
om (sekunder == 9)
sekunder: = sekunder + 6.
endif / / 25, 40, 55
om (sekunder == 25)
sekunder: = sekunder + 6.
endif
om (sekunder == 41)
sekunder: = sekunder + 6.
endif
om (sekunder == 57)
sekunder: = sekunder + 6.
endif
om (sekunder == 73)
sekunder: = sekunder + 6.
endif
minuter
om (minuter == 9)
minuter: = minuter + 7.
endif / / 25, 40, 55
om (minuter == 25)
minuter: = minuter + 7.
endif
om (minuter == 41)
minuter: = minuter + 7.
endif
om (minuter == 57)
minuter: = minuter + 7.
endif
om (minuter == 73)
minuter: = minuter + 7.
endif
timmar
om (timmar == 9)
timmar: = timmar + 7.
endif
om (! () sekunder: = (++ sekunder % 90)))
om (! () minuter: = (++ minuter % 90)))

om (timmar == 18)
timmar: = 0;
endif
timmar: = (++ timmar % 19);
endif
endif
endif
Clock.Time[seconds]: = sekunder. Läs klocka chip
Clock.Time[Minutes]: = minuter;
Clock.Time[hours]: = timmar;
Clock(); / / uppdatera tiden
hemkomst.
endif

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

DrawHand (r-20, seconds2 * 6, FACECOLOUR); undraw den andra handen

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

DrawHand (r-50, timmar2 * 30 + minutes2 >> 1, FACECOLOUR); undraw timvisaren

gfx_Circle (OLC, yc, 5, FACECOLOUR);

beräkna den nya tiden
Observera att detta var buggy,
om (! () seconds2: = (++ seconds2% 60)))
om (! () minutes2: = (++ minutes2% 60)))
timmar2: = (++ timmar2% 12);
endif
endif

display_Vsync();
DrawHand (r-20, seconds2 * 6, SECONDSCOLOUR); Rita om den andra handen
DrawHand (r-35, minutes2 * 6 + seconds2/10, MINUTESCOLOUR); Rita om minutvisaren
DrawHand (r-50, timmar2 * 30 + minutes2 >> 1, HOURSCOLOUR); Rita om timvisaren
gfx_Circle (OLC, yc, 5, ORANGE);
hemkomst.
Touch();
hemkomst.
endif
annat
hemkomst.
tag (!. Clock.Edit == 0 & &! edstate == 0)
PAUSE(100);

wend

endif
för evigt
endfunc

FUNC touch()
touch_Set(TOUCH_ENABLE); Aktivera pekskärmen
Clock();

Upprepa
var n, colr: = röd;
var staten.
staten: = touch_Get(TOUCH_STATUS); Vi ska se för någon touch verksamhet
MX: = touch_Get(TOUCH_GETX); Vi ska också ta tag i x
min: = touch_Get(TOUCH_GETY); och y-koordinaterna för beröring

IF(State == TOUCH_PRESSED) / / om det finns en press
n: = img_Touched(iHndl, ALL); se om någon profilen berördes
IF(State == TOUCH_RELEASED) / / om det finns en utgåva;
om (n! = -1)

IF(n==ADDBTN)

Main ();
KKL: = 0;
exit2: = 0;
endif
endif
endif
endif
hemkomst.
för evigt
endfunc