1Reloj en Auto-CAD mediante lenguaje LISP
Ivanna Lisette Medina Cruz
2019-2.
Universidad Nacional de Colombia Sede Bogotá.
Departamento de Ingeniería Mecánica y Mecatrónica.
Computación Gráfica
Descripción programa
Mediante el uso del programa Auto-CAD de Autodesk y el lenguaje LISP que este
programa usa, se realiza el diseño y simulación del funcionamiento de un reloj tanto
análogo como digital. En el cual por medio de comandos propios de Auto-CAD se
desarrolla un programa que realice este reloj con base en la fecha y hora del sistema, dibuje
las manecillas, el contorno del reloj, hora digital, entre otros elementos y vaya cambiando
sus propiedades para que marque la hora aproximada actual.
Además, se tuvo en cuenta las coordenadas (rectangulares y polares) en que se localizan los
objetos; por otro lado, se consideraron diferentes variables que afectan la fecha del sistema
que se está simulando, por ejemplo, la identificación de años bisiestos y por consiguiente
los cambios en los días de los meses que genera. Por otra parte, se trató con un delay para
que la hora sea lo más aproximada posible al valor real de fecha y hora real.
Descripción matemática
Para todo el desarrollo del programa se hicieron cálculos de coordenadas, ángulos y otras
operaciones matemáticas para condicionales para que el programa avanzara de tal manera o
para obtener datos para el funcionamiento. Estas se muestran a continuación:
Cálculo ángulos: Para cada manecilla se calcula el ángulo que debe girar con
respecto a un segundo, un minuto o una hora según sea necesario:
El signo menos en cada cálculo es gracias a que el sistema horario es contrario al
sistema positivo de medición de ángulos de Auto-CAD o sistema de coordenadas
polares.
Segundero
(setq segundero_seg (/ 360.0 -60))
Se divide 360° (todo un círculo) en 60, la cantidad de segundos por minuto o por
vuelta del segundero (coinciden con los marcadores de segundos en el reloj).
Esto nos da el ángulo que debe girar por segundo -6.0°
Minutero
(setq minutero_min (/ 360.0 -60))
Se divide 360° en 60, la cantidad de minutos en una hora o vuelta del minutero
(coinciden con los marcadores de minutos en el reloj), para determinar que por
minuto se debe mover -6.0°
(setq minutero_seg (/ 360.0 -60 60))
Se divide 360° en 60, así se obtiene el ángulo que recorre por minuto; se vuelve a
dividir por 60, que es la cantidad de segundos por minuto, así se halla el ángulo que
debe recorrer por minuto -0.1°
Horario
(setq horario_hor (/ 360.0 -12))
Se dividen los 360° del circulo en 12, la cantidad de indicadores o líneas de hora en
el reloj, así se halla el ángulo que debe recorrer entre hora -30.0°
(setq horario_min (/ 360.0 12 -60))
Se divide 360° entre 12, dando el ángulo por hora, se divide entre 60 (cantidad de
minutos de un ahora) para obtener el ángulo a recorrer por minutos -0.5°
(setq horario_seg (/ 360.0 12 -60 60))
Se divide 360° entre 12 y luego entre 60, dando el ángulo por minuto, luego se
divide por 60 otra vez (cantidad de segundos por minuto) para hallar el ángulo por
segundo que debe recorrer -0.0083°
Cálculo de ángulos finales de posición de las manecillas:
Ya teniendo los valores de la hora del sistema (hora, minutos y segundos) se
procede a calcular la posición de las manecillas que marcan esa hora:
Para el horario se multiplica la hora por el ángulo que recorre por hora, los
minutos por el ángulo que recorre por minuto y los segundos por el ángulo
que recorre por segundo; estos valores se suman, mas una constante de 90 ya
que la posición inicial de las manecillas es con un ángulo 0°, es decir hacia la
hora 3, pero la hora, los minutos y los segundos de un reloj se inician desde el
marcador de las 12 que tiene un ángulo de 90°; es decir se le suma la
diferencia entre el marcador de las 3 y las 12.
(setq horario_inicial(+ 90 (* hora horario_hor) (* minutos horario_min) (* segundos
horario_seg)))
Para el minutero es lo mismo solo que no es necesario el ángulo que recorre
por hora, también se suma la constante de 90°.
(setq minutero_inicial(+ 90 (* minutos minutero_min) (* segundos minutero_seg)))
Para el segundero tenemos que solo se calcula el ángulo que recorre por
segundo por el valor de los segundos y tendrá igualmente la constante de 90°.
(setq segundero_inicial(+ 90 (* segundero_seg segundos)))
