SEIZED BY DARK ARMY @D4rkArmy

You have been breached by the Dark Army.

Vous n'êtes pas identifié(e).

Annonce

SEIZED BY DARK ARMY You have been breached by the Dark Army @D4rkArmy

#1 19/01/2008 15h40

_Kilburn
SEIZED BY DARK ARMY @D4rkArmy
Inscription : 14/12/2007
Messages : 167

[WireMod] Traduction de la doc officielle de l'Expression Gate

Je sais que cette documentation existe déjà ici, mais elle est incomplète et pas très bien traduite, donc voici ma traduction complète, peut être que vous comprendrez mieux. smile



Expression Gate

Ceci est une documentation traduite de la documentation officielle en anglais de l'Expression gate qui se trouve ici. Je me suis permis de retirer quelques informations obsolètes et d'ajouter d'autres petites infos utiles pour mieux comprendre.

Si vous avez du mal à comprendre quelque chose, le mieux est d'expérimenter avec votre jeu, rien de tel que l'expérience pour comprentre les choses.  tongue
Et s'il n'y a vraiment pas moyen, ben postez sur ce forum ou envoyez moi un mail et j'essaierai de vous expliquer plus clairement.

Sommaire


     - Introduction
     - L'Expression Gate
     - Variables
     - Inputs et Outputs
     - Fonctions
     - Opérateurs arithmétiques
     - Opérateurs d'assignement
     - Opérateurs de comparaison
     - Opérateurs logiques
     - Expressions conditionnelles
     - Déclarations conditionnelles
     - Suites d'expressions
     - Paquets
     - Horloge interne
     - Syntaxes spéciales
     - Infos complémentaires
     - Exemples pour débuter
     - Références des fonctions


Introduction

L'Expression Gate n'introduit pas vraiment de fonctions nouvelles en plus de celles des divers gates (arithmetic, logic, etc...) existants, mais en revanche, permet de créer des systèmes bien plus complexes et compacts en utilisant un minimum de gates, et de réutiliser des expressions déjà écrites. Donc, en pratique, il permet de combiner les fonctions de tous les gates en un seul gate, bien qu'en utilisant les quelques fonctions avancées disponibles, il est aussi possible d'utiliser l'expression gate comme une mémoire ou un timer.


A propos du CPU :
Pour mettre au clair tous les débats et malentendus sur la différence entre l'Expression gate et le CPU chip, il est important de comprendre exactement la différence entre un gate et un chip. Un gate, littéralement, une porte, ne génère une sortie (output) que lorsque quelque chose entre (input).
Pour faire simple, vous donnez quelque chose à un gate, et il vous pond quelque chose en retour, en fonction de ce que vous lui avez donné. Un chip, par contre, n'a pas besoin d'inputs pour fonctionner, il est capable de vous pondre des trucs continuellement, sans que vous lui donniez quoi que ce soit. L'Expression gate n'est pas un gate à part entière, parce qu'il peut conserver des valeurs à long terme, mais à part cela, il a toutes les propriétés d'un gate, il ne peut pas agir par lui-même, alors que le CPU chip peut sortir des valeurs différentes et faire des calculs internes sans, en théorie, recevoir aucune valeur en entrée. En bref, alors que le CPU chip peut changer continuellement ses valeurs en sortie (outputs), l'expression gate attendra toujours de recevoir des entrées (inputs) avant d'agir.

ndt : Ce qui n'est plus vrai depuis que la fonction timer interne a été ajoutée à l'Expression Gate, c'est pourquoi celui ci a été renommé en Expression Chip depuis peu. Vous pouvez donc ignorer ce qui a été écrit ci-dessus.


L'idée principale que vous devez garder en tête, c'est que l'Expression gate est exclusivement utilisé pour faire des calculs, donc le CPU chip peut faire tout ce que l'Expression gate fait. La plus grande différence entre l'Expression gate et le CPU chip est que le CPU peut être utilisé pour exécuter un véritable programme comportant des boucles et des fonctions répétitives (récursivité), alors que l'Expression gate exécute son code de façon linéaire, sans boucler sur quoi que ce soit, et ne peut se souvenir de valeurs que de manière très limitée.


