Funciones de conteo y de tiempo

Conformación de señales

Impulso de Dirac "dirac"

La función emite, con el tiempo de muestreo discreto global discreteSampleTimeMs, un impulso 0-1-0 de 1 ns de duración. El tipo devuelto es <bool>.

p = dirac();

Impulso de Dirac

nota

Dado que esta función se utiliza por lo general para funciones lógicas, el valor devuelto como <bool> es directamente false o true. Para que se cumpla la condición integral de un impulso de Dirac «real»

\delta(f) = \int\delta(\tau)f(\tau)d\tau = f(0)

habría que multiplicar dirac() por $10^{-9}$ .

consejo

Para muestrear una señal con el tiempo de muestreo discreto discreteSampleTimeMs, debe utilizarse la función sample(x).

Temporizador "timer"

La siguiente fórmula proporciona periódicamente, en los instantes definidos, un impulso o la marca de tiempo correspondiente.

Los impulsos pueden utilizarse para poner a cero sumas o integrales, o para transferir los valores correspondientes a un registro latch.

Los impulsos no se recuperan si el sistema no estaba activo en el instante del impulso.

pulse = timer({ interval: <time>   // verpflichtend, sofern nicht midestens ein (*) definiert ist
              , aligned: <bool>
              , readTime: <bool>
              , useTZ: <bool>
              , minute: <str>     // (*)
              , hour: <str>       // (*)
              , day: <str>        // (*)
              , month: <str>      // (*)
              , weekday: <str>    // (*)
              });
// Das Konfigurationsobjekt ist verpflichtend, um darin
// eine eindeutige Konfiguration aus interval oder einem
// (*) - Element, um die Ereigniszeitpunkte zu definieren.

Propiedad	Valor	Descripción
interval	`<time>`	Intervalo de tiempo en el que se dispara un evento.
aligned	`<bool>`	Si esta opción está activada, el intervalo se refiere a las `00:00:00` del día, con independencia del instante de inicio del cálculo.
readTime	`<bool>`	Si esta opción está activada, en lugar de un impulso de 1 nanosegundo se emite en el instante del evento la marca de tiempo, uint64 en nanosegundos UTC desde el 1.1.1970.
useTZ¹	`<bool>`	Utiliza para interpretar la hora la zona horaria local configurada con la macro `#timezone`. Advertencia: ¡las marcas de tiempo que caen dentro del intervalo del cambio de hora pueden pasarse por alto!
minute	`<str>`	Sintaxis crontab para definir los instantes de los eventos
hour	`<str>`	Sintaxis crontab para definir los instantes de los eventos
day	`<str>`	Sintaxis crontab para definir los instantes de los eventos
month	`<str>`	Sintaxis crontab para definir los instantes de los eventos
weekday	`<str>`	Sintaxis crontab para definir los instantes de los eventos

Si en lugar de interval se utilizan los parámetros minute, hour, day, month y/o weekday, pueden establecerse instantes de disparo explícitos (UTC).

Para cada entrada, en el orden minute, hour, day, month, weekday, es posible la siguiente especificación (basada en la sintaxis crontab):

Especificación	Significado
sin indicación	equivale a '' si todos los elementos siguientes no están definidos; en caso contrario, el menor valor posible, normalmente '0' (o '1' para day* y month).
'*'	siempre / en cada
'*/n'	en el intervalo de n
'a-e'	en el rango de a hasta e inclusive
'a-e/n'	en el rango de a hasta e inclusive con paso n Ejecución a las/el $X=a$ , $a+1\cdot n$ , $a+2\cdot n$ , $a + 3\cdot n \dots$ con $X \le e$
'a,b,c'	lista de valores individuales cualesquiera separados por comas Ejecución a las/el a, b y c

Para los días de la semana y los meses pueden utilizarse, en lugar de números, abreviaturas que se corresponden con las tres primeras letras de la denominación inglesa: p. ej. “mon”, “thu”, “apr”, “jun”, “dec”, ... .

El recuento de los días de la semana comienza con el domingo “sun” como 0.

Ejemplos de la sintaxis crontab:

minute:	hour:	day:	month:	weekday:	Instante del impulso ...
`30`	`4`				diariamente a las 4:30, «tras el cierre de la jornada»
		`1`			el día 01 de cada mes a las 0:00
