Paso 4: programación
Este es el programa
#platform "uLCD-32PT_GFX2"
#inherit "4DGL_16bitColours.fnc"
#inherit "FONT4.fnt"
#constant FALSE, TRUE / / FALSE = 0, verdadero = 1
#STACK 100
Etiquetas de imagen para lo que utilizamos en GFX2DEMO. GCI (índices de control de imagen)
#constant SEG7 0
#constant teclado 1
#constant EXITBTN 4
#constant ADDBTN 8
#constant CHECKBTN 15
#constant CLOCKBTN 27
registros del reloj
#constant segundos 0
#constant minutos 1
HORAS de #constant 2
#constant DS1307 0xD0
#constant WR 1
var segundos, minutos, horas;
#constant SEG7_BG_COLOUR 0x0841 / / 7 seg color de fondo de pantalla
var iHndl; palanca de control de imagen
var mx, mi; posición del ratón táctil
var edstate; reloj Editar estado, 1 = HH, 2 mm, 3 = SS
hFile var;
#constant FACECOLOUR rojo
#constant SECONDSCOLOUR blanco
#constant MINUTESCOLOUR amarillo
#constant HOURSCOLOUR azul
variables globales
var segundos2, minutos2, horas2;
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, campos, x 2, y2, state2;
var set_timeButtonX, set_timeButtonY;
mapa de los valores claves de teclado
#DATA
llaves de byte 7,8,9,4,5,6,1,2,3,0,0,0
#END
valor de registro de tiempo máximo para el control de edición
#DATA
maxval byte 0x59, 0x59, 0x23
#END
traducir editar pos requiere registro
#DATA
la palabra xlat horas, minutos, segundos
#END
FUNC DrawHand (var longitud, ángulo de var, var color)
gfx_MoveTo (xc, yc); DEBE RE_ESTABLISH EL PUNTO!!!
gfx_Set (OBJECT_COLOUR, color);
gfx_Orbit (ángulo -90, longitud);
gfx_LineRel (targetX, targetY); MAL! Legado de Picaso tenía un roto gfx_LineRel que funcionó ok
gfx_LineTo (targetX, targetY); pero debe ser gfx_LineTo, esto ahora es correcto
ENDFUNC
FUNC teclado (estado var)
poscaracter privado var;
var temp, r, n, x, y, k, x 1, y1, xoffs, yoffs, oldshadow;
keyval privado var;
if (!. Clock.Edit)
if(!edstate)
poscaracter: = 2;
oldshadow: = gfx_Set(BEVEL_SHADOW,1);
img_Darken (iHndl, teclado);
img_SetAttributes (iHndl, teclado, I_TOUCH_DISABLE); desactivar touch teclado
img_SetWord (iHndl, teclado, IMAGE_INDEX, 10); establecer marco 10, botón encima del estado (no presionado)
gfx_Set(BEVEL_SHADOW,oldshadow);
otra cosa
img_ClearAttributes (iHndl, teclado, I_TOUCH_DISABLE); activar touch teclado
keyval: = 10; al principio, no asumir ninguna clave presionado, seleccionar último fotograma
if(State == TOUCH_PRESSED)
se pulsa el botón Calc
x1: = 4 + img_GetWord (iHndl, teclado, IMAGE_XPOS);
Y1: = 4 + img_GetWord (iHndl, teclado, 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; sabe donde está el teclado, utilice sólo valores fijos para guardar codespace
yoffs: = 16;
para (y: = y1; y < y1 + yoffs * 4; y += yoffs) / / ahora encontrar touch co-ord
para (x: = x1; x < x1 + xoffs * 3; x += xoffs)
n ++;
Si (mx > x & & mx < x + xoffs & & mi > y & & mi < y + yoffs) k: = n;
siguiente
rotura de if(k);
siguiente
if(k) / / si tenemos una clave válida
keyval: = teclas [k - 1]; obtener la clave de val
r: = xlat [edstate - 1]; punto de registro correcta
Temp: = Clock.time[r]; cambiar y agregar nuevos dígitos
Temp: = ((temp << 4) & 0xF0) + keyval;
Clock.Time[r]: = temp;
Clock.Edit & = ~ (poscaracter << ((edstate-1) << 1)); modificar el carácter de subrayado
poscaracter: = 1;
Clock(); actualización de display 7seg
endif
endif
img_SetWord (iHndl, teclado, IMAGE_INDEX, keyval); marco requiere establecer, si marco 10, depende del botón de estado (presionado)
endif
img_Show (iHndl, teclado);
ENDFUNC
Mostrar el tiempo normalmente si editar == 0, Mostrar otro subrayado requiere.
cada uno pedacito en var edición correspondientes a un subrayado muestra, bit5 es
zo de dígito 1 bit 0 = dígito 6
FUNC Clock()
PAUSE(1000);
Editar privado var; modo de edición, 5:0 bits selecciona uderscores para dígitos 6:1
var tiempo privado [3]; hora en formato del BCD, correspondientes al reloj registra segundos, minutos, horas
var k, n, xpos, regptr;
#constant 22 X / / x posición por vez
#constant Y 32 / y posición de tiempo
#constant 22 W / / anchura de dígitos
img_Enable (iHndl, SEG7); habilitar el display de 7seg y nos muestran
XPOS: = X; establecer a partir de x
regptr: = horas; comenzar a las horas
mientras (n < 6)
img_SetPosition (iHndl, SEG7, xpos, Y); posición de dígito
Si ((edit >> n) & 1) / / si edición de dígitos,
k: = 11; Seleccione el carácter de subrayado
otra cosa
k: = tiempo [regptr]; obtener otro registro de tiempo requerido
Si (! () n & 1)) k: = k >> 4; obtener el nibble HI si Hola dígitos
endif
img_SetWord (iHndl, SEG7, IMAGE_INDEX, k & 15); seleccionar dígito requerido
img_Show (iHndl, SEG7); Mostrar la imagen
XPOS += W;
n ++;
Si (n == 2 || n == 4) / / cuando sea necesario,
regptr--; puntero de registro decremento
XPOS += 4;
gfx_RectangleFilled (xpos, Y + 10, xpos + 4 Y + 14, naranja); colon lugar
gfx_RectangleFilled (xpos, Y 20, xpos + 4 Y + 24, naranja);
XPOS += 10;
endif
WEND
img_Disable (iHndl, SEG7); hemos terminado viendo, desactivar el display de 7seg
ENDFUNC
Compruebe que el valor que fue editado sólo es aceptable
proporcione un mensaje de error corto si fuera de rango,
estableciendo el campo de edición a mismo pos para otra oportunidad.
devuelve cero si no
FUNC checkRegisters()
reg de var, retval: = TRUE;
if(edstate)
reg: = xlat [edstate-1];
Si (Clock.time [reg] > maxval[reg]) / / cheque de valor razonable
gfx_MoveTo(90,3);
txt_FGcolour(red); Si no, lanzar el mensaje de
putstr("ERROR\r");
PAUSE(500);
putstr("");
edstate--; y copia de seguridad así que nos quedamos en el campo de edición actual
retval: = FALSE;
endif
endif
volver retval;
ENDFUNC
FUNC main()
var n, c, colr: = gris;
var estado;
var salida;
reintento de var: = 10;
mientras que (Reintentar--& &! file_Mount()); montar la unidad de
Si (! Reintentar)
putstr ("Monte falló!");
PAUSE(2000);
retorno; salir si no puede montar
endif
iHndl: = file_LoadImageControl ("GFX2DEMO. DAT","GFX2DEMO. GCI", 1); construir el control de imagen utilizando el modo necesario, devolver un puntero a la asignación de estructura
Si (! iHndl)
PAUSE(2000);
retorno; salir si no se puede cargar el control de imagen
endif
I2C_Open(I2C_SLOW); 100khz
I2C_Open(I2C_MED); 400khz
I2C_Open(I2C_FAST); 1mhz NB DS1307 no puede funcionar a 1mhz!!!!!!
PAUSE(10);
n:=ReadByte(seconds) & 0x7F; Asegúrese de CH es claro que no funciona el reloj
WriteByte(seconds, n);
PAUSE(1000);
gfx_Cls();
img_Disable(iHndl, All); en primer lugar, desactivar todas las imágenes
ahora permiten lo que necesitamos
img_Enable (iHndl, teclado); queremos que el teclado
img_Enable (iHndl, ADDBTN);
img_Enable (iHndl, EXITBTN); queremos que el botón exit
img_Enable (iHndl, CLOCKBTN); queremos que el botón de tiempo
gfx_Origin(30,15);
gfx_Panel (PANEL_RAISED, 0, 0, 200, 17, azul marino); barra de título
gfx_Panel (PANEL_RAISED, 0, 18, 200, 150, gris); panel de la ventana principal
img_SetPosition (iHndl, EXITBTN, 184, 2); Coloque el botón de salida
gfx_MoveTo(8,3);
txt_Opacity(Opaque);
txt_BGcolour(DARKBLUE);
txt_FGcolour(Cyan);
putstr ("tiempo"); Coloque el título
pantalla de 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, telclado numérico, 40, 85); Coloque el teclado
img_SetPosition (iHndl, CLOCKBTN, 140, 90); Coloque el botón de tiempo
img_SetPosition (iHndl, CHECKBTN, 138, 130); Coloque el botón de salida (ocultado hasta edición)
img_SetPosition (iHndl, ADDBTN, 3, 100);
gfx_Button (BUTTON_UP, 3, 100, plata, rojo, FONT1, 1, 1, "Set");
img_Show(iHndl, All); actualización de imágenes
gfx_Rectangle (140, 163, 90, 111, rojo); colocar un rectángulo rojo alrededor del botón del reloj (estado bloqueado)
Keypad(0);
touch_Set(TOUCH_ENABLE); activar la pantalla táctil
Clock();
while(!Exit) / / estancia en bucle a golpe de botón quit
Si (Clock.edit == 0 & & edstate == 0) / / si no somos edición
c: = segundos; Si el segundos ha rodado
if(c!=Clock.Time[seconds])
Clock.Time[seconds]: = segundos; leer el chip de reloj
Clock.Time[minutes]: = minutos;
Clock.Time[hours]: = horas;
Clock();
endif
endif
Estado: = touch_Get(TOUCH_STATUS); vamos a ver para cualquier actividad de toque
mx: = touch_Get(TOUCH_GETX); También podrá tomar el x
mi: = touch_Get(TOUCH_GETY); y las coordenadas y del toque
if(State == TOUCH_PRESSED) / / si hay una prensa
n: = img_Touched(iHndl, ALL); ver si las imágenes fueron tocadas
Si (n! = -1)
if(n == Keypad) / / si se toca el teclado,
Keypad(State); actualizar teclado
otra cosa
img_Lighten (iHndl, n); otra cosa a aclarar cuando nos toque
img_Show (iHndl, n);
endif
endif
gfx_Rectangle (140, 163, 90, 111, colr); Coloque el rectángulo redondo reloj btn
endif
if(State == TOUCH_MOVING) / / si hay movimiento
endif
if(State == TOUCH_RELEASED) / / si se produce una liberación;
Si (n! = -1)
if(n==EXITBTN) salida: = 1; Si la salida salida botón hit
if(n==CHECKBTN) / / si comprobar golpe de botón
if(checkRegisters()) / / si última edición fue ok
segundos: = Clock.time[SECONDS]; escribir a segundos + hold
minutos: = Clock.time[MINUTES]; escribir minutos
horas: = Clock.time[HOURS]; escribir horas
segundos2: = Clock.time[SECONDS]; escribir a segundos + hold
minutos2: = Clock.time[MINUTES]; escribir minutos
horas2: = Clock.time[HOURS]; escribir horas
n:=ReadByte(seconds) & 0x7F; sala de espera
WriteByte(seconds, n);
PAUSE(100);
Clock.Edit: = 0; edición no de ahora, modo de ejecución
edstate: = 0;
colr: = rojo;
img_Disable (iHndl, CHECKBTN); desactivar el botón check
gfx_RectangleFilled (138, 130, 138 + 28, 130 + 28, gris); borrar el botón check
Clock();
Keypad(0);
otra cosa
n: = CLOCKBTN; otro error, rehacer fase de edición actual
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);
retorno;
endif
img_Disable(iHndl, All);
PAUSE(10);
img_Enable (iHndl, ADDBTN);
img_SetPosition (iHndl, ADDBTN, 30, 10);
img_Show (iHndl, ADDBTN);
exit2: = 1;
segundos2: = Clock.time[SECONDS]; escribir a segundos + hold
minutos2: = Clock.time[MINUTES]; escribir minutos
horas2: = Clock.time[HOURS]; escribir horas
KJ: = 1;
endif
endif
if(n == CLOCKBTN)
img_Darken (iHndl, CLOCKBTN);
img_Show (iHndl, CLOCKBTN);
checkRegisters(); verificación de valores legales
Si (++ edstate == 4) edstate: = 1; recorrer los campos de edición
Clock.Edit: = 3 << ((edstate-1) << 1); alta en registro de edición requiere pedacitos determinados de la
Keypad.charpos: = 2; Inicio editar dígito menos significativo
Clock.Time[xlat [edstate-1]]: = 0; cero el registro de explotación listo
img_Enable (iHndl, CHECKBTN); habilitar el botón check
img_Show (iHndl, CHECKBTN); Mostrar
gfx_Rectangle (138, 130, 138 + 27, 130 + 27, gris); rectángulo para deshacerse de los molestos puntos de alineación
colr: = cal;
Clock();
Keypad(State);
endif
if(n == Keypad) / / si teclado lanzamiento
Keypad(State); Estado de actualización
endif
endif
gfx_Rectangle (140, 163, 90, 111, colr); Coloque el rectángulo redondo reloj btn
n: = -1;
endif
Setup();
WEND
setupclock();
ENDFUNC
setup() FUNC
Si (exit2 == 1 & & kj == 1)
KJ: = 0;
txt_Set (TEXT_OPACITY, opaco);
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, sólidos);
gfx_Circle (xc, yc, r-16, FACECOLOUR);
gfx_Set (PEN_SIZE, contorno);
n: = -8;
mientras (n ++ < 8)
colr: = verde;
gfx_Circle (xc, yc, r + n-8, colr);
WEND
establecer el punto
gfx_MoveTo (xc, yc);
una variable de destino para el comando órbita
gfx_OrbitInit (& targetX & targetY);
marca las horas alrededor del clockface
gfx_Set (PEN_SIZE, sólidos);
gfx_MoveTo (xc, yc);
n: = -90; posición 12:00
mientras (n < 270)
gfx_Orbit (n, r-6);
k: = 3;
Si (! () k n % 90)): = 5;
gfx_Circle (targetX, targetY, k, azul);
n: = n + 30; cada 30 degreees
WEND
KKL: = 0;
setupclock();
Touch();
otra cosa
setupclock();
endif
ENDFUNC
FUNC setupclock()
segundos: = 80;
minutos: = 89;
horas: = 18;
repetir
Si (Clock.edit == 0 & & edstate == 0)
PAUSE(1000);
Si (kkl == 1)
Imprimir ("el tiempo", [DEC1Z] horas, ":", [DEC2Z] minutos, ":", [DEC2Z] segundos);
segundos
Si (segundos == 9)
segundos: = segundos + 6;
endif / / 25, 40, 55
Si (segundos == 25)
segundos: = segundos + 6;
endif
Si (segundos == 41)
segundos: = segundos + 6;
endif
Si (segundos == 57)
segundos: = segundos + 6;
endif
Si (segundos == 73)
segundos: = segundos + 6;
endif
minutos
Si (minutos == 9)
minutos: = minutos + 7;
endif / / 25, 40, 55
Si (minutos == 25)
minutos: = minutos + 7;
endif
Si (minutos == 41)
minutos: = minutos + 7;
endif
Si (minutos == 57)
minutos: = minutos + 7;
endif
Si (minutos == 73)
minutos: = minutos + 7;
endif
horas
Si (horas == 9)
horas: = horas + 7;
endif
Si (! () segundos: = (++ segundos % 90)))
Si (! () minutos: = (++ minutos % 90)))
Si (horas == 18)
horas: = 0;
endif
horas: = (++ horas % 19);
endif
endif
endif
Clock.Time[seconds]: = segundos; leer el chip de reloj
Clock.Time[minutes]: = minutos;
Clock.Time[hours]: = horas;
Clock(); / / actualizar el tiempo
retorno;
endif
Si (kkl == 2 & & exit2 == 1)
DrawHand (segundos2 r-20, * 6, FACECOLOUR); Undraw segunda mano
DrawHand (r-35, minutos2 * 6 + segundos2/10, FACECOLOUR); Undraw el minutero
DrawHand (r-50, horas2 * 30 minutos2 >> 1, FACECOLOUR); Undraw aguja de las horas
gfx_Circle (xc, yc, 5, FACECOLOUR);
calcular el nuevo tiempo
Tenga en cuenta que se trataba de buggy,
Si (! () segundos2: = (++ segundos2% 60)))
Si (! () minutos2: = (++ minutos2% 60)))
horas2: = (++ horas2% 12);
endif
endif
display_Vsync();
DrawHand (segundos2 r-20, * 6, SECONDSCOLOUR); volver a dibujar la segunda mano
DrawHand (r-35, minutos2 * 6 + segundos2/10, MINUTESCOLOUR); volver a dibujar el minutero
DrawHand (r-50, horas2 * 30 minutos2 >> 1, HOURSCOLOUR); volver a dibujar la manecilla de las horas
gfx_Circle (xc, yc, 5, naranja);
retorno;
Touch();
retorno;
endif
otra cosa
retorno;
mientras (!. Clock.Edit == 0 & &! edstate == 0)
PAUSE(100);
WEND
endif
para siempre
ENDFUNC
FUNC touch()
touch_Set(TOUCH_ENABLE); activar la pantalla táctil
Clock();
repetir
var n, colr: = rojo;
var estado;
Estado: = touch_Get(TOUCH_STATUS); vamos a ver para cualquier actividad de toque
mx: = touch_Get(TOUCH_GETX); También podrá tomar el x
mi: = touch_Get(TOUCH_GETY); y las coordenadas y del toque
if(State == TOUCH_PRESSED) / / si hay una prensa
n: = img_Touched(iHndl, ALL); ver si las imágenes fueron tocadas
if(State == TOUCH_RELEASED) / / si se produce una liberación;
Si (n! = -1)
if(n==ADDBTN)
Main();
KKL: = 0;
exit2: = 0;
endif
endif
endif
endif
retorno;
para siempre
ENDFUNC