Voici quelques exemples pour donner une idée des différentes applications de l'Expression gate et du CPU chip (évidemment, ce ne sont que des exemples, et non une règle, rien ne vous empêche de vous compliquer la vie et de programmer un missile à tête chercheuse avec un CPU):

Expression Gate
Calculs et statistiques : Tout ce qui est opérations mathématiques, et calculs de statistiques en utilisant la valeur d'une entrée à différents instants.
Missile autoguidé : La direction est tout simplement contrôlée à partir des coordonnées de la cible, qui sont mises à jour en permanence.
Wire Scribe de Qjet : Dessine des points en tirant sur une surface, l'Expression gate gère simplement la position du tir en fonction des coordonnées auxquelles on veut tracer les points.

CPU Chip
Radars et autres machines devant afficher des informations rapidement : Impossible avec l'Expression Gate car celui-ci n'a pas une vitesse de calcul assez rapide, contrairement au CPU.
Système d'exploitation : Un système qui gère des données et des périphériques externes, comme Windows ou Linux, impossible à faire avec l'Expression Gate car celui-ci n'est pas capable de stocker de la mémoire et n'a pas les propriétés spéciales du CPU (exécution indépendante, vitesse variable, etc...)


En bref, le CPU est théoriquement largement supérieur à l'Expression gate. Le seul défaut, c'est qu'il est bien plus difficile et long d'écrire un programme qui fait des calculs complexe avec un CPU qu'avec un Expression Gate. Gardez cela en tête : l'Expression gate peut faire des calculs, le CPU peut tout faire.
Le seul et unique intérêt de l'Expression Gate est qu'il permet de gagner de la place et du temps, et de remplacer une dizaine de gates par un gate unique.

Si quelque chose est possible en utilisant des gates, c'est aussi possible avec un Expression gate, et vice-versa.


L'Expression Gate

L'expression gate fonctionne comme n'importe quel gate, sauf que vous devez entrer un programme valide avant de pouvoir le créer, cliquez donc sur le bouton "New Expression..." dans le menu, ce qui vous permet d'entrer des expressions. Une fois que vous avez créé votre gate, vous pouvez remplacer son programme par un autre en tirant dessus à nouveau avec le tir primaire (clic gauche). Vous pouvez aussi prendre le programme d'un expression gate et l'éditer en faisant un tir secondaire (clic droit) sur l'expression gate concerné, son programme apparaitra alors dans le menu de l'expression gate.
En utilisant Reload (R) sur un expression gate, vous pouvez remettre à zéro ses variables internes. (voir "Inputs et Outputs")

Tant que le nouveau programme que vous injectez à un expression gate a les mêmes inputs que le programme précédent, les liaisons wire ne seront pas déconnectées. Par contre, si vous retirez un input ou un output déjà branché, la liaison correspondante disparaîtra.

S'il y a une erreur, un message vous en avertira quand vous essayerez de créer l'expression gate, donnant des détails sur la nature de l'erreur. Les messages d'erreur ne sont en général pas très explicites, ils ne vous donneront que des informations sur quelque chose qui manque, ou qui est en trop à un certain endroit. Par exemple, si l'erreur est "Expected (() near (,)", cela signifie qu'il s'attendait à un "(" derrière un "," à une certaine ligne. Si la ligne fautive est par exemple "A = fonc, B = 0", en admettant que fonc soit le nom d'une fonction, c'est parce que "A = fonc" n'est pas un appel de fonction correct car il manque une paire de parenthèses après "fonc". L'erreur est donc corrigée en écrivant "A = fonc(), B = 0".


Variables

Les variables sont des moyens de stocker et de transférer des valeurs, exactement comme les variables mémoire de votre calculatrice.

Attention: Tous les noms de variable doivent commencer par une lettre majuscule pour être correctement interprétés. Toutes les variables qui ne sont pas des inputs seront sauvegardées en mémoire entre chaque exécution, ce qui signifie que si vous réglez une variable (non-input) à 1, sa valeur sera toujours 1 jusqu'à ce que vous la changiez. Ce qui permet de faire des systèmes utilisant une mémoire interne limitée, comme un compteur par exemple.

A, A2, A3, Out, TotalDistance... sont des noms de variable corrects.
lol, totalDistance, 2A... sont des noms de variable incorrects.

