Étape 4: programmation
Voici le programme
#platform « uLCD-32PT_GFX2 »
#inherit « 4DGL_16bitColours.fnc »
#inherit « FONT4.fnt »
#constant FALSE, TRUE / / FALSE = 0, vrai = 1
#STACK 100
étiquettes d’image de ce que nous utilisons dans GFX2DEMO. GCI (index de contrôle image)
#constant SEG7 0
#constant clavier 1
#constant EXITBTN 4
#constant ADDBTN 8
#constant CHECKBTN 15
#constant CLOCKBTN 27
registres de l’horloge
#constant secondes 0
#constant MINUTES 1
#constant heures 2
DS1307 #constant 0xD0
#constant WR 1
var secondes, minutes, heures ;
#constant SEG7_BG_COLOUR 0x0841 / / 7 seg affichage couleur de fond
var iHndl ; poignée de contrôle d’image
var mx, my ; souris tactile/position
var edstate ; horloge état de modification, 1 = HH, 2 = MM, 3 = SS
hFile var ;
#constant FACECOLOUR rouge
#constant SECONDSCOLOUR blanc
#constant MINUTESCOLOUR jaune
#constant HOURSCOLOUR bleu
variables globales
var seconds2, minutes2, heures2 ;
var targetX, targetY ;
var screenwidth, screenheight ;
var xc, yc, r ;
var n, x, y, k, colr, t, kj: = 1 ;
kkl var: = 1 ;
exit2 var: = 0 ;
var firstx, firsty, x 2, y2, state2 ;
var set_timeButtonX, set_timeButtonY ;
carte des valeurs de clé pour clavier
#DATA
touches d’octets 7,8,9,4,5,6,1,2,3,0,0,0
#END
valeur de Registre Max temps pour contrôle edit
#DATA
maxval octet 0 x 59, 0 x 59, 0 x 23
#END
définition de pos edit registre requis
#DATA
mot xlat heures, MINUTES, secondes
#END
Func DrawHand (longueur du var, var angle, couleur du var)
gfx_MoveTo (xc, yc) ; DOIT RE_ESTABLISH LE POINT DE CENTRE!!!
gfx_Set (OBJECT_COLOUR, couleur) ;
gfx_Orbit (angle -90, longueur) ;
gfx_LineRel (targetX, targetY) ; FAUX ! Héritage de Picasso avait un gfx_LineRel brisé qui fonctionnait bien ici,
gfx_LineTo (targetX, targetY) ; mais il doit être gfx_LineTo, ce n’est maintenant correct
ENDFUNC
Func clavier (État du var)
var PosCar privé ;
var temp, r, n, x, y, k, x 1, y1, xoffs, yoffs, oldshadow ;
var keyval privé ;
if (!. Clock.Edit)
if(!edstate)
PosCar: = 2 ;
oldshadow: = gfx_Set(BEVEL_SHADOW,1) ;
img_Darken (iHndl, clavier) ;
img_SetAttributes (iHndl, clavier, I_TOUCH_DISABLE) ; désactiver la touche du clavier
img_SetWord (iHndl, clavier, IMAGE_INDEX, 10) ; définir la trame 10e, boutonnez (non enfoncées)
gfx_Set(BEVEL_SHADOW,oldshadow) ;
d’autre
img_ClearAttributes (iHndl, clavier, I_TOUCH_DISABLE) ; activer la touche du clavier
keyVal: = 10 ; au départ, n’assumer aucune image clé enfoncée, sélectionnez dernière
if(State == TOUCH_PRESSED)
Calc qui touche
x1: = 4 + img_GetWord (iHndl, clavier, IMAGE_XPOS) ;
Y1: = 4 + img_GetWord (iHndl, clavier, 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 ; Nous savons où est le clavier, il suffit d’utiliser des valeurs fixes pour sauver codespace
yoffs: = 16 ;
pour (y: = y1; y < y1 + yoffs * 4; y += yoffs) / / maintenant trouver touch co-ord
pour (x: = x1; x < x1 + xoffs * 3; x += xoffs)
n ++ ;
Si (mx > x & & mx < x + xoffs & & ma > y & & mon < y + yoffs) k: = n ;
prochaine
if(k) Pause ;
prochaine
if(k) / / si nous avons obtenu une clé valide
keyVal: = touches [k - 1] ; obtenir la clé val
r: = xlat [edstate - 1] ; pointez sur Registre correcte
Temp: = Clock.time[r] ; passer et ajouter de nouveaux chiffres
Temp: = ((temp << 4) & 0xF0) + keyval ;
Clock.Time[r]: = temp ;
Clock.Edit & = ~ (PosCar << ((edstate-1) << 1)) ; modifier le caractère de soulignement
PosCar: = 1 ;
Clock() ; mise à jour 7seg affichage
endif
endif
img_SetWord (iHndl, clavier, IMAGE_INDEX, keyval) ; Set cadre requis, si trame 10e, c’est le bouton État (non pressé)
endif
img_Show (iHndl, clavier) ;
ENDFUNC
afficher le temps normalement si modifier == 0, sinon montrer nécessaire trait de soulignement.
chaque bit dans var edit coresponds à un trait de soulignement affichée, bit5 est
chiffre 1 downto bit 0 = chiffre 6
Func Clock()
Pause(1000) ;
private var modifier ; mode d’édition, bits 5:0 sélectionne uderscores pour chiffres 6:1
var temps privé [3] ; heure au format BCD, coresponds à l’horloge enregistre secondes, MINUTES, heures
var k, n, xpos, regptr ;
#constant X 22 / / position de temps x
#constant Y 32 / / y position pour fois
#constant 22 W / / largeur des chiffres
img_Enable (iHndl, SEG7) ; activer l’affichage de 7seg tandis que nous lafficher
XPos: = X ; à partir de la valeur x
regptr: = heures ; départ à heures
alors que (n < 6)
img_SetPosition (iHndl, SEG7, xpos, Y) ; position réglée pour le chiffre
Si ((edit >> n) & 1) / / si la modification des chiffres,
k: = 11 ; Sélectionnez le caractère de soulignement
d’autre
k: = temps [regptr] ; obtenir d’autre registre de temps requis
Si (! () k n & 1)): = k >> 4 ; Obtenez le grignotement HI si Salut à chiffres
endif
img_SetWord (iHndl, SEG7, IMAGE_INDEX, k & 15) ; sélectionner les chiffres requis
img_Show (iHndl, SEG7) ; montrer l’image
XPos += W ;
n ++ ;
Si (n == 2 || n == 4) / / si nécessaire,
regptr--; Decrement, registre de pointeur
XPos += 4 ;
gfx_RectangleFilled (xpos, Y + 10, xpos + 4, Y + 14, ORANGE) ; Placer deux points
gfx_RectangleFilled (xpos, Y + 20, xpos + 4, Y + 24, ORANGE) ;
XPos += 10 ;
endif
Wend
img_Disable (iHndl, SEG7) ; Nous avons fini affichage, désactivez l’affichage de 7seg
ENDFUNC
Vérifiez que le calue juste modifié est ok
invite avec un message d’erreur court si hors de portée,
définissant le champ d’édition au même point de vente pour un autre essai.
retourne zéro si a échoué
Func checkRegisters()
var reg, retval: = TRUE ;
if(edstate)
Reg: = xlat [edstate-1] ;
Si (Clock.time [reg] > maxval[reg]) / / vérifier une valeur raisonnable
gfx_MoveTo(90,3) ;
txt_FGcolour(Red) ; Sinon, jetez le message
putstr("ERROR\r") ;
Pause(500) ;
putstr("") ;
edstate--; et de sauvegarde, donc nous restons dans le champ d’édition actuel
retval: = FALSE ;
endif
endif
Return retval ;
ENDFUNC
main() Func
var n, c, colr: = gris ;
var Etat ;
sortie du var ;
nouvelle tentative var: = 10 ;
tandis que (nouvelle tentative--& &! file_Mount()) ; monter le lecteur
Si (! réessayer)
putstr ("Mount Failed!") ;
Pause(2000) ;
retour ; Si la sortie ne peut pas monter
endif
iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1) ; générer le contrôle de l’image en utilisant le mode souhaité, retournant un pointeur à l’attribution de la structure
Si (! iHndl)
Pause(2000) ;
retour ; Si la sortie ne peut pas charger le contrôle image
endif
I2C_Open(I2C_SLOW) ; 100khz
I2C_Open(I2C_MED) ; 400khz
I2C_Open(I2C_FAST) ; 1mhz NB DS1307 peut ne pas fonctionner à 1mhz!!!
Pause(10) ;
n:=ReadByte(seconds) & 0x7F ; s’assurer que le bit CH est clair sinon l’horloge ne fonctionne
WriteByte(seconds, n) ;
Pause(1000) ;
gfx_Cls() ;
img_Disable(iHndl, All) ; tout d’abord, désactivez toutes les images
Activez maintenant ce que nous devons
img_Enable (iHndl, clavier) ; Nous voulons que le clavier
img_Enable (iHndl, ADDBTN) ;
img_Enable (iHndl, EXITBTN) ; Nous voulons que le bouton exit
img_Enable (iHndl, CLOCKBTN) ; Nous voulons que le bouton time
gfx_Origin(30,15) ;
gfx_Panel (PANEL_RAISED, 0, 0, 200, 17, bleu-foncé) ; barre de titre
gfx_Panel (PANEL_RAISED, 0, 18, 200, 150, gris) ; panneau de la fenêtre principale
img_SetPosition (iHndl, EXITBTN, 184, 2) ; Placez le bouton exit
gfx_MoveTo(8,3) ;
txt_Opacity(opaque) ;
txt_BGcolour(DARKBLUE) ;
txt_FGcolour(cyan) ;
putstr ("Set Time") ; Placer le titre
panneau d’affichage 7 seg
gfx_Panel (PANEL_SUNKEN, 15, 24, 170, 50, gris) ;
gfx_Panel (PANEL_RAISED, 19, 28, 162, 42, SEG7_BG_COLOUR) ;
img_SetPosition (iHndl, clavier, 40, 85) ; Placez le clavier
img_SetPosition (iHndl, CLOCKBTN, 140, 90) ; Placez le bouton time
img_SetPosition (iHndl, CHECKBTN, 138, 130) ; Placer le bouton de sortie (caché jusqu’au montage)
img_SetPosition (iHndl, ADDBTN, 3, 100) ;
gfx_Button (BUTTON_UP, 3, 100, argent, rouge, FONT1, 1, 1, « Set ») ;
img_Show(iHndl, All) ; mise à jour des images
gfx_Rectangle (140, 163, 90 et 111, rouge) ; Placez un rectangle rouge autour du bouton (état verrouillé) de l’horloge
Keypad(0) ;
touch_Set(TOUCH_ENABLE) ; activer l’écran tactile
Clock() ;
while(!Exit) / / séjour en boucle til hit bouton quitter
Si (Clock.edit == 0 & & edstate == 0) / / si nous ne sommes pas edition
c: = s ; Si secondes a basculé
if(c!=Clock.Time[seconds])
Clock.Time[seconds]: = s ; lire la puce d’horloge
Clock.Time[minutes]: = minutes ;
Clock.Time[hours]: = heures ;
Clock() ;
endif
endif
Etat: = touch_Get(TOUCH_STATUS) ; Nous allons étudier pour toute activité tactile
MX: = touch_Get(TOUCH_GETX) ; Nous allons également saisir le x
ma: = touch_Get(TOUCH_GETY) ; et les coordonnées y de la touche
if(State == TOUCH_PRESSED) / / s’il y a une presse
n: = img_Touched(iHndl, ALL) ; voir si toutes les images ont été touchés
Si (n! = -1)
if(n == Keypad) / / si le clavier a été touché,
Keypad(State) ; mise à jour du clavier
d’autre
img_Lighten (iHndl, n) ; Sinon, juste éclaircir lorsque nous touchons
img_Show (iHndl, n) ;
endif
endif
gfx_Rectangle (140, 163, 90 et 111, colr) ; Placez le rectangle rond horloge btn
endif
if(State == TOUCH_MOVING) / / s’il y a mouvement
endif
if(State == TOUCH_RELEASED) / / si il y a une version ;
Si (n! = -1)
sortie if(n==EXITBTN): = 1 ; Si la sortie sortie bouton hit
if(n==CHECKBTN) / / si vérifier le bouton hit
if(checkRegisters()) / / si la dernière édition a été autorisée
secondes: = Clock.time[SECONDS] ; écrire secondes + tenir
minutes: = Clock.time[MINUTES] ; écrire des minutes
heures: = Clock.time[HOURS] ; écrire des heures
seconds2: = Clock.time[SECONDS] ; écrire secondes + tenir
minutes2: = Clock.time[MINUTES] ; écrire des minutes
heures2: = Clock.time[HOURS] ; écrire des heures
n:=ReadByte(seconds) & 0x7F ; Communiqué de cale
WriteByte(seconds, n) ;
Pause(100) ;
Clock.Edit: = 0 ; maintenant, ne pas l’édition mode d’exécution
edstate: = 0 ;
colr: = rouge ;
img_Disable (iHndl, CHECKBTN) ; désactiver le bouton de contrôle
gfx_RectangleFilled (138, 130, 138 + 28, 130 + 28, GRAY) ; effacer le bouton check
Clock() ;
Keypad(0) ;
d’autre
n: = CLOCKBTN ; autre erreur, refaire le phase édition actuelle
endif
endif
if(n==ADDBTN)
Si (kkl == 0)
main() ;
KKL: = 1 ;
endif
Si (kkl == 1)
KKL: = 2 ;
endif
Si (kkl == 2)
gfx_Cls() ;
iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1) ;
Si (! iHndl)
Pause(2000) ;
retour ;
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] ; écrire secondes + tenir
minutes2: = Clock.time[MINUTES] ; écrire des minutes
heures2: = Clock.time[HOURS] ; écrire des heures
kJ: = 1 ;
endif
endif
if(n == CLOCKBTN)
img_Darken (iHndl, CLOCKBTN) ;
img_Show (iHndl, CLOCKBTN) ;
checkRegisters() ; Recherchez les valeurs juridiques
Si (++ edstate == 4) edstate: = 1 ; faire défiler les champs edit
Clock.Edit: = 3 << ((edstate-1) << 1) ; Définissez les bits requis élevés dans edit Registre
Keypad.charpos: = 2 ; début modifier le chiffre le moins significatif
Clock.Time[Xlat [edstate-1]]: = 0 ; zéro le registre d’exploitation prêt
img_Enable (iHndl, CHECKBTN) ; activez le bouton de contrôle
img_Show (iHndl, CHECKBTN) ; Affichez-la
gfx_Rectangle (138, 130, 138 + 27, 130 + 27, GRAY) ; rectangle pour se débarrasser de ces ennuyeux points d’alignement
colr: = chaux ;
Clock() ;
Keypad(State) ;
endif
if(n == Keypad) / / si le pavé numérique de sortie
Keypad(State) ; État de la mise à jour
endif
endif
gfx_Rectangle (140, 163, 90 et 111, colr) ; Placez le rectangle rond horloge btn
n: = -1 ;
endif
Setup() ;
Wend
setupclock() ;
ENDFUNC
Func setup()
Si (exit2 == 1 & & kj == 1)
kJ: = 0 ;
txt_Set (TEXT_OPACITY, OPAQUE) ;
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, solides) ;
gfx_Circle (xc, yc, r-16, FACECOLOUR) ;
gfx_Set (PEN_SIZE, esquisse) ;
n: = -8 ;
tandis que (< 8 n ++)
colr: = vert ;
gfx_Circle (xc, yc, r + n-8, colr) ;
Wend
mettre en place le point central
gfx_MoveTo (xc, yc) ;
une variable cible de la commande orbite
gfx_OrbitInit (& targetX, & targetY) ;
marquer les heures autour du cadran d’horloge
gfx_Set (PEN_SIZE, solides) ;
gfx_MoveTo (xc, yc) ;
n: = -90 ; position de 12:00
tandis que (n < 270)
gfx_Orbit (n, r-6) ;
k: = 3 ;
Si (! () % n 90)) k: = 5 ;
gfx_Circle (targetX, targetY, k, bleu) ;
n: = n + 30 ; chaque 30 degreees
Wend
KKL: = 0 ;
setupclock() ;
Touch() ;
d’autre
setupclock() ;
endif
ENDFUNC
Func setupclock()
secondes: = 80 ;
minutes: = 89 ;
heures: = 18 ;
Répétez
Si (Clock.edit == 0 & & edstate == 0)
Pause(1000) ;
Si (kkl == 1)
imprimer (« The Time is », heures [DEC1Z], «: », [DEC2Z] minutes, ":", [DEC2Z] secondes) ;
secondes
Si (secondes == 9)
secondes: = secondes + 6 ;
endif / / 25, 40, 55
Si (secondes == 25)
secondes: = secondes + 6 ;
endif
Si (secondes == 41)
secondes: = secondes + 6 ;
endif
Si (secondes == 57)
secondes: = secondes + 6 ;
endif
Si (secondes == 73)
secondes: = secondes + 6 ;
endif
minutes
Si (minutes == 9)
minutes: = minutes + 7 ;
endif / / 25, 40, 55
Si (minutes == 25)
minutes: = minutes + 7 ;
endif
Si (minutes == 41)
minutes: = minutes + 7 ;
endif
Si (minutes == 57)
minutes: = minutes + 7 ;
endif
Si (minutes == 73)
minutes: = minutes + 7 ;
endif
heures
Si (heures == 9)
heures: = heures + 7 ;
endif
Si (! () secondes: = (++ secondes 90 %)))
Si (! () minutes: = (++ minutes 90 %)))
Si (heures == 18)
heures: = 0 ;
endif
heures: = (++ % heures 19) ;
endif
endif
endif
Clock.Time[seconds]: = s ; lire la puce d’horloge
Clock.Time[minutes]: = minutes ;
Clock.Time[hours]: = heures ;
Clock(); / / mise à jour de l’heure
retour ;
endif
Si (kkl == 2 & & exit2 == 1)
DrawHand (r-20, seconds2 * 6, FACECOLOUR) ; undraw l’aiguille des secondes
DrawHand (r-35, minutes2 * 6 + seconds2/10, FACECOLOUR) ; undraw l’aiguille des minutes
DrawHand (r-50, heures2 * 30 + minutes2 >> 1, FACECOLOUR) ; undraw l’aiguille des heures
gfx_Circle (xc, yc, 5, FACECOLOUR) ;
calculer le temps nouveau
Notez qu’il s’agissait de buggy,
Si (! () seconds2: = (++ seconds2 % 60)))
Si (! () minutes2: = (++ minutes2 % 60)))
heures2: = (++ heures2 %12) ;
endif
endif
display_Vsync() ;
DrawHand (r-20, seconds2 * 6, SECONDSCOLOUR) ; redessiner la trotteuse
DrawHand (r-35, minutes2 * 6 + seconds2/10, MINUTESCOLOUR) ; redessiner l’aiguille des minutes
DrawHand (r-50, heures2 * 30 + minutes2 >> 1, HOURSCOLOUR) ; redessiner l’aiguille des heures
gfx_Circle (xc, yc, 5, ORANGE) ;
retour ;
Touch() ;
retour ;
endif
d’autre
retour ;
while (!. Clock.Edit == 0 & &! edstate == 0)
Pause(100) ;
Wend
endif
pour toujours
ENDFUNC
Func touch()
touch_Set(TOUCH_ENABLE) ; activer l’écran tactile
Clock() ;
Répétez
var n, colr: = rouge ;
var Etat ;
Etat: = touch_Get(TOUCH_STATUS) ; Nous allons étudier pour toute activité tactile
MX: = touch_Get(TOUCH_GETX) ; Nous allons également saisir le x
ma: = touch_Get(TOUCH_GETY) ; et les coordonnées y de la touche
if(State == TOUCH_PRESSED) / / s’il y a une presse
n: = img_Touched(iHndl, ALL) ; voir si toutes les images ont été touchés
if(State == TOUCH_RELEASED) / / si il y a une version ;
Si (n! = -1)
if(n==ADDBTN)
main() ;
KKL: = 0 ;
exit2: = 0 ;
endif
endif
endif
endif
retour ;
pour toujours
ENDFUNC
