Estamos en un proceso de migración de contenidos desde el sitio scratchbydsigno.com.ar hacia este nuevo blog.

La prioridad está centrada en los 3 Tutoriales que constituyen la base de dicho sitio, para luego seguir con el resto de los contenidos.

En caso de que encuentres algún error de visualización, o links rotos, puedes comunicármelo usando el formulario de contacto...

1er paso: diseñar el mecanismo (final)

Reloj analógico. Reloj mecánico. Pulso. Base de tiempo. Sincronismo. Parece un exceso de nuevas ideas sólo para poder llevar adelante algo tan lateral como un simple proyecto vinculado a un cuasi-ignoto software que no hace más que enfrentarnos a más preguntas que respuestas… ¡Y yo que la paso tan bien leyendo y escribiendo en mi muro de Facebook y viendo desopilantes videos en YouTube!
¿Cuánto de pulsos, de sincronismo y mecanicismos tiene nuestra valiosa —por única e irrepetible— existencia? ¿Cuánto de dedicar nuestro bien más preciado a ser engranajes de una maquinaria "ajena y superior"? ¿Cuánto de lo cíclico en nuestras vidas tiene que ver con la madre naturaleza y cuánto a los imperativos del progreso taylorista? La puntualidad, la exactitud, lo previsible, etc. son sin duda atributos positivos para cualquier buen reloj, forman parte de su esencia, ¿pero para los humanos..? No sé: el cierre de este pensamiento te lo dejo a vos… [fin de la pausa reflexiva].

Si hablamos de relojes hablamos de sincronismo

Habíamos quedado en que el pulso de nuestro reloj está asociado directamente con el giro de su segundero ¿cómo simular el efecto que proporcionan los engranajes dentro de un reloj mecánico? Yo diría que conviene espiar la solución dada en los relojes electrónicos: allí todo se reduce a contadores y divisores.
Conviene traer a la memoria las metas nº5 y nº6 que impusimos para este 1er paso:
  • El movimiento de giro del minutero se efectuará mediante "saltos de posición" a razón de 1 vez por minuto.
  • Respetando lo que ocurre con los relojes analógicos "reales", la aguja de la hora irá moviéndose al ir transcurriendo el lapso de una hora (dicho de otra manera, a las "y media" estará a mitad de camino entre las dos horas que correspondan).
    En nuestro caso optaremos por lo siguiente: que sus "saltos" de posición se efectúen a razón de 1 vez por minuto —a la par del minutero—
Fijate que los saltos angulares se deben producir en ambas agujas 1 vez por minuto (estamos hablando de nuestros minutos).
Te estoy dando demasiadas pistas… van las últimas: ¿cómo podemos saber que ya transcurrió 1 de nuestros minutos?
RTA: contando 60 de nuestros segundos.
¿Cómo informar al minutero y al horario que ya se contaron 60 de nuestros segundos?
RTA: utilizando el envío de mensajes.
script segundero sincrónico
script segundero
Una vez expuesta la solución parece más que trivial… de hecho me ilusiono en que se te debe haber ocurrido a vos antes de llegar a leer estas líneas.
Y materializar la solución en un nuevo script para el segundero (y van…) tampoco entraña demasiados desafíos: sólo hay que hacer leves cambios dentro del bucle infinito del mismo —ya lo podés ir apreciando en la imagen—.
Funcionalmente su comportamiento no se alteró para nada: se sigue usando una base de tiempo generada por el bloque de espera, y una instrucción de giro. El bucle de repetición por 60 veces es el que actúa como contador, y es seguido por el envío de un mensaje que deberá ser captado por los otros 2 objetos, pero que en sí no afecta al propio segundero.
Desde ya que dicho mensaje se enviará cada vez que transcurra uno de nuestros minutos.

Reabrí el proyecto y efectuá los cambios mostrados. Deberás crear un nuevo mensaje: como podés ver en la imagen yo lo nombré pasó un minuto, nombre innecesariamente largo pero justificable a los fines de este Tutorial (vos usá el que quieras).

¿y dónde se demuestra el sincronismo?

Ya vá, ansios@. El sincronismo del dispositivo va a mostrarse cuando se muevan todas las agujas.

