Fonctions de comptage et de temps

Mise en forme de signaux

Impulsion de Dirac « dirac »

La fonction émet, avec le temps d'échantillonnage discret global discreteSampleTimeMs, une impulsion 0-1-0 d'une durée de 1 ns. Le type de retour est <bool>.

p = dirac();

Impulsion de Dirac

remarque

Comme cette fonction est généralement utilisée pour des fonctions logiques, la valeur de retour de type <bool> est directement false ou true. Pour que la condition d'intégrale d'une « véritable » impulsion de Dirac

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

soit vérifiée, dirac() devrait être multipliée par $10^{-9}$ .

astuce

Pour échantillonner un signal avec le temps d'échantillonnage discret discreteSampleTimeMs, il faut utiliser la fonction sample(x).

Timer « timer »

La formule suivante fournit périodiquement, aux instants définis, une impulsion ou l'horodatage correspondant.

Les impulsions peuvent servir à réinitialiser des sommations ou des intégrales, ou à reprendre les valeurs correspondantes dans un registre latch.

Les impulsions ne sont pas rattrapées si le système n'était pas actif à l'instant de l'impulsion.

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.

Propriété	Valeur	Description
interval	`<dbl>`	Intervalle de temps dans lequel un événement est déclenché.
grid	`<bool>`	Si cette option est activée, l'intervalle est rapporté à `00:00:00` du jour, indépendamment de l'heure de démarrage du calcul.
readTime	`<bool>`	Si cette option est activée, l'horodatage est émis à l'instant de l'événement à la place d'une impulsion de 1 nanoseconde, uint64 en nanosecondes UTC depuis le 1.1.1970.
useTZ¹	`<bool>`	Utilise, pour interpréter l'heure, le fuseau horaire local réglé avec la macro `#timezone`. Avertissement : les horodatages tombant dans la période du changement d'heure peuvent être manqués !
minute	`<str>`	Syntaxe crontab pour définir les instants des événements
hour	`<str>`	Syntaxe crontab pour définir les instants des événements
day	`<str>`	Syntaxe crontab pour définir les instants des événements
month	`<str>`	Syntaxe crontab pour définir les instants des événements
weekday	`<str>`	Syntaxe crontab pour définir les instants des événements

Si les paramètres minute, hour, day, month et/ou weekday sont utilisés à la place de interval, des instants de déclenchement explicites (UTC) peuvent être définis.

Pour chaque entrée, dans l'ordre minute, hour, day, month, weekday, les indications suivantes sont possibles (inspirées de la syntaxe crontab) :

Indication	Signification
aucune indication	vaut '' si tous les éléments suivants sont non définis, sinon la plus petite valeur possible, en général '0' (resp. '1' pour day* et month).
'*'	toujours / à chaque
'*/n'	à intervalle de n
'a-e'	dans la plage de a jusqu'à e inclus
'a-e/n'	dans la plage de a jusqu'à e inclus avec un pas de n Exécution à/le $X=a$ , $a+1\cdot n$ , $a+2\cdot n$ , $a + 3\cdot n \dots$ avec $X \le e$
'a,b,c'	liste de valeurs individuelles quelconques séparées par des virgules Exécution à/le a, b et c

Pour les jours de la semaine et les mois, des noms abrégés peuvent être utilisés à la place de nombres, correspondant aux trois premières lettres de la désignation anglaise : par ex. “mon”, “thu”, “apr”, “jun”, “dec”, ... .

Le décompte des jours de la semaine commence le dimanche “sun” avec 0.

Exemples de la syntaxe crontab :

minute:	hour:	day:	month:	weekday:	Instant de l'impulsion ...
`30`	`4`				tous les jours à 4:30, « après la fermeture »
		`1`			le 1er de chaque mois à 0:00