`'50-59/4'`	`23`	`30`	`'3-12/3'`		el 30.03., 30.6., 30.09., 30.12., siempre a las 23:50, 23:54, 23:58
`'*/15'`					cada 15 minutos, x:00, x:15, x:30, x:45
`'3-59/15'`					cada 15 minutos, x:03, x:18, x:33, x:48
		`15`	`'apr-sep'`		el día 15 de los meses de abril a septiembre a las 0:00
		`10`	`'oct-mar'`		el día 10 de los meses de octubre a marzo
	`'6,9,14,18'`				diariamente a las 6, 9, 14 y 18 horas
	`2`	`'*'`	`'*'`	`'sun'`	semanalmente, el domingo a las 2:00
`30`	`2`			`'mon'`	ADVERTENCIA: faltan las entradas para day y month

aviso

En el último ejemplo existe una incoherencia, ya que no se han indicado las entradas para day y month, es decir, están en modo automático. Según las reglas, estas se comparan por defecto con su primer valor (aquí, por tanto, 1), puesto que a su derecha hay una asignación. Sin embargo, esto no conduce al resultado deseado.

trigg_1 = timer({minute:30, hour:2, weekday:sun});

En el archivo de registro² se emite una advertencia por esta incoherencia:

|WARNING|module.math: (WW) "timer(24): Enclosed, automatic definitions found in crontab! Criteria may not function as expected! Please review the definition."

consejo

Mientras se defina un bloque contiguo de propiedades, los elementos de los extremos se completan automáticamente de forma correcta: a la izquierda con su menor valor (0 o 1), a la derecha con '*'. Ejemplos:

minute, hour, day
day, month
hour, day

Ejemplo

En el ejemplo 1b se utiliza la función timer() para generar un impulso de almacenamiento a una hora fija (cierre de la jornada).

Retardo "delay"

Las siguientes fórmulas sirven para filtrar y retardar los flancos de una señal.

delayed1_s = delay(signal, {...});
delayed2_s = delay(signal, reset, {...});
// Das Konfigurationsobjekt ist verpflichtend
delayedX_s = delay(..., { delayOn: off|<time>
                        , delayOff: off|<time>
                        , restart:<bool>
                        , startup: inf|<bool>
                        }); 

Propiedad	Valor	Descripción
delayOn	`off/<time>`	Tiempo en segundos para retardar el flanco positivo off³ o 0: sin retardo (def.)
delayOff	`off/<time>`	Tiempo en segundos para retardar el flanco negativo off³ o 0: sin retardo (def.)
restart	`<bool>`	Los flancos posteriores durante el tiempo de espera reinician el intervalo de tiempo
startup	`inf/<bool>`	Condición de inicio para la detección de flancos, véase la descripción siguiente

El comportamiento depende del estado de la señal de salida. Si este es false, solo se tienen en cuenta los flancos positivos de la señal de entrada signal y el parámetro de tiempo delayOn. Si el estado es true, se tienen en cuenta los flancos negativos y el parámetro de tiempo delayOff.

Retardo de flancos

La medición del tiempo comienza en cada caso con el primer flanco que llega y, opcionalmente, puede reiniciarse con los flancos siguientes (restart: true). El estado de salida solo cambia si, al transcurrir el tiempo, la señal de entrada se encuentra en el estado opuesto. De este modo solo se filtran los cambios breves de señal, y los cambios de señal se transmiten con retardo únicamente una vez que la señal se ha estabilizado.

Con un true en la entrada reset, el estado de salida se restablece a false y se mantiene así.

La función puede utilizarse para filtrar y estabilizar una señal de conmutación con «rebotes».

Para el arranque del sistema debe establecerse cómo se trata el historial de la entrada signal y si, por tanto, debe detectarse un flanco inmediatamente al arrancar y desencadenarse con ello un tiempo de espera. Para ello sirve la propiedad startup:

inf: la primera muestra de la señal determina el valor en el pasado y, con ello, la salida antes del arranque del sistema; por tanto, la primera muestra no desencadena ningún flanco.
<bool>: se asume que la entrada y la salida tenían este valor de señal (true, false) en el pasado, antes del arranque del sistema. De este modo, la primera muestra de la entrada puede desencadenar un flanco y, con ello, iniciar un tiempo de retardo.

Propiedad startup

Pulso "pulse"

Las siguientes fórmulas convierten un flanco de entrada seleccionable en signal en un impulso booleano rectangular de duración duration (similar a un monoestable 74HC121 o 74HC122). Con un true en el parámetro reset, la salida se restablece a false y se mantiene así. Las entradas signal y reset se interpretan como <bool>, la entrada duration como duración en segundos.