Empecemos con el minutero 

script minutero sincrónico
scripts minutero
Lo primero que se impone es partir de un script que sólo tenga las condiciones iniciales. Ellas deben ejecutarse cuando se arranque el programa con la "bandera verde", y luego de producirse esto la ejecución del script debe detenerse (el bloque detener programa puede o no colocarse: el script se detiene igual).
¿Cómo proporcionar el salto de giro entonces? Este salto dependerá del mensaje pasó un minuto que emite el segundero, así que deberemos tan sólo armar un script que reciba el mensaje y ejecute la acción de giro.
¿De cuántos grados deberá ser el salto angular del minutero?
El análisis es muy similar al caso del segundero. En este caso se recibe un mensaje/pulso por minuto: la aguja debe saltar 60 veces en una hora. Al cabo de la misma dá una vuelta completa (360º) al cuadrante, por lo que si gira por salto tendremos todo funcionando OK.

Terminamos con la aguja horaria 

script horario sincrónico
scripts horario
La primera parte de lo dicho para el minutero será igualmente válida aquí. Existe un script que se dedica al cumplimiento de las condiciones iniciales y se luego se detiene, y un script que sintoniza el mensaje/pulso que emite el segundero y se encarga de hacer girar al horario. Hasta aquí todo conceptualmente igual.
¿De cuántos grados deberá ser el salto angular de la aguja horaria?
Lo primero a recordar es que, según la meta nº5, esta aguja se va a mover también 1 vez por minuto. Por lo tanto también va a dar 60 saltos en una hora, pero ¿cuánto se va a desplazar en ese tiempo? Es hora de pensar.

("… A ver: el cuadrante muestra 12 horas, por lo tanto el ángulo que le corresponde a cada hora es la doceava parte de un giro completo: 360º/12 = 30º… Si el horario dá 60 saltos para cubrir 30º cada salto debe ser de 30º/60 = 1/2º (0,5º)". También lo podía haber pensado como: "la aguja horaria se mueve 12 veces 'más lenta' que el minutero: si éste dá 6º por salto, se necesitará 6º/12 = 0,5º").

Es momento de que efectúes los cambios necesarios en nuestro proyecto (desde luego, ya los debés estar probando).
Nuestro reloj analógico funcionará ahora de manera sincrónicamente perfecta. Si tenés un reloj "real" a mano vas a poder verificar que nuestro reloj retrasa en el orden de algún segundo por minuto (esto dependerá de multiples factores)… ¡pero aún así su funcionamiento es consistente con lo esperable de un reloj que se precie de tal! Y todo esto porque existe un sincronismo entre sus componentes, lo cual deviene del empleo de una base de tiempo única: el pulso que mueve al segundero termina siendo responsable del movimiento de todo "el mecanismo".
Hasta aquí felices y contentos… nuestras metas ya se han cumplido. Tomemos un respiro y veamos una cuestión más.

Controlando la base de tiempo

El factor sorpresa: ¡cuantas batallas se han ganado gracias a este recurso! Pero aquí vendrá en realidad en ayuda de nuestro desarrollo y, quizás, recibirá el beneplácito de nuestros futuros espectadores (perdón, debí decir usuarios de nuestro proyecto).
Voy a ser más claro: vamos a agregar una posibilidad de control no preanunciada a nuestro proyecto.
Primero demos las razones: en todo programa se requiere comprobar que se ha conseguido el funcionamiento esperado, pero para el caso de un reloj poder verificar que, por ejemplo, la aguja horaria se está desplazando correctamente, nos insumiría un tiempo considerable.
Pero ¿que pasaría si cambiásemos la base de tiempo de 1 segundo a un valor mucho menor? "El reloj dejaría de funcionar correctamente…" debés estar pensando. ¿Es así?
El reloj dejaría de dar la hora correctamente, diría yo, pero agregaría que si el mecanismo respeta el sincronismo podemos presumir que la validez del núcleo funcional sigue en pie.

A destacar

