No entiendo el porqué el primer código fuente propuesto no debe
funcionar, ya que se supone que la lectura de tiempo es del reloj de
hardware.


El 23/03/17 a les 03:05, Ricardo Cárdenes ha escrit:
> Hola Rolando,
> 
> Creo que es lo mejor para lo que estás haciendo. Si lo quieres hacer
> programable, busca algún microcontrolador. Un simple Arduino te basta
> para una tarea como esta.
> 
> 2017-03-22 5:42 GMT-10:00 Rolando Paz <flx...@gmail.com
> <mailto:flx...@gmail.com>>:
> 
>     Hola a todos.
> 
>     En efecto Ricardo lo que necesito hacer es controlar los tiempos T0
>     y T1.
> 
>     La acción para pruebas fue imprimir los valores 0 y 1, sin embargo,
>     de acuerdo al hardware que estoy programando, estos valores 0 y 1
>     los debo ajustar dentro de un registro de software que habilita o
>     deshabilita la generación de una señal senoidal.
> 
>     Sin embargo, luego de buscar varias formas de hacerlo con software,
>     creo que lo más facil sera hacerlo con hardware. Con algun generador
>     de señales :)
> 
> 
> 
> 
>     El 21 de marzo de 2017, 22:30, Ricardo Cárdenes
>     <ricardo.carde...@gmail.com <mailto:ricardo.carde...@gmail.com>>
>     escribió:
> 
>         Según la presentación del problema, es un ciclo de: "imprimir
>         0", "esperar T0 segundos", "imprimir 1", "esperar T1 segundos"
> 
>         2017-03-21 10:07 GMT-10:00 Carlos Zuniga <carlos....@gmail.com
>         <mailto:carlos....@gmail.com>>:
> 
>             2017-03-20 23:05 GMT-05:00 Rolando Paz <flx...@gmail.com
>             <mailto:flx...@gmail.com>>:
>             > Hola a todos de nuevo...
>             >
>             > Ahora regreso con un pequeño código:
>             >
>             > import time
>             >
>             > start_time = time.time()
>             > #tiempo total en segundos, como ejemplo 10.
>             > tiempo_total = 10
>             > #numero de conmutaciones generadas, como ejemplo 4.
>             > conmutaciones = 4
>             > for offset in range(tiempo_total):
>             >     while (time.time() - start_time) < offset:
>             >         time.sleep(0.01)
>             >         #lo siguiente realiza una conmutacion entre 0 y 1.
>             >         count = 0
>             >         for i in range(conmutaciones):
>             >             count = (count + 1) % 2
>             >              print count
>             >
>             > Lo que hace este código es conmutar entre 0 y 1, tantas
>             veces como se defina
>             > en "conmutaciones", durante el tiempo establecido en
>             "tiempo_total".
>             >
>             > La salida es la siguiente.
>             >
>             > 0
>             > 1
>             > 0
>             > 1
>             >
>             > Estoy tratando de entender cómo usar este código para
>             controlar los tiempos
>             > que se definen en la imagen adjunta, es decir:
>             >
>             > T1 = tiempo durante el cual la conmutacion es 1
>             > T0 = tiempo durante el cual la conmutacion es 0
>             > Tiempo Total = tiempo total de las conmutaciones
>             >
>             > Agradecería cualquier comentario sobre como poder
>             controlar los tiempos
>             > anteriores.
>             >
> 
>             Tu intención es que espere un tiempo tras cada print de 0 o
>             1? o que
>             imprima 0/1 4 veces y luego esperar?
> 
>                 import time
>                 from itertools import cycle
>                 conmutador = cycle((0,1))
> 
>                 tiempo_total = 10
>                 conmutaciones = 4
> 
>                 start = time.time()
>                 end = start + tiempo_total
>                 time_per_pulse = tiempo_total / conmutaciones
>                 while end > time.time():
>                     pulse_start = time.time()
>                     print(next(conmutador))
>                     pulse_end = time.time()
>                     time.sleep(time_per_pulse - (pulse_end - pulse_start))
> 
> 
>             Ahora, time.sleep no es exacto, el tiempo va a ser
>             normalmente mayor
>             al que especificas, depende del sistema. También hay
>             threading.Event.wait que puede ser más exacto.
> 
> 
>             Saludos
>             _______________________________________________
>             Python-es mailing list
>             Python-es@python.org <mailto:Python-es@python.org>
>             https://mail.python.org/mailman/listinfo/python-es
>             <https://mail.python.org/mailman/listinfo/python-es>
> 
> 
> 
>         _______________________________________________
>         Python-es mailing list
>         Python-es@python.org <mailto:Python-es@python.org>
>         https://mail.python.org/mailman/listinfo/python-es
>         <https://mail.python.org/mailman/listinfo/python-es>
> 
> 
> 
>     _______________________________________________
>     Python-es mailing list
>     Python-es@python.org <mailto:Python-es@python.org>
>     https://mail.python.org/mailman/listinfo/python-es
>     <https://mail.python.org/mailman/listinfo/python-es>
> 
> 
> 
> 
> _______________________________________________
> Python-es mailing list
> Python-es@python.org
> https://mail.python.org/mailman/listinfo/python-es
> 
_______________________________________________
Python-es mailing list
Python-es@python.org
https://mail.python.org/mailman/listinfo/python-es

Responder a