p1 = pulse(signal, {...});
p2 = pulse(signal, reset, {...});
p3 = pulse(signal, reset, duration, {...});
// Das Konfigurationsobjekt ist verpflichtend
px = pulse(..., { edge:<int>
                , duration:<time>
                , restart:<bool> 
                , startup: inf|<bool>
                });

Propiedad	Valor	Descripción
edge	`<int>`	Selección del flanco de control: -1: negEdge, 0: anyEdge, +1: posEdge (default)
duration	`<time>`	Duración del impulso en segundos (def.: 10 ns)
restart	`<bool>`	Posibilidad de prolongar el impulso con un nuevo flanco
startup	`inf/<bool>`	Condición de inicio para la detección de flancos, véase la descripción siguiente

El siguiente ejemplo muestra, para edge = +1, el comportamiento de la propiedad restart:

Señal de pulso

inf: la primera muestra de la señal determina el valor en el pasado antes del arranque del sistema; por tanto, la primera muestra no desencadena ningún flanco.
<bool>: se asume que la entrada tenía este valor de señal (true, false) en el pasado, antes del arranque del sistema. De este modo, la primera muestra puede desencadenar un flanco.

Propiedad startup

Generador de funciones "periodic"

La función periodic() puede utilizarse como generador de funciones y genera una señal periódica con el periodo period mientras la entrada enable se mantenga en true. La forma de la señal se establece mediante la propiedad mode. La frecuencia de salida corresponde al tiempo de muestreo discreto global discreteSampleTimeMs o a la frecuencia de salida fOut configurada.

p1 = periodic(enable, {...});
p2 = periodic(enable, control, {...});
p3 = periodic(enable, control, period, {...});
// Das Konfigurationsobjekt ist verpflichtend
px = periodic(..., { period: <time>
                   , mode: <enum>
                   , reset: <enum>
                   , control: <dbl>
                   , fOut: <dbl>
                   , width: <uint>
                   , taps: [<uint>]|p##
                   });