Inputs et Outputs

Les inputs et les outputs sont des variables comme les autres, seulement, elles sont liées aux inputs (entrées) et aux outputs (sorties) de l'Expression gate. C'est à dire que tout ce qui est connecté à l'input A d'un expression gate déclenchera une exécution de l'expression à chaque fois que sa valeur change, et que la variable nommée A dans le programme aura automatiquement cette valeur.
De même, tout ce qui est connecté à l'output B recevra la valeur que la variable B a eue quand l'exécution de l'expression a terminé.

Les inputs et les outputs sont définis dans l'expression gate les uns à la suite des autres, séparés par des espaces.

A B C

Si vouz regardez dans les fichiers des expressions sauvegardées (c'est le format sous lequel elles sont souvent postées sur les forums), vous trouverez trois lignes au début qui commencent par un "@", ce sont les définitions pour le nom de l'expression (@N), ses inputs (@I), et ses outputs (@O).

Vous pouvez aussi assigner des variables qui ne sont ni des inputs ou des outputs, elles sont appelées dans ce cas "variables de session", et sont gardées en mémoire entre chaque exécution. Par exemple, si vous assignez une valeur à "C", à la prochaine exécution, la variable "C" aura toujours cette valeur. Ce qui vous permet de faire des choses encore plus complexes.

# Incorrect : Une fois que Speed aura atteint 50, Break sera toujours égal à 1
Speed >= 50 -> Break = 1;
# Correct : Break retournera à 0 dès que Speed sera inférieur à 50
Break = 0, Speed >= 50 -> Break = 1;
# Encore mieux : Même chose, mais plus court
Break = (Speed >= 50 ? 1 : 0)

Vous pouvez aussi utiliser les variables de session comme des constantes qui ne changeront jamais de valeur, ce qui peut être pratique pour un nombre qui réapparait plusieurs fois dans votre expression et que vous devez ajuster pour obtenir la valeur voulue. Au lieu de modifier ce nombre partout où il apparait dans l'expression, vous pouvez le remplacer par une variable, et régler la valeur de cette variable en haut de l'expression. Comme ça, vous n'avez qu'une valeur à modifier dans l'expression. Par exemple :

Z1 = Z + 500
Z2 = Z/2 + 500
Z3 = Z/4 + 500
Z4 = Z/8 + 500

Admettons que vous vous êtes trompé, et que vous voulez remplacer 500 par 400. Dans ce cas, ce n'est pas pratique parce que vous devez retaper 400 4 fois (et encore, ça peut être pire dans les expressions plus longues). Il aurait été plus malin de faire:

HAUTEUR = 500
Z1 = Z + HAUTEUR
Z2 = Z/2 + HAUTEUR
Z3 = Z/4 + HAUTEUR
Z4 = Z/8 + HAUTEUR

Dans quel cas, vous n'avez plus qu'à modifier le début.

Fonctions

Des fonctions sont mises à disposition pour effectuer des calculs plus compliqués que des additions ou des multiplications. Tous les appels de fonctions se font en écrivant le nom de la fonction en minuscules, une parenthèse ouvrante, les arguments séparés par des virgules, et enfin une parenthèse fermante pour terminer. "atan2(4, 5.2)" donnera la tangente inverse de 4 divisé par 5.2 (voir la liste des fonctions en fin de documentation)

ndt : Ca m'étonne que rien ne le dise dans cette documentation, mais vous devez savoir que les espaces placés entre les noms, les opérateurs, etc... servent à rendre la lecture de l'expression plus claire. Vous pouvez tout à fait écrire "atan2(4,5.2)" dans votre expression, ou même "atan2 ( 4 , 5.2 )", ou encore "atan2(        4      ,    5.2        )", cela reviendra exactement au même. Mettez donc vos espaces là où cela peut rendre votre expression plus lisible.

Attention: Un appel à une fonction qui n'existe pas ne donnera pas d'erreur, mais le résultat sera toujours -1.

# La valeur absolue de -2 est 2
abs(-2)
# L'arrondi par défaut de 3.42 est 3
floor(3.42)
# 67 degrés = 1.169... radians
rad(67)

Opérateurs arithmétiques

Les opérateurs arithmétiques sont la base de toute expression, et ne devraient pas être difficiles à comprendre (à moins que vous soyez particulièrement con et que vous ayez oublié ce que vous avez appris en maternelle). Voici les opérateurs utilisables dans l'Expression gate :

N + N : addition
N - N : soustraction
N * N : multiplication
N / N : division
N % N : modulo (reste d'une division)
N ^ N :puissance
-N    : opposé

Tous les opérateurs sont récursifs à gauche, c'est à dire que "1 / 2 / 3" signifie "(1 / 2) / 3", et non "1 / (2 / 3)". Si vous ne vous en souvenez pas, le mieux est d'utiliser toujours des parenthèses dans ce cas.

# 2 + 2 = 4
2 + 2
# 4 * 2 = 8
4 * 2
# -4 / -2 = 2
-4 / -2
# (4 + 2)² = 36
(4 + 2) ^ 2

Opérateurs d'assignement

Les opérateurs d'assignement permettent d'assigner une valeur à une variable, en théorie, il n'existe qu'un seul opérateur, l'opérateur d'assignement "=".

Cependant, il arrive que l'on veuille faire des assignements où vous ne donnez pas une nouvelle valeur indépendante à une variable, mais une valeur qui dépend de la valeur actuelle de cette variable. Par exemple, "A += 5" sera l'équivalent de "A = A + 5". Il y a un tel opérateur d'assignement correspondant à chaque opérateur arithmétique.

V = N  : assignement
V += N : assignement avec addition
V -= N : assignement avec soustraction
V *= N : assignement avec multiplication
V /= N : assignement avec division
V %= N : assignement avec modulo
V ^= N : assignement avec puissance
# Assigne la valeur de A à Out
Out = A
# Assign la valeur de A + 2 à Out
Out = A + 2

Un assignement peut aussi donner un résultat. Par exemple, "A = 5" est égal à 5.

# Assigne la valeur de C + D à B, puis assigne la valeur de A + B à Out, ce qui est équivalent à A + C + D
Out = A + (B = C + D)

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés pour donner pour résultat 0 (non) ou 1 (oui), répondant à des questions comme "Est que ce X est plus petit que 42 ?", 'Est ce que Y est égal à 20 ?", ce qui permet de mettre en place des conditions pour faire une certaine action uniquement lorsque certaines valeurs entrent dans ces conditions. (voir la section suivante pour combiner plusieurs conditions)

N == N : égal
N != N : différent
N > N  :plus grand
N < N  :plus petit
N >= N :plus grand ou égal
N <= N :plus petit ou égal

Si la relation est vraie, le résultat est 1, sinon 0.

# Est ce que 2 est égal à 2 ? Oui -> résultat : 1
2 == 2
# Est ce que 2 est plus petit que 1 ? Non -> résultat : 0
2 < 1
# Est ce que 3 est différent de 3 ? Non -> résultat : 0
3 != 3

Opérateurs logiques

Les opérateurs logiques seuls ne sont pas très utiles, mais lorsqu'ils sont utilisés avec des opérateurs de comparaison, ils deviennent très utiles pour créer des conditions, par exemple vérifier si une valeur est comprise entre deux limites. De la même manière que pour les comparaisons, les opérations logiques ont pour résultat 0 (faux) ou 1 (vrai).

B & B : ET logique, si tout est vrai, alors le résultat est 1, sinon le résultat est 0
B | B : OU logique, si au moins un est vrai, alors le résultat est 1, sinon le résultat est 0
!B    : NON logique, si vrai, alors le résultat est 0, si faux, alors le résultat est 1

Dans l'expression gate, "faux" est égal à 0, et n'importe quelle autre valeur est considéré comme "vrai".

# 1 ET 0 = 0
1 & 0
# 1 OU 0 = 1
1 | 0
# 3 > 5 OU 4 < 2 = 0
3 > 5 | 4 < 2

Expressions conditionnelles

Une expression conditionnelle exécutera une expression parmi deux, dépendant de la valeur résultant de la condition, ce qui permet de faire des calculs dans certaines circonstances, et d'autres calculs le reste du temps.

(B ? T : F) : Si B est vrai, alors calculer T, sinon calculer F

Attention: N'oubliez pas d'entourer votre expression conditionnelle par des parenthèses, ou vous aurez généralement une erreur.

# Ces deux expressions sont équivalentes
Out = (A < 0 ? 1 : 0)
Out = (A < 0)
# Si A > 32 alors assigner 32 à Out, sinon assigner la valeur de A à Out
Out = (A > 32 ? 32 : A)
# Si Select est vrai alors retourne A + B, sinon retourne B + C, puis assigne la valeur du résultat + 2 à Out
"Out = 2 + (Select ? A + B : B + C)

Déclarations conditionnelles

Bien que les expressions conditionnelles soient très pratiques, il est souvent utile de pouvoir contrôler l'exécution du code à un autre niveau, de telle sorte que seuls certains bouts de code seront traités à certains moments. Ou de stopper l'exécution si une condition n'est pas satisfaite.

B -> E;           : Si B est vrai, alors exécuter E
B -> E1, E2, ...; : Si B est vrai, alors exécuter E1, puis E2, ...
B -> E1 E2 ...;   : Même chose

Dans une déclaration conditionnelle, vous pouvez aussi écrire "end", ce qui va immédiatement stopper l'exécution de l'expression gate, qui n'ira pas plus loin.

B -> end;         : Si B est vrai alors stopper l'exécution
B -> E1, E2, ..., end; : Si B est vrai, alors exécuter E1, puis E2, ..., puis stopper l'exécution
B -> E1 E2 ... end;   : Même chose

Attention: N'oubliez pas le point-virgule à la fin de chaque déclaration conditionnelle.

# Si Reset est vrai, alors remettre Clock à zéro. Incrémente toujours Clock de 1.
Reset -> Clock = 0; Clock += 1
# Si Active est vrai et que Angle est plus grand que 0, alors assigner 1 à ThrustUp, et 0 à ThrustDown
Active & Angle > 0 -> ThrustUp = 1, ThrustDown = 0;
# Si Tick est vrai et qu'il n'a pas changé (voir section Syntaxes spéciales) alors stopper l'éxécution, sinon incrémenter Count
!(~Tick & Tick) -> end; Count += 1

Suites d'expressions

Comme vous avez pu le voir dans les expressions conditionnelles, on peut exécuter des expressions les unes à la suite des autres en les séparant par un espace ou une virgule. Ce qui s'applique aussi hors des expressions conditionnelles.

E1 E2 ...   : On exécute E1, puis E2, etc...
E1, E2, ... : Même chose
# On assigne 1 à A, puis 2 à B
A = 1, B = 2

Paquets

Bien qu'il est aussi possible d'envoyer et de recevoir des paquets (groupes de valeurs) en utilisant le Duplexer gate, le système de paquets de l'expression gate n'est pas le même, il n'est donc pas compatible avec les duplexers.

Pour envoyer un paquet (plusieurs valeurs sur un seul output), il suffit d'ajouter un output (par exemple, Packet) dans le gate qui va envoyer le paquet, et d'ajouter une ligne comme:

Packet = send(A, B, C)

pour envoyer un paquet contenant les valeurs A, B et C. Notez que vous pouvez mettre autant de valeurs que vous voulez dans un paquet.


Pour recevoir un paquet, il suffit d'ajouter un input (Packet) dans le gate de réception, et d'ajouter une ligne comme:

B = recv(Packet, 2)

pour assigner la 2ème valeur du paquet à B. Si vous demandez une valeur qui dépasse le paquet (demander la 4ème valeur alors que le paquet n'en a que 3), le résultat sera toujours -1.

send et recv sont des fonctions comme les autres, donc rien ne vous empêche d'avoir plusieurs inputs ou outputs paquets. Les paquets se comportent comme les autres valeurs, vous ne pouvez donc pas envoyer plusieurs paquets sur le même output, et les paquets ne sont pas conservés en mémoire. La gestion des paquets est une fonctionnalité encore expérimentale, donc il peut avoir des problèmes de lecture quand vous envoyez et recevez plusieurs paquets à la fois.

Les paquets peuvent être utilisés pour simplifier la communication entre plusieurs systèmes, ainsi, ces systèmes peuvent être facilement connectés et déconnectés (pas besoin d'attacher une dizaine de câbles à chaque fois).

# Multiplexeur:(inputs: A B C D, output: Packet)
Packet = send(A, B, C, D)
# Démultiplexeur (input: Packet, outputs: A B C D)
A = recv(Packet, 1)
B = recv(Packet, 2)
C = recv(Packet, 3)
D = recv(Packet, 4)

Personnellement, je trouve pas ça très utile, donc si vous avez rien compris, laissez tomber.


Horloge interne

Avant la création de l'expression gate, les circuits capables d'effectuer des actions périodiquement ou avec un certain délai n'étaient possibles qu'en utilisant une horloge externe (timer, pulser, etc...). A présent, il est non seulement possible d'enlever tous ces composants externes, mais aussi de créer des systèmes beaucoup plus complexes, et faciles à mettre en place.

Au lieu de donner une fréquence, il suffit de dire à l'expression gate quand le prochain signal d'horloge doit se produire en utilisant la fonction "schedule". Par exemple, "schedule(50)" produira un signal d'horloge 50 millisecondes après le moment où il a été exécuté.
Pour produire des signaux d'horloge périodiquement, la fonction "interval" doit être utilisée, et placée en haut de l'expression.

Il est évidemment possible d'utiliser "schedule" et "interval" dans une expression conditionnelle. Par exemple "Button -> schedule(1000);" produira un signal d'horloge 1 seconde après que vous avez appuyé sur le bouton. Le plus petit délai utilisable est 20 millisecondes. Toute valeur au dessous de 20 sera remontée automatiquement à 20, et 0 annulera les signaux d'horloges mis en délai.

Pour détecter si l'exécution de l'expression gate est due à un signal d'horloge, il suffit d'utiliser la fonction clk(), qui sera égale à 1 lorsqu'un signal d'horloge s'est produit, et 0 le reste du temps.


Voici deux exemples simples de l'application de "schedule" et "interval"

# Bombe à retardement
Button -> schedule(5000);
clk() -> Explode = 1;

Ici, la bombe explosera 5 secondes après que vous avez appuyé sur le bouton.

# Comptage de secondes
interval(1000)
clk() -> Seconds += 1;

Ici, l'expression gate comptera tout simplement le nombre de secondes passées depuis que vous l'avez créé.


Syntaxes spéciales

Pour des expressions plus complexes, il existe deux opérateurs spéciaux à votre disposition:

~A : Egal à 1 si la valeur A a changé depuis la dernière exécution
$A : Egal au delta de A, c'est à dire la différence entre la valeur courante de A, et la valeur de A à l'exécution précédence.

Alors, pourquoi utiliser "~" ? Comme vous le savez sûrement déjà, l'expression gate est exécuté à chaque fois qu'un de ses inputs change (ou qu'un signal d'horloge se produit si vous avez utilisé schedule ou interval). Ce qui peut produire des effets gênants, au niveau d'un bouton par exemple. Si votre expression gate a plusieurs inputs, dont un correspond à un bouton, et que vous appuyez sur ce bouton alors que les autres inputs changent régulièrement, l'expression conditionnelle correspondant au bouton sera exécutée plusieurs fois (vu que vous maintenez le bouton quand même un cours temps avant de le relâcher). Ce qui n'est pas voulu. Donc...

# Sans "~"
Button -> Boom = 1;

# Avec "~"
~Button & Button -> Boom = 1;

Pas de risque que votre explosif explose plusieurs fois quand vous appuyez sur le bouton.


Le delta permet de calculer des variations, et est donc très utile dans beaucoup de cas, comme pour calculer une vitesse ou une accélération à partir de la position d'un objet. Le principe du delta est extrêmement simple. Si A est égal à 5 à un moment, et qu'il passe subitement à 8 à l'exécution suivante, le delta de A sera 8-5=3 à l'exécution suivante.

Infos complémentaires

Attention, si vous écrivez votre expression hors du jeu (en utilisant le bloc-notes par exemple), veillez à ce que la longueur de vos lignes ne soit pas supérieure à 92 caractères, sinon toute l'expression peut ne pas se charger correctement, ou causer des erreurs. Si vous ne pouvez pas spawner votre expression gate, mais que la validation ne détecte pourtant aucune erreur, c'en est probablement la cause.


Pour écrire un commentaire dans votre expression, placez un dièse (#) au début de votre ligne.

# Ceci est un commentaire

Un retour à la ligne équivaut à un espace. Par conséquent, vous pouvez répartir des bouts d'expressions sur plusieurs lignes sans problèmes:

A = 4 +
3 / 2

# équivaut à

A = 4 + 3 / 2

N'hésitez pas à utiliser plusieurs expression gates au lieu d'un seul, surtout si votre construction effectue plusieurs tâches différentes à la fois.


Exemples pour débuter

Les exemples suivants utilisent le format sous lequel les expressions sont sauvegardées (décrite dans la section Inputs et Outputs). "I@A B C" signifie que l'expression doit avoir pour inputs "A B C".


Hello World

Un exemple très très simple qui prend une valeur en entrée, et sort son carré, sa racine carrée, et détermine si cette valeur est positive ou pas.

N@Hello World
I@Valeur
O@Valeur Carre RacineCarree Positif
Carre = Valeur * Valeur
RacineCarree = sqrt(Valeur)
Positif = Valeur >= 0

Chronomètre

Un simple chronomètre. (minutes:secondes:dixièmes de secondes)
Reliez un bouton (cochez Toggle) à On, et un autre bouton (décochez Toggle) à Reset, et éventuellement des screens ou tout composant d'affichage à Min, Sec et DSec, et c'est bon.

N@Chronomètre
I@On Reset
O@Min Sec DSec
!On -> end;
~Reset & Reset -> Min = 0,Sec = 0,DSec = 0;
interval(100)
clk()->DSec += 1;
DSec==10->DSec = 0,Sec += 1;
Sec==60->Sec = 0,Min += 1;

Référence des fonctions

Commun

abs(n)         : Valeur absolue
clamp(n, l, u) : La valeur n est contrainte entre l (borne inférieure) et u (borne supérieure)
frac(n)        : Partie décimale
int(n)         : Partie entière

Mathématiques

e()            : Constante d'Euler (e=2.71828183)
exp(n)         : Exponentielle de n (e exposant n)
ln(n)          : Logarithme népérien
log(n, k)      : Logarithme de base k
log2(n)        : Logarithme de base 2
log10(n)       : Logarithme décimal (base 10)

mod(n,c)       : Modulo (reste de la division de n par c)
sgn(n)         : Signe (n négatif -> -1 ; n positif -> 1 ; n=0 -> 0)

cbrt(n)        : Racine cubique
sqrt(n)        : Racine carrée
root(n, k)     : Racine n-ième

Arrondi

ceil(n)        : Arrondi par excès
ceil(n, d)     : Arrondi par excès à d décimales
floor(n)       : Arrondi par défaut
floor(n, d)    : Arrondi par défaut à d décimales
round(n)       : Arrondi
round(n, d)    : Arrondi à d décimales

Sélection

max(n, ...)    : La plus grande des valeurs données
min(n, ...)    : La plus petite de valeurs données
avg(n, ...)    : La moyenne des valeurs données
sel(i, n, ...) : La i-ième valeur donnée

Arbitraire

curtime()      : Temps écoulé depuis le lancement du serveur

random()       : Valeur aléatoire entre 0 et 1
random(l, u)   : Valeur aléatoire entre l et u

Trigonométrie
Les fonctions suivantes prennent un angle en degrés. Pour donner un angle en radians, ajoutez un "r" à la fin du nom de chaque fonction ("cosr", "tanr", "angnormr", ...)

acos(x)        : Arc cosinus (cosinus inverse)
asin(x)        : Arc sinus (sinus inverse)
atan(x)        : Arc tangente (tangente inverse)
atan(y, x)     : Arc tangente de y/x
atan2(y, x)    : Même chose que atan
cos(d)         : Cosinus
cosh(d)        : Cosinus hyperbolique
sin(d)         : Sinus
sinh(d)        : Sinus hyperbolique
tan(d)         : Tangente
tanh(d)        : Tangente hyperbolique

angnorm(d)     : Normalise un angle tel que -180 <= d < 180

deg(n)         : Convertit des radians en degrés
rad(n)         : Convertit des degrés en radians
pi()           : Pi (3.14159265)

Vecteur
Très expérimental, réservé uniquement aux utilisateurs chevronnés. Normalement, X est l'axe avant/arrière, Y est l'axe droite/gauche, et Z est l'axe haut/bas.

vector(x, y, z)       : Crée un vecteur (x,y,z)

vecx(v)               : Composante X du vecteur
vecy(v)               : Composante Y du vecteur
vecz(v)               : Composante Z du vecteur

vecpitch(v)           : Inclinaison verticale du vecteur (tangage)
vecyaw(v)             : Direction horizontale du vecteur (cap)

veclength(v)          : Norme du vecteur (longueur)
vecnormalize(v)       : Normalise le vecteur (conserve la direction et le sens, mais ramène la longueur à 1)

vecadd(v1, v2)        : Ajoute deux vecteurs
vecsub(v1, v2)        : Soustrait deux vecteur
vecmul(v1, v2)        : Multiplie deux vecteurs

vecsmul(v1, n)        : Multiplie un vecteur par un scalaire
vecsdiv(v1, n)        : Divise un vecteur par un scalaire

vecdot(v1, v2)        : Produit scalaire de deux vecteurs
veccross(v1, v2)      : Produit vectoriel de deux vecteurs
vecdistance(v1, v2)   : Distance entre deux vecteurs

vecrotate(v, p, y, r) : Rotation d'un vecteur en utilisant les trois angles de l'espace (tangage/cap/roulis, pitch/yaw/roll en anglais)

Spécial

first()        : 1 lorsque l'expression vient d'être spawnée, ou lorsqu'elle est réinitialisée, 0 le reste du temps

send(n, ...)   : Crée un paquet
recv(id, i)    : Extrait des valeurs d'un paquet

clk()          : 1 lorsque l'exécution est due à un signal d'horloge, 0 le reste du temps
interval(ms)   : Fonction pour générer des signaux d'horloge périodiquement
schedule(ms)   : Fonction pour générer un signal d'horloge après un certain délai

concommand(c)  : Exécute une commande console (la commande est toujours exécutée sur le propriétaire de l'expression gate, pas comme le Command Box)

Je me suis permis de changer le second exemple dans les "Exemples pour débuter" parce que celui donné sur Wiremod est dépassé, vu qu'il utilise un pulser et non le timer interne.

Dernière modification par _Kilburn (19/01/2008 15h44)

Hors ligne

#2 20/01/2008 16h06

GannoN
SEIZED BY DARK ARMY @D4rkArmy
Lieu : France -> Nord
Inscription : 01/09/2006
Messages : 11

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

Super sa va baucoup m'aidez . MERCI wink

Hors ligne

#3 04/02/2008 15h58

1nxe
SEIZED BY DARK ARMY @D4rkArmy
Inscription : 05/10/2007
Messages : 5

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

Merci pour cette traduction que je vais relire et relire ^^

Hors ligne

#4 04/02/2008 16h21

DarK_Avenger
SEIZED BY DARK ARMY @D4rkArmy
Inscription : 25/10/2007
Messages : 130

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

merci kilburn d'avoir pris le temps de tout traduire. ca va beaucoup nous aider.

Hors ligne

#5 28/03/2008 00h23

MathieuG89
Staff Serveur
Inscription : 03/03/2008
Messages : 186

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

Merci beaucoup _Kilburn pour cette traduction, je débute avec le expression gate et cette traduction est grandement appréciée. J'ai déjà franchis grâce à toi les tout première étape de mon ambitieux projet.

Hors ligne

#6 24/10/2008 19h33

-XI-
SEIZED BY DARK ARMY @D4rkArmy
Lieu : Suisse
Inscription : 20/06/2008
Messages : 121
Site Web

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

Quelqu'un sait comment faire pour mettre deux intervals différents dans une seule expression?

Hors ligne

#7 03/11/2008 20h47

killman42
SEIZED BY DARK ARMY @D4rkArmy
Inscription : 16/09/2008
Messages : 9

Re : [WireMod] Traduction de la doc officielle de l'Expression Gate

Bonjours
Excusez moi, mais avec un expression chip, peut t'on crée un programme simple genre grafcet avec des etapes et des transition ?
Merci

Hors ligne

Pied de page des forums