`'50-59/4'`	`23`	`30`	`'3-12/3'`		le 30.03., 30.6., 30.09., 30.12., chaque fois à 23:50, 23:54, 23:58
`'*/15'`					toutes les 15 minutes, x:00, x:15, x:30, x:45
`'3-59/15'`					toutes les 15 minutes, x:03, x:18, x:33, x:48
		`15`	`'apr-sep'`		le 15 des mois d'avril à septembre à 0:00
		`10`	`'oct-mar'`		le 10 des mois d'octobre à mars
	`'6,9,14,18'`				tous les jours à 6, 9, 14 et 18 heures
	`2`	`'*'`	`'*'`	`'sun'`	chaque semaine le dimanche à 2:00
`30`	`2`			`'mon'`	AVERTISSEMENT : les entrées pour day et month sont absentes

attention

Dans le dernier exemple, il existe une incohérence, car les entrées pour day et month ne sont pas indiquées et sont donc en mode automatique. Selon les règles, elles sont comparées par défaut à leur première valeur (ici donc 1), puisqu'une affectation figure à leur droite. Cela ne conduit toutefois pas au résultat souhaité.

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

Un avertissement concernant cette incohérence est émis dans le fichier journal² :

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

astuce

Tant qu'un bloc continu de propriétés est défini, les éléments de bord sont complétés automatiquement de manière correcte. À gauche avec leur plus petite valeur (0 ou 1), à droite avec '*'. Exemples :

minute, hour, day
day, month
hour, day

Exemple

Dans l'exemple 1b, la fonction timer() est utilisée pour générer une impulsion de mémorisation à une heure fixe (fermeture).

Temporisation « delay »

Les formules suivantes servent à filtrer et à temporiser les fronts d'un signal

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

Propriété	Valeur	Description
delayOn	`<dbl>`	Temps en secondes pour temporiser le front positif
delayOff	`<dbl>`	Temps en secondes pour temporiser le front négatif
restart	`<bool>`	Les fronts suivants pendant le temps d'attente relancent l'intervalle de temps
startup	`inf/<bool>`	Condition de départ pour la détection de fronts, voir la description ci-après

Le comportement dépend de l'état du signal de sortie. S'il est false, seuls les fronts positifs du signal d'entrée signal et le paramètre de temps delayOn sont pris en compte. S'il est true, les fronts négatifs et le paramètre de temps delayOff sont pris en compte.

Temporisation de fronts

La mesure du temps commence à chaque fois avec le premier front reçu et peut éventuellement être relancée par d'autres fronts suivants (restart : true). L'état de sortie ne change que si, à l'expiration du temps, le signal d'entrée se trouve dans l'état opposé. Ainsi, seuls les changements de signal brefs sont filtrés et les changements de signal ne sont transmis, avec retard, qu'après stabilisation du signal.

Avec un true sur l'entrée reset, l'état de sortie est remis à false et maintenu.

La fonction peut être utilisée pour filtrer et stabiliser un signal de commutation « rebondissant ».

Pour le démarrage du système, il faut définir comment traiter le passé de l'entrée signal et si un front doit ainsi être détecté immédiatement au démarrage, déclenchant un temps d'attente. La propriété startup sert à cela :

inf : le premier échantillon du signal détermine la valeur dans le passé et donc la sortie avant le démarrage du système ; aucun front n'est donc déclenché avec le premier échantillon.
<bool> : l'entrée et la sortie sont supposées avoir cette valeur de signal (true, false) dans le passé avant le démarrage du système. Un front peut ainsi éventuellement être déclenché avec le premier échantillon de l'entrée et un temps de delay être démarré.

Propriété startup

Impulsion « pulse »

Les formules suivantes transforment un front d'entrée au choix sur signal en une impulsion booléenne rectangulaire de durée duration (similaire à un monostable 74HC121 ou 74HC122). Avec un true sur le paramètre reset, la sortie est remise à false et maintenue. Tous les paramètres sont interprétés comme <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>
                });