Propiedad	Valor	Descripción
period	`<time>`	Periodo constante de la forma de onda en segundos, equivale a la entrada period Rango de valores: $[0.0001 .. \infty[$ Obligatorio para todos los modos excepto prbs, salvo que se indique mediante la entrada period³
mode	`<enum>`	Modo de funcionamiento (def.: ramp) [rect, pwm, time, ramp, ramp2, sawtooth, 2Pi…]
reset	`<enum>`	Restablecimiento de la forma de onda con [stop, start, none]
control	`<dbl>`	Valor de control constante para PWM, equivale a la entrada control
fOut	`<dbl>`	Frecuencia de salida opcional para los puntos de datos en hercios Rango de valores $[0.1..\infty[$
width	`<uint>`	Anchura de salida de la señal PRBS Rango de valores $[0..64]$
taps	`[<uint>]/p##`	Posiciones de realimentación PRBS o polinomio predefinido p2..p24

Las entradas opcionales control y period tienen prioridad sobre las propiedades configuradas de forma fija. Si el periodo cambia durante la emisión de la señal, la forma de onda continúa sin saltos en la posición de salida actual (*).

Aunque la elección del periodo y de la frecuencia de salida no está sujeta en principio a ninguna restricción, deben elegirse valores razonables con vistas al funcionamiento del smartCORE.

Valores para reset:

stop: (default) El valor de salida se restablece con enable == false.
start: El valor de salida se mantiene hasta el siguiente inicio y solo entonces se restablece.
none: Con enable == false la salida solo se detiene, no se restablece.

Algunos ejemplos de modos de salida en combinación con el periodo period, la frecuencia de salida fOut, una señal de control control y distintos ajustes de reset

Señales periódicas

Mode: rect

Se emite una señal rectangular 0-1 de tipo <bool>, donde control $\in [0.0..1.0]$ representa la posición relativa del flanco positivo dentro del intervalo period (default: 0.5). ¡El estado de reset es 0!

Mode: pwm

Se emite una señal rectangular 1-0 de tipo <bool>, donde control $\in [0.0..1.0]$ representa la posición relativa del flanco negativo dentro del intervalo period (PWM, default: 0.5). ¡El estado de reset es 0!

Mode: time

Se emiten rampas con los valores de tiempo $[0.0 .. period[$ en segundos

Mode: ramp (def.)

Se emiten rampas con la posición relativa en el intervalo como valor de escala $[0.0..1.0[$

Mode: ramp2

Se emiten rampas con los valores de escala $[0.0..1.0[, [-1.0 .. 0.0[$ , donde el salto de retorno a $-1.0$ se sitúa en la mitad del periodo.

Mode: sawtooth

Se emite una forma de onda en diente de sierra $[0.0 .. 1.0 .. 0.0[$ , donde control $=[0..1]$ representa la posición relativa del pico de 1.0 dentro del intervalo period. ¡El estado de reset es 0.0!

Mode: 2pi

Se emite la posición relativa en el intervalo como valor angular $[0.0 .. 2π[$ para funciones angulares posteriores.

wave = 10.0 * sin(periodic(true, { mode : 2pi
                                 , period: 2.0     // Signal-Periode / s
                                 , fOut: 100.0})); // Sample-Rate

Mode: prbs

Emisión de una señal de ruido pseudobinario (pseudo random binary sequence) con la frecuencia de salida fOut. La longitud del periodo resulta del generador configurado; el parámetro period se ignora.

En el registro de desplazamiento interno de 64 bits se prevén realimentaciones NXOR en las posiciones marcadas por taps[]. width (def: 0) es la anchura en bits de la máscara de salida del registro de desplazamiento, para utilizar el PRBS en la generación de amplitudes pseudoaleatorias. Con width: 0 solo se emite una secuencia <bool>.

Para taps también pueden obtenerse polinomios predefinidos como realimentación para longitudes de 2 .. 24 bits.

La señal PRBS puede utilizarse para la identificación de parámetros de sistemas dinámicos.

Conteo y medición

Contador "counter"

Las siguientes fórmulas cuentan flancos positivos en distintas configuraciones.

precaución

¡El significado de los parámetros depende del modo de funcionamiento configurado!

c1  = counter(up);
c2  = counter(up, down);                     // mode: updown
c3  = counter(up, down, reset);              // mode: updown
c4  = counter(up, down, reset, preset);      // mode: updown
c5  = counter(count, dir);                   // mode: countdir
c6  = counter(count, dir, reset);            // mode: countdir
c7  = counter(count, dir, reset, preset);    // mode: countdir
c8  = counter(count, incr);                  // mode: countincr
c9  = counter(count, incr, reset);           // mode: countincr
c10 = counter(count, incr, reset, preset);   // mode: countincr
c11 = counter(A, B);                         // mode: qencoder
c12 = counter(A, B, reset);                  // mode: qencoder
c13 = counter(A, B, reset, preset);          // mode: qencoder
// Optionale Konfiguration für alle Varianten
cX = counter(..., { mode: <enum>  // verpflichtend, falls nicht 'updown'
                  , start: <int>
                  , preset: <int>
                  , lower: off|<int>
                  , upper: off|<int>
                  , range: <uint>
                  , modulo: <uint>
                  , storage: <str>
                  });

En el modo updown (default), los flancos positivos en up cuentan hacia arriba y los de down hacia abajo (similar a un 74HC193). Si los flancos llegan exactamente en el mismo instante, se cuenta $+1-1=0$ .

En el modo countdir, se cuentan los flancos positivos en la entrada count y la dirección se establece independientemente mediante la entrada dir de tipo <dbl> (similar a 74HC191). Si dir > 0.0 (o true), se cuenta hacia arriba; con dir <= 0.0 (o false), hacia abajo. El valor por defecto es 1.0 o true (hacia arriba). El uso del tipo <dbl> para la dirección permite utilizar un valor de medición analógico de velocidad (p. ej., en «m/s») para controlar el sentido de conteo. Por otra parte, la entrada es compatible con señales <bool>.

mode: countdir

Los ámbitos de aplicación son la determinación de la posición en movimientos lineales o rotativos, o también el conteo, según la dirección, de objetos que pasan por una estación de conteo.

En el modo countincr, el paso de conteo se suma al registro a través de la entrada incr de tipo <int> con el flanco ascendente en count. El valor por defecto es 1 (hacia arriba). El orden de magnitud de incr debe adaptarse de forma razonable a la anchura del contador configurada, a los límites del contador, etc.

En el modo qencoder se cuentan todos los flancos de las señales desfasadas A y B. Por tanto, el uso de las dos entradas es obligatorio. En cada caso, la señal sin flanco indica el sentido de conteo. Los ámbitos de aplicación son la determinación de posición de alta precisión en movimientos lineales o rotativos con resolución cuádruple («Quadrature Encoder»). Para ello, los flancos deberían guardar entre sí exactamente las mismas distancias.

mode: qencoder

Para la disposición mostrada en la figura resulta el siguiente esquema de conteo:

A	B	Giro a la derecha Incrementar	Giro a la izquierda Decrementar
0	0	$\downarrow$ A: 0->1	$\uparrow$ B: 0->1
1	0	$\downarrow$ B: 0->1	$\uparrow$ A: 1->0
1	1	$\downarrow$ A: 1->0	$\uparrow$ B: 1->0
0	1	$\downarrow$ B: 1->0	$\uparrow$ A: 0->1
0	0	$\downarrow$ A: 0->1	$\uparrow$ B: 0->1

Con un true en la entrada reset, el contador se fija en preset (def: 0) y se mantiene así. preset puede pasarse mediante las propiedades o como cuarto argumento.

El registro de conteo es de tipo <int64>.

Si incr (modo countincr) o dir (modo countdir) es NaN o INF, se aplica el último valor finito recibido. Un argumento preset no finito se considera no indicado, al igual que un valor ausente o no finito en la memoria persistente (el contador comienza entonces con start). Solo se aceptan escalares numéricos; ante un vector, una matriz, una cadena de texto o un valor complejo, counter() devuelve el mensaje de error Input Value is not a numerical scalar.

Propiedad	Valor	Descripción
mode	`<enum>`	updown: entradas de conteo separadas para arriba / abajo (def.) countdir: entrada de conteo y dirección separada `<dbl>` (> 0.0: hacia arriba) countincr: entrada de reloj y paso separado como `<int>` qencoder: se cuentan todos los flancos de las señales de reloj A, B según la dirección
start	`<int>`	Valor inicial al arrancar el smartCORE
preset	`<int>`	Valor de restablecimiento con true en el parámetro r
lower	`off/<int>`	El valor de conteo se detiene en el límite inferior, sin desbordamiento
upper	`off/<int>`	El valor de conteo se detiene en el límite superior, sin desbordamiento
range	`<uint>`	Rango del valor de conteo $[0..range-1]$ Desbordamiento desde los valores extremos hacia $0$ o $range-1$
modulo	`<uint>`	Rango del valor de conteo `count %= modulo` con signo $[1-modulo..modulo-1]$ Desbordamiento desde los valores extremos hacia 0
storage	`<str>`	Nombre de una memoria persistente para el estado interno. De este modo, tras un reinicio del sistema, la salida recibe el último valor almacenado. El contenido de esta memoria no puede utilizarse en ningún otro lugar del smartCORE.

Cronómetro "stopwatch"

Las siguientes fórmulas representan un cronómetro y miden la duración de un impulso pulse o el intervalo entre dos flancos positivos en pulse, o entre el primer flanco positivo en beg y el siguiente flanco positivo en end. La medición comienza siempre con la condición de inicio en $t=0.0s$ . Con un flanco en la entrada lap puede emitirse un tiempo parcial (latch = true). Un true en la entrada reset pone el cronómetro y la salida a 0.0 y los mantiene en ese estado. Todas las entradas se interpretan como <bool>. La salida se expresa en segundos.

t1 = stopwatch(pulse);        
t2 = stopwatch(beg,end);      
t3 = stopwatch(beg,lap,end);    
t4 = stopwatch(beg,lap,end,reset);
// Optionale Konfiguration für alle Varianten
tx = stopwatch(..., { latch: <bool>
                    , period: <bool>
                    , hold: <bool>
                    , restart: <bool>
                    , upper: off|<time>
                    });

Propiedad	Valor	Descripción
latch	`<bool>`	true: el tiempo se emite solo con los flancos de control (def.) false: emisión continua del tiempo de medición creciente
period	`<bool>`	true: medición entre dos flancos ascendentes en la entrada pulse false: medición del tiempo durante el cual pulse = true
hold	`<bool>`	true: la salida se fija en el nuevo valor de medición solo al concluir la medición. false: la salida se pone a 0 con una medición nueva o en curso.
restart	`<bool>`	true: cada flanco ascendente en beg reinicia la medición false: solo el primer flanco ascendente en beg inicia la medición (def.)
upper	`off/<time>`	Cuando se alcanza este valor de tiempo, se realiza la emisión y se cancela la medición. (def.: off)

En la primera forma solo se utiliza una señal de impulso pulse. El siguiente diagrama muestra distintas configuraciones y posibilidades de salida para la medición en una señal de impulso:

Medición de tiempo, señal de impulso

La primera fila muestra una señal de impulso cualquiera que se desea medir.

La segunda fila muestra, para la medición de la duración del impulso, con las rampas ascendentes discontinuas, el tiempo transcurrido desde el flanco correspondiente situado en la base a la izquierda. En magenta, finalmente, la salida de la función stopwatch() para distintas propiedades latch, hold o upper.

La tercera fila muestra, para la medición del periodo, con las rampas ascendentes discontinuas, de nuevo el tiempo transcurrido desde el flanco correspondiente situado en la base a la izquierda. En naranja o azul, finalmente, la salida de la función stopwatch() en función de las propiedades latch o upper.

Para el funcionamiento con las entradas beg, lap y end, la configuración de la salida es análoga. Con la propiedad restart, una medición activa puede volver a comenzar en 0.0 con cada nuevo flanco en beg, con lo que se mide la distancia desde el último flanco ascendente hasta el flanco en end. En este modo de funcionamiento, la emisión de tiempos parciales puede inducir a error. En el siguiente diagrama se ha activado la propiedad latch = true para permitir la emisión de tiempos parciales.

Medición de tiempo Begin Lap End

Las tres primeras filas muestran evoluciones temporales ejemplares de las señales de entrada beg, lap y end. La entrada lap es opcional. En las zonas discontinuas es posible, en cualquier momento, un retorno de la señal a false (verde), ya que para la entrada beg solo es relevante un flanco ascendente, o bien la señal puede adoptar cualquier estado (rojo, azul), ya que el reloj no está en marcha.

En la fila inferior se muestra de nuevo la salida de la función stopwatch() para distintos ajustes de las propiedades restart y hold. Las rampas ascendentes discontinuas muestran el tiempo transcurrido desde el flanco correspondiente situado en la base a la izquierda.

nota

stopwatch() mide únicamente la duración de un evento individual. Para determinar el tiempo de conexión acumulado de un equipo (calefacción, compresor, etc.), la función integrate(x, {...}) es la adecuada.

total_on_time = integrate(onState, {storage:'myTotalizerX'});

Aquí, onState es una señal de estado <bool> que forma el integrando como 0 o 1. Opcionalmente podría utilizarse además una señal de reset para restablecer el valor integrado.

Conversiones

Conversión de tiempo "decodeTime" ²

La función decodeTime() toma una marca de tiempo escalar t en UTC y, con la zona horaria #timezone opcional o con un desfase fijo tzDiff, la convierte a la hora local en la representación correspondiente de fecha y hora. Pueden configurarse distintas interpretaciones y formatos de salida.

TM1 = decodeTime(t);
TM2 = decodeTime(t, tzDiff);
// Optionale Konfiguration
TMx = decodeTime(..., { scale: <enum>
                      , epoch: unix|<date>
                      , useTZ: <bool>
                      , tzDiff: <int>            // deprecated
                      , format: <str> 
                      });

Propiedad	Valor	Descripción
scale	`<enum>`	Determina qué describe la parte entera de la marca de tiempo: auto: el orden de magnitud de la marca de tiempo determina la resolución (def.), o la parte entera de t cuenta... d: ... días s: ... segundos ms: ... milisegundos us: ... microsegundos ns: ... nanosegundos
epoch	`unix/<date>`	El instante de inicio del recuento se fija en la fecha UTC indicada, formato: `yyyy-mm-dd`, opcionalmente con hora `yyyy-mm-dd HH:MM[:SS]` o `yyyy-mm-ddTHH:MM[:SS]` (def.: unix 1970-01-01) Una fecha no válida se notifica como error³.
useTZ¹	`<bool>`	Utiliza para decodificar la hora la zona horaria local configurada con la macro `#timezone`. Este parámetro tiene prioridad sobre la indicación de un tzDiff; un tzDiff indicado adicionalmente se notifica como no utilizado³.
tzDiff (deprecated)	`<int>`	Desfase horario en minutos para emitir la hora local, ejemplo CET: +60, CEST: +120, EST: -300 Nota: dado que este parámetro no admite el cambio de zona horaria, en su lugar debería utilizarse el parámetro useTZ junto con la macro `#timezone`.
format	`<str>`	En lugar de un vector se emite una cadena de fecha/hora con formato. La función utiliza internamente la función de c++ `strftime()`. El formato de la salida se describe aquí. Adicionalmente pueden utilizarse los siguientes marcadores de posición: %FMS: milisegundos de 3 dígitos %FUS: microsegundos de 6 dígitos %FNS: nanosegundos de 9 dígitos en cada caso con ceros a la izquierda

Salvo que con la propiedad format se solicite la emisión de un texto de fecha y hora con formato, el resultado es un vector con los siguientes valores <uint>:

TM = [ year, month, day
     , hour, minute, second, nanoseconds
     , weekday                  // 0..6, 0 := Sunday
     , yearday
     ];

Si useTZ está activado, se añade un elemento adicional que señala el cambio a la «hora de verano»¹:

TM_local = [ year, month, day
           , hour, minute, second, nanoseconds
           , weekday                  // 0..6, 0 := Sunday
           , yearday
           , dayLightSaving
           ];

Generar un valor de tiempo "mkTime" ³

La función mkTime() convierte una indicación de tiempo en un valor numérico en segundos. La entrada x puede ser un texto o un vector de tiempo, como el que devuelve decodeTime(). Las indicaciones de tiempo absolutas dan como resultado segundos UTC desde 1970-01-01; los intervalos de tiempo, una duración en segundos. Si la entrada es una constante, se convierte ya al compilar el conjunto de fórmulas.

t1 = mkTime(x);
t2 = mkTime(x, useDLS);
// Optionale Konfiguration
tx = mkTime(..., { result: <enum>
                 , useTZ: <bool>
                 , useDLS: <bool>
                 });

Parámetro	Tipo	Descripción
x	`<str>` / `[<uint>]`	Indicación de tiempo como texto en los formatos `<date>` o `<time>`, o un vector de tiempo `[year, month, day, hour, minute, second, nanoseconds, ...]`
useDLS	`<bool>`	Opcional, tiene prioridad sobre la propiedad del mismo nombre y sobre el elemento dayLightSaving de un vector de tiempo

Propiedad	Valor	Descripción
result	`<enum>`	Restringe las entradas admisibles: sin indicación: fecha, duración o intervalo de tiempo con signo (def.) date: solo indicaciones de tiempo absolutas duration: solo intervalos de tiempo $\geq 0$ relative: solo intervalos de tiempo, también con signo Un vector de tiempo es siempre una fecha.
useTZ	`<bool>`	Las indicaciones de tiempo absolutas se interpretan en la zona horaria local configurada con la macro `#timezone` (def.: false, UTC). Una `Z` final indica siempre UTC.
useDLS	`<bool>`	Solo con useTZ: en la hora duplicada al volver a la hora estándar se elige la hora de verano (def.: false, hora estándar). Una hora que se omite en el cambio a la hora de verano da como resultado el comienzo de la hora de verano.

En el caso de un vector de tiempo, el décimo elemento dayLightSaving (véase decodeTime()) se utiliza como useDLS, siempre que useDLS no se haya indicado como parámetro. De este modo, mkTime(decodeTime(t, {useTZ:true}), {useTZ:true}) vuelve a dar como resultado la marca de tiempo t.

Una indicación de tiempo no válida o un valor fuera del calendario (p. ej. 2026-02-30) se notifica como error.

tStart = mkTime('2026-10-07 08:00');                    // 1791360000, UTC
tLocal = mkTime('2026-10-07 08:00', {useTZ:true});       // mit #timezone 'Europe/Berlin': 1791352800
shift  = mkTime('8:00:00', {result:duration});           // 28800

Disponible a partir de la versión 13 del catálogo. ↩ ↩² ↩³
Disponible a partir de la versión 11 del catálogo. ↩ ↩²
Disponible a partir de la versión 14 del catálogo. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

Conformación de señales​

Impulso de Dirac "dirac"​

Temporizador "timer"​

Ejemplo​

Retardo "delay"​

Pulso "pulse"​

Generador de funciones "periodic"​

Valores para reset:​

Mode: rect​

Mode: pwm​

Mode: time​

Mode: ramp (def.)​

Mode: ramp2​

Mode: sawtooth​

Mode: 2pi​

Mode: prbs​

Conteo y medición​

Contador "counter"​

Cronómetro "stopwatch"​

Conversiones​

Conversión de tiempo "decodeTime" 2​

Generar un valor de tiempo "mkTime" 3​

Footnotes​