Funzioni di conteggio e di tempo

Formazione del segnale

Impulso di Dirac "dirac"

La funzione emette, con il tempo di campionamento discreto globale discreteSampleTimeMs, un impulso 0-1-0 della durata di 1 ns. Il tipo restituito è <bool>.

p = dirac();

Impulso di Dirac

note

Poiché questa funzione viene di regola utilizzata per funzioni logiche, il valore restituito come <bool> è direttamente false o true. Affinché per un "vero" impulso di Dirac sia valida la condizione di integrale

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

dirac() dovrebbe essere moltiplicata per $10^{-9}$ .

suggerimento

Per campionare un segnale con il tempo di campionamento discreto discreteSampleTimeMs occorre utilizzare la funzione sample(x).

Timer "timer"

La formula seguente fornisce periodicamente, negli istanti definiti, un impulso oppure il timestamp corrispondente.

Gli impulsi possono essere utilizzati per azzerare somme o integrali oppure per acquisire i valori corrispondenti in un registro latch.

Gli impulsi non vengono recuperati se il sistema non era attivo nell'istante dell'impulso.

pulse = timer({ interval: <dbl>   // verpflichtend, sofern nicht midestens ein (*) definiert ist
              , grid: <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.

Proprietà	Valore	Descrizione
interval	`<dbl>`	Intervallo di tempo con cui viene generato un evento.
grid	`<bool>`	Se questa opzione è impostata, l'intervallo viene riferito alle `00:00:00` del giorno, indipendentemente dall'istante di avvio del calcolo.
readTime	`<bool>`	Se questa opzione è impostata, invece di un impulso di 1 nanosecondo viene emesso, all'istante dell'evento, il timestamp, uint64 in nanosecondi UTC dal 1.1.1970.
useTZ¹	`<bool>`	Per l'interpretazione dell'ora si utilizza il fuso orario locale impostato con la macro `#timezone`. Avvertenza: i timestamp che cadono nell'intervallo del cambio d'ora possono essere ignorati!
minute	`<str>`	Sintassi crontab per la definizione degli istanti degli eventi
hour	`<str>`	Sintassi crontab per la definizione degli istanti degli eventi
day	`<str>`	Sintassi crontab per la definizione degli istanti degli eventi
month	`<str>`	Sintassi crontab per la definizione degli istanti degli eventi
weekday	`<str>`	Sintassi crontab per la definizione degli istanti degli eventi

Se al posto di interval si utilizzano i parametri minute, hour, day, month e/o weekday, è possibile stabilire istanti di trigger espliciti (UTC).

Per ogni voce, nell'ordine minute, hour, day, month, weekday, sono possibili le seguenti indicazioni (sul modello della sintassi crontab):

Indicazione	Significato
nessuna indicazione	è '', se tutti gli elementi seguenti non sono definiti, altrimenti il valore minimo possibile, di norma '0' (o '1' per day* e month).
'*'	sempre / a ogni
'*/n'	a intervalli di n
'a-e'	nell'intervallo da a fino a e incluso
'a-e/n'	nell'intervallo da a fino a e incluso con passo n Esecuzione alle/il $X=a$ , $a+1\cdot n$ , $a+2\cdot n$ , $a + 3\cdot n \dots$ con $X \le e$
'a,b,c'	elenco di singoli valori qualsiasi separati da virgole Esecuzione alle/il a, b e c

Per i giorni della settimana e i mesi, al posto dei numeri si possono utilizzare anche abbreviazioni corrispondenti alle prime tre lettere della denominazione inglese: ad es. “mon”, “thu”, “apr”, “jun”, “dec”, ... .

Il conteggio dei giorni della settimana inizia con la domenica “sun” pari a 0.

Esempi di sintassi crontab:

minute:	hour:	day:	month:	weekday:	Istante dell'impulso ...
`30`	`4`				ogni giorno alle 4:30, "dopo la chiusura dell'attività"
		`1`			il giorno 1 di ogni mese alle 0:00
`'50-59/4'`	`23`	`30`	`'3-12/3'`		il 30.03., 30.6., 30.09., 30.12., rispettivamente alle 23:50, 23:54, 23:58
`'*/15'`					ogni 15 minuti, x:00, x:15, x:30, x:45
`'3-59/15'`					ogni 15 minuti, x:03, x:18, x:33, x:48
		`15`	`'apr-sep'`		il 15 dei mesi da aprile a settembre alle 0:00
		`10`	`'oct-mar'`		il 10 dei mesi da ottobre a marzo
	`'6,9,14,18'`				ogni giorno alle 6, 9, 14 e 18
	`2`	`'*'`	`'*'`	`'sun'`	ogni settimana la domenica alle 2:00
`30`	`2`			`'mon'`	AVVERTENZA: mancano le voci per day e month

warning

Nell'ultimo esempio è presente un'incongruenza, perché le voci per day e month non sono indicate e si trovano quindi in modalità automatica. Secondo le regole, per impostazione predefinita queste vengono confrontate con il loro primo valore (qui quindi 1), dato che alla loro destra è presente un'assegnazione. Ciò non porta però al risultato desiderato.

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

Nel file di log² viene emesso un avviso per questa incongruenza:

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

suggerimento

Finché viene definito un blocco continuo di proprietà, gli elementi ai margini vengono completati automaticamente in modo corretto. A sinistra con il loro valore minimo (0 o 1), a destra con '*'. Esempi:

minute, hour, day
day, month
hour, day

Esempio

Nell'Esempio 1b la funzione timer() viene utilizzata per generare un impulso di memorizzazione a un'ora fissa (chiusura dell'attività).

Ritardo "delay"

Le formule seguenti servono a filtrare e ritardare i fronti di un segnale

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

Proprietà	Valore	Descrizione
delayOn	`<dbl>`	Tempo in secondi per il ritardo del fronte positivo
delayOff	`<dbl>`	Tempo in secondi per il ritardo del fronte negativo
restart	`<bool>`	I fronti successivi durante il tempo di attesa riavviano l'intervallo di tempo
startup	`inf/<bool>`	Condizione di avvio per il rilevamento dei fronti, vedere la descrizione seguente

Il comportamento dipende dallo stato del segnale in uscita. Se questo è false, vengono considerati solo i fronti positivi sul segnale di ingresso signal e il parametro temporale delayOn. Se lo stato è true, vengono considerati i fronti negativi e il parametro temporale delayOff.

Ritardo dei fronti

La misurazione del tempo inizia sempre con il primo fronte in arrivo e può opzionalmente essere riavviata con ulteriori fronti successivi (restart: true). Lo stato di uscita cambia solo se, allo scadere del tempo, il segnale di ingresso si trova nello stato opposto. In questo modo vengono filtrate solo le brevi variazioni del segnale e le variazioni vengono inoltrate con ritardo solo dopo la stabilizzazione del segnale.

Con un true sull'ingresso reset lo stato di uscita viene riportato a false e mantenuto.

La funzione può essere utilizzata per filtrare e stabilizzare un segnale di commutazione "con rimbalzi".

Per l'avvio del sistema occorre stabilire come trattare lo storico dell'ingresso signal e se all'avvio debba quindi essere rilevato subito un fronte e avviato un tempo di attesa. A tale scopo serve la proprietà startup:

inf: il primo campione del segnale determina il valore nel passato e quindi l'uscita prima dell'avvio del sistema, quindi con il primo campione non viene generato alcun fronte.
<bool>: l'ingresso e l'uscita vengono assunti con questo valore di segnale (true, false) nel passato prima dell'avvio del sistema. In questo modo con il primo campione dell'ingresso può eventualmente essere generato un fronte e avviato un tempo di delay.

Proprietà startup

Impulso "pulse"

Le formule seguenti convertono un fronte di ingresso selezionabile su signal in un impulso booleano rettangolare di durata duration (simile a un monostabile 74HC121 o 74HC122). Con un true sul parametro reset l'uscita viene riportata a false e mantenuta. Tutti i parametri vengono interpretati come <bool>.

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

Proprietà	Valore	Descrizione
edge	`<int>`	Selezione del fronte di controllo: -1: negEdge, 0: anyEdge, +1: posEdge (default)
duration	`<dbl>`	Durata dell'impulso in secondi
restart	`<bool>`	Possibilità di prolungare l'impulso con un nuovo fronte
startup	`inf/<bool>`	Condizione di avvio per il rilevamento dei fronti, vedere la descrizione seguente

L'esempio seguente mostra per edge = +1 il comportamento della proprietà restart:

Segnale a impulso

Per l'avvio del sistema occorre stabilire come trattare lo storico dell'ingresso signal e se all'avvio debba quindi essere rilevato subito un fronte e generato un impulso. A tale scopo serve la proprietà startup:

inf: il primo campione del segnale determina il valore nel passato prima dell'avvio del sistema, quindi con il primo campione non viene generato alcun fronte.
<bool>: l'ingresso viene assunto con questo valore di segnale (true, false) nel passato prima dell'avvio del sistema. In questo modo con il primo campione può eventualmente essere generato un fronte.

Proprietà startup

Generatore di funzioni "periodic"

La funzione periodic() può essere utilizzata come generatore di funzioni e genera un segnale periodico con periodo period finché l'ingresso enable viene mantenuto a true. La forma del segnale è definita dalla proprietà mode. La frequenza di uscita corrisponde al tempo di campionamento discreto globale discreteSampleTimeMs oppure alla frequenza di uscita impostata fOut.

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

Proprietà	Valore	Descrizione
period	`<dbl>`	Periodo costante dell'andamento del segnale in secondi, corrisponde all'ingresso period Intervallo di valori: $[0.0001 .. \infty[$
mode	`<enum>`	Modalità di funzionamento (def.: ramp) [rect, pwm, time, ramp, ramp2, sawtooth, 2Pi…]
reset	`<enum>`	Ripristino dell'andamento del segnale con [stop, start, none]
control	`<dbl>`	Valore di controllo costante per PWM, corrisponde all'ingresso control
fOut	`<dbl>`	Frequenza di uscita opzionale per i punti dati in Hertz Intervallo di valori $[0.1..\infty[$
width	`<uint>`	Larghezza di uscita del segnale PRBS Intervallo di valori $[0..64]$
taps	`[<uint>]/p##`	Posizioni di retroazione PRBS o polinomio predefinito p2..p24

Gli ingressi opzionali control e period hanno la priorità sulle proprietà impostate in modo fisso. Se il periodo cambia durante l'emissione del segnale, l'andamento del segnale prosegue senza discontinuità dalla posizione di uscita attuale (*).

Anche se la scelta del periodo e della frequenza di uscita non è inizialmente soggetta ad alcuna restrizione, occorre scegliere valori ragionevoli in considerazione del funzionamento di smartCORE.

Valori per reset:

stop: (default) il valore di uscita viene ripristinato con enable == false.
start: il valore di uscita rimane fermo fino al nuovo avvio e viene ripristinato solo allora.
none: con enable == false l'uscita viene solo arrestata, non ripristinata.

Alcuni esempi di modalità di uscita in combinazione con il periodo period, la frequenza di uscita fOut, un segnale di controllo control e diverse impostazioni di reset

Segnali periodici

Mode: rect

Viene emesso un segnale rettangolare 0-1 di tipo <bool>, dove control $\in [0.0..1.0]$ rappresenta la posizione relativa del fronte positivo nell'intervallo period (default: 0.5). Lo stato di reset è 0!

Mode: pwm

Viene emesso un segnale rettangolare 1-0 di tipo <bool>, dove control $\in [0.0..1.0]$ rappresenta la posizione relativa del fronte negativo nell'intervallo period (PWM, default: 0.5). Lo stato di reset è 0!

Mode: time

Vengono emesse rampe con i valori di tempo $[0.0 .. period[$ in secondi

Mode: ramp (def.)

Vengono emesse rampe con la posizione relativa nell'intervallo come valore di scala $[0.0..1.0[$

Mode: ramp2

Vengono emesse rampe con i valori di scala $[0.0..1.0[, [-1.0 .. 0.0[$ , dove il ritorno a $-1.0$ si trova a metà del periodo.

Mode: sawtooth

Viene emesso un andamento a dente di sega $[0.0 .. 1.0 .. 0.0[$ , dove control $=[0..1]$ rappresenta la posizione relativa del picco 1.0 nell'intervallo period. Lo stato di reset è 0.0!

Mode: 2pi

Viene emessa la posizione relativa nell'intervallo come valore angolare $[0.0 .. 2π[$ per funzioni angolari a valle.

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

Mode: prbs

Emissione di un segnale di rumore pseudo-binario (pseudo random binary sequence) con frequenza di uscita fOut. La lunghezza del periodo risulta dal generatore configurato; il parametro period viene ignorato.

Sul registro a scorrimento interno a 64 bit sono previste retroazioni NXOR nelle posizioni contrassegnate da taps[]. width (def: 0) è la larghezza in bit della maschera di uscita per il registro a scorrimento, per utilizzare il PRBS nella generazione di ampiezze pseudocasuali. Con width: 0 viene emessa solo una sequenza <bool>.

Per taps si possono richiamare anche polinomi predefiniti come retroazione per lunghezze da 2 a 24 bit.

Il segnale PRBS può essere utilizzato per l'identificazione dei parametri di sistemi dinamici.

Conteggio e misura

Contatore "counter"

Le formule seguenti contano i fronti positivi in diverse configurazioni.

attenzione

Il significato dei parametri dipende dalla modalità di funzionamento impostata!

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>
                  });

Nella modalità updown (default) con i fronti positivi su up si conta in avanti e su down all'indietro (simile a un 74HC193). Se i fronti arrivano esattamente nello stesso istante, si conta $+1-1=0$ .

Nella modalità countdir vengono contati i fronti positivi sull'ingresso count e la direzione viene stabilita indipendentemente tramite l'ingresso dir di tipo <dbl> (simile a 74HC191). Se dir > 0.0 (o true) si conta in avanti, altrimenti con dir <= 0.0 (o false) all'indietro. Il default è 1.0 ovvero true (in avanti). L'uso del tipo <dbl> per la direzione consente di utilizzare un valore di misura analogico della velocità (ad es. in "m/s") per controllare la direzione di conteggio. D'altra parte l'ingresso è compatibile con segnali <bool>.

mode: countdir

Gli ambiti di applicazione sono la determinazione della posizione per movimenti lineari o rotatori oppure il conteggio, dipendente dalla direzione, di oggetti che passano davanti a una stazione di conteggio.

Nella modalità countincr il passo di conteggio viene sommato al registro tramite l'ingresso incr di tipo <int> con il fronte di salita su count. Il default è 1 (in avanti). L'ordine di grandezza di incr va adeguato in modo opportuno alla larghezza del contatore impostata, ai limiti del contatore, ecc.

Nella modalità qencoder vengono contati tutti i fronti sui segnali sfasati A e B. L'uso dei due ingressi è quindi obbligatorio. Qui è il segnale senza fronte a indicare la direzione di conteggio. Gli ambiti di applicazione sono la determinazione ad alta precisione della posizione per movimenti lineari o rotatori con risoluzione quadrupla ("Quadrature Encoder"). A tal fine i fronti dovrebbero avere esattamente le stesse distanze reciproche.

mode: qencoder

Per la disposizione mostrata nella figura risulta il seguente schema di conteggio:

A	B	Rotazione oraria Incremento	Rotazione antioraria Decremento
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 sull'ingresso reset il contatore viene impostato a preset (def: 0) e mantenuto. preset può essere passato tramite le proprietà o come quarto argomento.

Il registro del contatore è di tipo <int64>.

Proprietà	Valore	Descrizione
mode	`<enum>`	updown: ingressi di conteggio separati per avanti / indietro (def.) countdir: ingresso di conteggio e direzione separata `<dbl>` (> 0.0: in avanti) countincr: ingresso di clock e passo separato come `<int>` qencoder: tutti i fronti dei segnali di clock A, B vengono contati in funzione della direzione
start	`<int>`	Valore iniziale all'avvio di smartCORE
preset	`<int>`	Valore di ripristino con true sul parametro r
lower	`off/<int>`	Il valore di conteggio si arresta al limite inferiore, nessun overflow
upper	`off/<int>`	Il valore di conteggio si arresta al limite superiore, nessun overflow
range	`<uint>`	Intervallo del valore di conteggio $[0..range-1]$ Overflow dai valori limite a $0$ o $range-1$
modulo	`<uint>`	Intervallo del valore di conteggio `count %= modulo` con segno $[1-modulo..modulo-1]$ Overflow dai valori limite a 0
storage	`<str>`	Nome di una memoria persistente per lo stato interno. In questo modo, dopo un riavvio del sistema l'uscita assume l'ultimo valore salvato. Il contenuto di questa memoria non è utilizzabile in nessun altro punto di smartCORE.

Cronometro "stopwatch"

Le formule seguenti rappresentano un cronometro e misurano la durata di un impulso pulse oppure l'intervallo tra due fronti positivi su pulse oppure tra il primo fronte positivo su beg e il successivo fronte positivo su end. La misurazione parte sempre da $t=0.0s$ con la condizione di avvio. Con un fronte sull'ingresso lap può essere emesso un tempo intermedio (latch = true). True sull'ingresso reset porta il cronometro e l'uscita a 0.0 e li mantiene in questo stato. Tutti gli ingressi vengono interpretati come <bool>. L'uscita avviene in secondi.

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|<dbl>
                    });

Proprietà	Valore	Descrizione
latch	`<bool>`	true: il tempo viene emesso solo con i fronti di controllo (def.) false: emissione continua del tempo di misura crescente
period	`<bool>`	true: misurazione tra due fronti di salita sull'ingresso pulse false: misurazione del tempo per pulse = true
hold	`<bool>`	true: l'uscita viene impostata al nuovo valore di misura solo al termine della misurazione. false: l'uscita viene impostata a 0 con una misurazione nuova/in corso.
restart	`<bool>`	true: ogni fronte di salita su beg riavvia la misurazione false: solo il primo fronte di salita su beg avvia la misurazione (def.)
upper	`off/<dbl>`	Quando viene raggiunto questo valore di tempo, avviene l'emissione e la misurazione viene interrotta. (def.: off)

Nella prima forma viene utilizzato solo un segnale a impulsi pulse. Il diagramma seguente mostra diverse configurazioni e possibilità di emissione per la misurazione su un segnale a impulsi:

Misura del tempo su segnale a impulsi

La prima riga mostra un qualsiasi segnale a impulsi da misurare.

La seconda riga mostra, per la misura della durata dell'impulso, con le rampe tratteggiate crescenti il tempo trascorso dal fronte corrispondente alla base a sinistra. In magenta, infine, l'uscita della funzione stopwatch() per diverse proprietà latch, hold o upper.

La terza riga mostra, per la misura del periodo, con le rampe tratteggiate crescenti di nuovo il tempo trascorso dal fronte corrispondente alla base a sinistra. In arancione o blu, infine, l'uscita della funzione stopwatch() in funzione delle proprietà latch o upper.

Per il funzionamento con gli ingressi beg, lap e end la configurazione dell'uscita è analoga. Con la proprietà restart una misurazione attiva può ricominciare da 0.0 a ogni nuovo fronte su beg, per cui viene misurata la distanza dall'ultimo fronte di salita al fronte su end. In questa modalità l'emissione di tempi intermedi può essere fuorviante. Nel diagramma seguente la proprietà latch = true è impostata per consentire l'emissione di tempi intermedi.

Misura del tempo Begin Lap End

Le prime tre righe mostrano andamenti temporali esemplificativi dei segnali di ingresso beg, lap e end. L'ingresso lap è opzionale. Nelle aree tratteggiate, o è possibile in qualsiasi momento un ritorno del segnale a false (verde), poiché per l'ingresso beg è rilevante solo un fronte di salita, oppure il segnale può assumere qualsiasi stato (rosso, blu), perché il cronometro non è avviato.

Nella riga inferiore segue di nuovo l'uscita della funzione stopwatch() per diverse impostazioni delle proprietà restart e hold. Le rampe tratteggiate crescenti mostrano il tempo trascorso dal fronte corrispondente alla base a sinistra.

note

stopwatch() misura solo la durata di un singolo evento. Per determinare la durata di accensione cumulata di un'apparecchiatura (riscaldamento, compressore, ecc.) è adatta la funzione integrate(x, {...}).

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

Qui onState è un segnale di stato <bool> che forma, come 0 o 1, l'integrando. Opzionalmente si potrebbe utilizzare anche un segnale di reset per azzerare il valore integrato.

Conversioni

Conversione del tempo "decodeTime" ²

La funzione decodeTime() prende un timestamp scalare t in UTC e lo converte nella corrispondente rappresentazione di data e ora, con il fuso orario #timezone opzionale oppure con un offset fisso tzDif verso l'ora locale. È possibile impostare diverse interpretazioni e formati di output.

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

Proprietà	Valore	Descrizione
scale	`<enum>`	Determina che cosa descrive la parte intera del timestamp: auto: l'ordine di grandezza del timestamp determina la risoluzione (def.), oppure la parte intera di t conta... d: ... giorni s: ... secondi ms: ... millisecondi us: ... microsecondi ns: ... nanosecondi
epoch	`unix/<date>`	L'istante di inizio del conteggio viene fissato alla data UTC indicata, formato: 'yyyy-mm-dd', opzionalmente con indicazione dell'ora 'yyyy-mm-dd HH:MM' (def.: unix 1970-01-01)
useTZ¹	`<bool>`	Per la decodifica dell'ora si utilizza il fuso orario locale impostato con la macro `#timezone`. Questo parametro sovrascrive l'indicazione di tzDif.
tzDif (deprecated)	`<int>`	Offset temporale in minuti per l'emissione dell'ora locale, esempio CET: +60, CEST: +120, EST: -300 Nota: poiché questo parametro non supporta il passaggio tra fusi orari, è preferibile utilizzare invece il parametro useTZ insieme alla macro `#timezone`.
format	`<str>`	Invece di un vettore viene emessa una stringa di data/ora formattata. Internamente la funzione utilizza la funzione c++ `strftime()`. La formattazione dell'output è descritta qui. Si possono inoltre utilizzare i seguenti segnaposto: %FMS: millisecondi a 3 cifre %FUS: microsecondi a 6 cifre %FNS: nanosecondi a 9 cifre rispettivamente con zeri iniziali

Se con la proprietà format non viene richiesta l'emissione di un testo di data e ora formattato, il risultato è un vettore con i seguenti valori <uint>:

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

Se useTZ è impostato, viene aggiunto un elemento supplementare per segnalare il passaggio all'"ora legale"¹:

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

Disponibile dalla versione 13 del catalogo. ↩ ↩² ↩³
Disponibile dalla versione 11 del catalogo. ↩ ↩²

Formazione del segnale​

Impulso di Dirac "dirac"​

Timer "timer"​

Esempio​

Ritardo "delay"​

Impulso "pulse"​

Generatore di funzioni "periodic"​

Valori per reset:​

Mode: rect​

Mode: pwm​

Mode: time​

Mode: ramp (def.)​

Mode: ramp2​

Mode: sawtooth​

Mode: 2pi​

Mode: prbs​

Conteggio e misura​

Contatore "counter"​

Cronometro "stopwatch"​

Conversioni​

Conversione del tempo "decodeTime" 2​

Footnotes​