Propriété	Valeur	Description
edge	`<int>`	Choix du front de commande : -1 : negEdge, 0 : anyEdge, +1 : posEdge (par défaut)
duration	`<dbl>`	Durée de l'impulsion en secondes
restart	`<bool>`	Prolongation de l'impulsion possible avec un nouveau front
startup	`inf/<bool>`	Condition de départ pour la détection de fronts, voir la description ci-après

L'exemple suivant montre, pour edge = +1, le comportement de la propriété restart :

Signal d'impulsion

Pour le démarrage du système, il faut définir comment traiter le passé de l'entrée signal et si un front doit ainsi être détecté immédiatement au démarrage, déclenchant une impulsion. La propriété startup sert à cela :

inf : le premier échantillon du signal détermine la valeur dans le passé avant le démarrage du système ; aucun front n'est donc déclenché avec le premier échantillon.
<bool> : l'entrée est supposée avoir cette valeur de signal (true, false) dans le passé avant le démarrage du système. Un front peut ainsi éventuellement être déclenché avec le premier échantillon.

Propriété startup

Générateur de fonctions « periodic »

La fonction periodic() peut être utilisée comme générateur de fonctions et produit un signal périodique de période period tant que l'entrée enable est maintenue à true. La forme du signal est définie par la propriété mode. La cadence de sortie correspond au temps d'échantillonnage discret global discreteSampleTimeMs ou à la cadence de sortie fOut définie.

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