Controlar la base de tiempo nos permitirá entonces, entre otras cosas, asegurar que se verifica el sincronismo en nuestro proyecto sin tener que esperar horas para comprobarlo. También puede proporcionar una manera de compensar "a ojo" el atraso que presente el funcionamiento de nuestro reloj (tal como hacíamos con aquellos viejos despertadores a campana).

Nuestra nueva meta incorporada

Yendo a lo concreto: lo que buscaremos es proporcionar un medio para multiplicar la velocidad de funcionamiento de nuestro reloj, de manera que pueda ser controlable por el usuario del proyecto usando un slider (control deslizador, bah…).
Ya en el Tutorial 2 hablamos de la posibilidad de controlar el funcionamiento de nuestros proyectos usando los monitores de las variables con su opción deslizador habilitada [podés leerlo aquí]. Usando esta funcionalidad que nos brinda Scratch veremos como multiplicar hasta 20 veces (por ej.) la velocidad de giro de nuestras agujas. Manos a la obra.

Pero primero… a pensar 

Y sí, no nos íbamos a salvar de analizar un poco esta nueva situación. Si hablamos de multiplicar la velocidad de giro hablamos de alterar la base de tiempo de manera que los pulsos se presenten a una frecuencia mayor que la inicial de 1Hz (1 por segundo).
Revisando en nuestro script del segundero vemos que el efecto de la base de tiempo de nuestro reloj aparece a través del uso de un bloque esperar (x) segundos: si x = 1 (como fue hasta ahora) el reloj estaría funcionando "normalmente" (o casi).
¿Cómo haríamos para multiplicar por 20 la velocidad del reloj? Deberíamos tener 20 pulsos por seg. (20Hz), por lo que el valor a colocar dentro del bloque de espera debería ser x = 1/20 = 0,05  [testealo en el proyecto].
Si lo pensamos, vemos que este factor de multiplicación de velocidad va a aparecer dividiendo al 1 original cualquiera sea el caso: si queremos controlar entonces la velocidad deberemos crear una variable (yo la llamé multiplicador), y usar su monitor con la opción deslizador de manera de tener en pantalla el pretendido slider (ver imágenes).

Ahora sí… a actuar 

No hay mucho para explicar: deberás crear primero una variable (multiplicador), y haciendo clic derecho sobre ella en el escenario elegir la opción deslizador.
No hay que olvidarse de colocar los valores minimo y máximo (rango del valor) que podrá tomar el factor multiplicador en cuestión: yo elegí 1 como mínimo y 20 como máximo.
Por supuesto que habrá que hacer cambios en el script del segundero de manera que la variable afecte la base de tiempo del reloj. Aquí debajo podés ver como quedará finalmente nuestro script… con los 2 restantes no habrá que hacer nada.
script final
script segundero (final)
Tomate un tiempo para testear la solución: como verás, el cambio en el factor multiplicador puede aplicarse aún estando el reloj en funcionamiento, y pese a ello nunca se perderá el sincronismo entre las agujas ¿qué me contás?
Una vez conforme con el funcionamiento, podés guardar el proyecto… y aplausos por favor: terminamos nuestro 1er paso de este Tutorial 3 (¡justo a tiempo, en mi reloj dan las 12!)

PARA VER

Si visitás el sitio web oficial de Scratch podés ir a esta página para ver este 1er paso del proyecto en acción [recordá que podrás descargarlo a tu computadora sólo si estás suscripto como usuario del sitio].

Lo que queda por delante

Ya sabés que me gusta anticipar algo de lo que va a venir. Nuestro "mecanismo" funciona según lo esperable, pero todo reloj debe brindar además alguna forma para que lo pongamos en hora. Daremos 2 propuestas para resolver esta situación, que diferirán fundamentalmente en la forma en que serán presentadas al usuario (una cuestión de interfaz), pero compartirán lo central del análisis y la estrategia de resolución "interna".
Podés ir pensando sobre esta cuestión: ¿cómo hacer para poner al reloj en hora?. Yo mientras tanto me voy a dormir un rato… despiértenme a las 12. Nos vemos en el 2do paso.
Última actualización: Marzo 2, 2014

No hay comentarios.:

Publicar un comentario

© Scratch CodeLab | D153ñ0 b454d0 3n l4 pl4n71ll4 SimpleRWD d3 Oloblogger