Propriété	Valeur	Description
period	`<dbl>`	Période constante de l'allure du signal en secondes, correspond à l'entrée period Plage de valeurs : $[0.0001 .. \infty[$
mode	`<enum>`	Mode de fonctionnement (déf. : ramp) [rect, pwm, time, ramp, ramp2, sawtooth, 2Pi…]
reset	`<enum>`	Réinitialisation de l'allure du signal avec [stop, start, none]
control	`<dbl>`	Valeur de commande constante pour PWM, correspond à l'entrée control
fOut	`<dbl>`	Cadence de sortie facultative des points de données en hertz Plage de valeurs $[0.1..\infty[$
width	`<uint>`	Largeur de sortie du signal PRBS Plage de valeurs $[0..64]$
taps	`[<uint>]/p##`	Positions de rétroaction PRBS ou polynôme prédéfini p2..p24

Les entrées facultatives control et period sont prioritaires sur les propriétés réglées de manière fixe. Si la période change pendant la sortie du signal, l'allure du signal se poursuit sans à-coup à la position de sortie actuelle (*).

Même si le choix de la période et de la cadence de sortie n'est a priori soumis à aucune restriction, il convient de choisir des valeurs raisonnables au regard du fonctionnement de smartCORE.

Valeurs pour reset :

stop : (par défaut) La valeur de sortie est réinitialisée avec enable == false.
start : La valeur de sortie reste figée jusqu'au prochain démarrage et n'est réinitialisée qu'à ce moment.
none : La sortie est seulement suspendue avec enable == false, et non réinitialisée.

Quelques exemples de modes de sortie en liaison avec la période period, la cadence de sortie fOut, un signal de commande control et différents réglages de reset

Signaux périodiques

Mode : rect

Un signal rectangulaire 0-1 de type <bool> est émis, control $\in [0.0..1.0]$ représentant la position relative du front positif dans l'intervalle period (par défaut : 0.5). L'état de réinitialisation est 0 !

Mode : pwm

Un signal rectangulaire 1-0 de type <bool> est émis, control $\in [0.0..1.0]$ représentant la position relative du front négatif dans l'intervalle period (PWM, par défaut : 0.5). L'état de réinitialisation est 0 !

Mode : time

Des rampes avec les valeurs de temps $[0.0 .. period[$ en secondes sont émises

Mode : ramp (déf.)

Des rampes avec la position relative dans l'intervalle comme valeur d'échelle $[0.0..1.0[$ sont émises

Mode : ramp2

Des rampes avec les valeurs d'échelle $[0.0..1.0[, [-1.0 .. 0.0[$ sont émises, le retour à $-1.0$ se situant au milieu de la période.

Mode : sawtooth

Une allure en dents de scie $[0.0 .. 1.0 .. 0.0[$ est émise, control $=[0..1]$ représentant la position relative du sommet à 1.0 dans l'intervalle period. L'état de réinitialisation est 0.0 !

Mode : 2pi

La position relative dans l'intervalle est émise sous forme de valeur angulaire $[0.0 .. 2π[$ pour des fonctions angulaires en aval.

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

Mode : prbs

Émission d'un signal de bruit pseudo-binaire (pseudo random binary sequence) à la fréquence de sortie fOut. La longueur de période résulte du générateur configuré ; le paramètre period est ignoré.

Sur le registre à décalage interne de 64 bits, des rétroactions NXOR sont prévues aux positions marquées par taps[]. width (déf. : 0) est la largeur en bits du masque de sortie du registre à décalage, afin d'utiliser le PRBS pour générer des amplitudes pseudo-aléatoires. Avec width : 0, seule une séquence <bool> est émise.

Pour taps, des polynômes prédéfinis peuvent également être appelés comme rétroaction pour des longueurs de 2 .. 24 bits.

Le signal PRBS peut être utilisé pour l'identification de paramètres de systèmes dynamiques.

Comptage et mesure

Compteur « counter »

Les formules suivantes comptent les fronts positifs dans différentes configurations.

attention

La signification des paramètres dépend du mode de fonctionnement réglé !

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 mode updown (par défaut), les fronts positifs sur up font compter en incrémentation et ceux sur down en décrémentation (similaire à un 74HC193). Si les fronts arrivent exactement au même instant, on compte $+1-1=0$ .

En mode countdir, les fronts positifs sur l'entrée count sont comptés et le sens est fixé indépendamment par l'entrée dir de type <dbl> (similaire au 74HC191). Si dir > 0.0 (ou true), on compte en incrémentation, sinon, avec dir <= 0.0 (ou false), en décrémentation. La valeur par défaut est 1.0 resp. true (incrémentation). L'utilisation du type <dbl> pour le sens permet d'utiliser une valeur de mesure de vitesse analogique (par ex. en « m/s ») pour piloter le sens de comptage. D'autre part, l'entrée est compatible avec des signaux <bool>.

mode: countdir

Les domaines d'application sont la détermination de position pour des mouvements linéaires ou rotatifs, ou encore le comptage, dépendant du sens, d'objets passant devant un poste de comptage.

En mode countincr, le pas de comptage est ajouté au registre via l'entrée incr de type <int> sur front montant de count. La valeur par défaut est 1 (incrémentation). L'ordre de grandeur de incr doit être adapté de manière judicieuse à la largeur du compteur réglée, aux limites du compteur, etc.

En mode qencoder, tous les fronts des signaux déphasés A et B sont comptés. L'utilisation des deux entrées est donc obligatoire. Le signal sans front indique alors à chaque fois le sens de comptage. Les domaines d'application sont la détermination de position de haute précision pour des mouvements linéaires ou rotatifs avec une résolution quadruple (« Quadrature Encoder »). Pour cela, les fronts doivent présenter exactement les mêmes écarts entre eux.

mode: qencoder

Pour la disposition représentée sur l'image, on obtient le schéma de comptage suivant :

A	B	Sens horaire Incrémentation	Sens anti-horaire Décrémentation
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

Avec un true sur l'entrée reset, le compteur est mis à preset (déf. : 0) et maintenu. preset peut être transmis via les propriétés ou comme quatrième argument.

Le registre de comptage est de type <int64>.

Propriété	Valeur	Description
mode	`<enum>`	updown : entrées de comptage séparées pour incrémentation / décrémentation (déf.) countdir : entrée de comptage et sens séparé `<dbl>` (> 0.0 : incrémentation) countincr : entrée d'horloge et pas séparé sous forme de `<int>` qencoder : tous les fronts des signaux d'horloge A, B sont comptés en fonction du sens
start	`<int>`	Valeur de départ au démarrage de smartCORE
preset	`<int>`	Valeur de réinitialisation avec true sur le paramètre r
lower	`off/<int>`	La valeur de comptage s'arrête à la limite inférieure, pas de débordement
upper	`off/<int>`	La valeur de comptage s'arrête à la limite supérieure, pas de débordement
range	`<uint>`	Plage de la valeur de comptage $[0..range-1]$ Débordement des valeurs de bord vers $0$ ou $range-1$
modulo	`<uint>`	Plage de la valeur de comptage `count %= modulo` avec signe $[1-modulo..modulo-1]$ Débordement des valeurs de bord vers 0
storage	`<str>`	Nom d'une mémoire persistante pour l'état interne. Après un redémarrage du système, la sortie reprend ainsi la dernière valeur enregistrée. Le contenu de cette mémoire n'est utilisable à aucun autre endroit dans smartCORE.

Chronomètre « stopwatch »

Les formules suivantes représentent un chronomètre et mesurent la durée d'une impulsion pulse ou l'intervalle entre deux fronts positifs sur pulse, ou entre le premier front positif sur beg et le front positif suivant sur end. La mesure commence toujours à $t=0.0s$ avec la condition de départ. Un front sur l'entrée lap permet d'émettre un temps intermédiaire (latch = true). True sur l'entrée reset remet le chronomètre et la sortie à 0.0 et les maintient dans cet état. Toutes les entrées sont interprétées comme <bool>. La sortie s'effectue en secondes.

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

Propriété	Valeur	Description
latch	`<bool>`	true : le temps n'est émis qu'avec les fronts de commande (déf.) false : émission continue du temps de mesure croissant
period	`<bool>`	true : mesure entre deux fronts montants sur l'entrée pulse false : mesure de la durée pour pulse = true
hold	`<bool>`	true : la sortie n'est mise à la nouvelle valeur mesurée qu'à la fin de la mesure. false : la sortie est mise à 0 avec une nouvelle mesure / une mesure en cours.
restart	`<bool>`	true : chaque front montant sur beg relance la mesure false : seul le premier front montant sur beg démarre la mesure (déf.)
upper	`off/<dbl>`	Lorsque cette valeur de temps est atteinte, la sortie a lieu et la mesure est interrompue. (déf. : off)

Dans la première forme, seul un signal d'impulsion pulse est utilisé. Le diagramme suivant montre différentes configurations et possibilités de sortie pour la mesure sur un signal d'impulsion :

Mesure de temps sur signal d'impulsion

La première ligne montre un signal d'impulsion quelconque à mesurer.

La deuxième ligne montre, pour la mesure de durée d'impulsion, avec les rampes croissantes en pointillés, le temps écoulé depuis le front correspondant au point d'origine à gauche. En magenta figure enfin la sortie de la fonction stopwatch() pour différentes propriétés latch, hold ou upper.

La troisième ligne montre, pour la mesure de période, avec les rampes croissantes en pointillés, de nouveau le temps écoulé depuis le front correspondant au point d'origine à gauche. En orange ou en bleu figure enfin la sortie de la fonction stopwatch() en fonction des propriétés latch ou upper.

Pour le fonctionnement avec les entrées beg, lap et end, la configuration de la sortie est adaptée en conséquence. Avec la propriété restart, une mesure active peut repartir de 0.0 à chaque nouveau front sur beg, ce qui permet de mesurer l'écart entre le dernier front montant et le front sur end. Dans ce mode de fonctionnement, l'émission de temps intermédiaires peut prêter à confusion. Dans le diagramme suivant, la propriété latch = true est activée afin de permettre l'émission de temps intermédiaires.

Mesure de temps Begin Lap End

Les trois premières lignes montrent des allures temporelles à titre d'exemple des signaux d'entrée beg, lap et end. L'entrée lap est facultative. Dans les zones en pointillés, soit un retour du signal à false (vert) est possible à n'importe quel instant, puisque seul un front montant est pertinent pour l'entrée beg, soit le signal peut prendre n'importe quel état (rouge, bleu), car le chronomètre n'est pas démarré.

Dans la ligne du bas figure de nouveau la sortie de la fonction stopwatch() pour différents réglages des propriétés restart et hold. Les rampes croissantes en pointillés montrent le temps écoulé depuis le front correspondant au point d'origine à gauche.

remarque

stopwatch() ne mesure que la durée d'un événement isolé. Pour déterminer la durée de fonctionnement cumulée d'un équipement (chauffage, compresseur, etc.), la fonction integrate(x, {...}) est appropriée.

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

Ici, onState est un signal d'état <bool> qui forme, avec 0 ou 1, l'intégrande. Un signal de réinitialisation pour remettre à zéro la valeur intégrée pourrait en outre être utilisé en option.

Conversions

Conversion de temps « decodeTime » ²

La fonction decodeTime() prend un horodatage scalaire t en UTC et le convertit, avec le fuseau horaire #timezone facultatif ou un décalage fixe tzDif vers l'heure locale, en la représentation de date et d'heure correspondante. Différentes interprétations et formats de sortie peuvent être réglés.

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

Propriété	Valeur	Description
scale	`<enum>`	Détermine ce que décrit la partie entière de l'horodatage : auto : l'ordre de grandeur de l'horodatage détermine la résolution (déf.), ou la partie entière de t compte... d : ... des jours s : ... des secondes ms : ... des millisecondes us : ... des microsecondes ns : ... des nanosecondes
epoch	`unix/<date>`	L'instant de départ du comptage est fixé à la date UTC indiquée, format : 'yyyy-mm-dd', éventuellement avec heure 'yyyy-mm-dd HH:MM' (déf. : unix 1970-01-01)
useTZ¹	`<bool>`	Utilise, pour décoder l'heure, le fuseau horaire local réglé avec la macro `#timezone`. Ce paramètre remplace l'indication d'un tzDif.
tzDif (deprecated)	`<int>`	Décalage horaire en minutes pour la sortie de l'heure locale, exemple CET : +60, CEST : +120, EST : -300 Remarque : comme ce paramètre ne prend pas en charge le changement de fuseau horaire, il convient d'utiliser à la place le paramètre useTZ avec la macro `#timezone`.
format	`<str>`	Au lieu d'un vecteur, une chaîne de date/heure formatée est émise. La fonction utilise en interne la fonction c++ `strftime()`. Le formatage de la sortie est décrit ici. Les espaces réservés suivants peuvent en outre être utilisés : %FMS : millisecondes sur 3 chiffres %FUS : microsecondes sur 6 chiffres %FNS : nanosecondes sur 9 chiffres chaque fois avec zéros en tête

Sauf si l'émission d'un texte de date et d'heure formaté est demandée avec la propriété format, le résultat est un vecteur contenant les valeurs <uint> suivantes :

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

Si useTZ est activé, un élément supplémentaire signalant le passage à l'« heure d'été » est ajouté¹ :

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

Disponible à partir de la version 13 du catalogue. ↩ ↩² ↩³
Disponible à partir de la version 11 du catalogue. ↩ ↩²

Mise en forme de signaux​

Impulsion de Dirac « dirac »​

Timer « timer »​

Exemple​

Temporisation « delay »​

Impulsion « pulse »​

Générateur de fonctions « periodic »​

Valeurs pour reset :​

Mode : rect​

Mode : pwm​

Mode : time​

Mode : ramp (déf.)​

Mode : ramp2​

Mode : sawtooth​

Mode : 2pi​

Mode : prbs​

Comptage et mesure​

Compteur « counter »​

Chronomètre « stopwatch »​

Conversions​

Conversion de temps « decodeTime » 2​

Footnotes​