Tutoriels/Mécanismes électroniques avancés

De Minecraft Wiki
Aller à : navigation, rechercher
IcôneMCRedstoneSim.png
Cet article présente des diagrammes au format MCRedstoneSim pour sa clarté et sa concision.
Certains des circuits peuvent être d'une hauteur supérieure à deux blocs, ce qui est représenté par des couches, soit animées dans une GIF, soit présentées côte à côte. Une légende complète peut être trouvée sur la page des schémas redstone.

Les mécanismes électroniques avancés sont des mécanismes qui ont des circuits de redstone bien plus complexes. Si vous recherchez des mécanismes plus simples, allez voir dans les mécanismes électroniques, les pièges câblés, ou plus simplement la partie sur la redstone.

Divers[modifier | modifier le wikicode]

Verrou à combinaison sans ordre[modifier | modifier le wikicode]

Le système est assez simple à comprendre, il s'agit d'une porte qui s'ouvre seulement avec une certaine combinaison de boutons ou de leviers sur on. Il n'est pas nécessaire de faire la combinaison dans l'ordre, la seule chose qui compte est de l'activation des bons leviers. C'est un système qui, bien que plus compliqué à mettre en place, reste simple à réaliser, et est souvent favorisé par les utilisateurs en multijoueur pour éviter le vol de coffres (nécessite que le serveur soit occupé d'un anti-grieff, sinon il suffit de casser le mur pour passer). Voici les différentes manières possibles de créer ce verrou.

(Note : il est nécessaire de connaître et de comprendre les portes logiques).

Circuit avec Verrou RS NON-OU[modifier | modifier le wikicode]

RSNORLock.jpg

Avant tout, il faut savoir que ce circuit demande beaucoup de place comparé aux autres versions du verrou à combinaison sans ordre. Il est donc préféré aux autres circuits lorsqu'il faut appuyer sur les interrupteurs à des endroits assez éloignés (par exemple, pour un donjon, avec le passage d'une énigme). Il est aussi important de noter que l'utilisation de bouton est fortement conseillée en dépit du levier, car celui-ci devrait être abaissé après chaque tentative, sinon le reset du circuit ne fonctionnerait pas.

Pour commencer, il faut connecter chaque bouton à l'entrée S d'un verrou RS NON-OU. En suite, vous devez relier les sorties Q en ayant choisi le code à entrer. Dans notre exemple, les boutons A et B doivent être enfoncés, tandis que le bouton C ne doit pas être touché. Il faut donc relier les sorties Q, des RS NON-OU des boutons A et B, à l'aide d'une porte ET. De ce fait, pour que la sortie de cette porte ET soit activée, il faudra que les boutons A et B soient activés. Pour éviter que le verrou s'ouvre lorsque l'on appuis sur les 3 boutons, il faut rajouter une porte ET. Cette porte ET doit relier la sortie de la porte ET précédente, ainsi que la sortie Q du verrou RS NON-OU du bouton C. Cependant, il faut inverser cette sortie, pour que lors de l'appui sur le bouton C, cela désactive une des deux entrées de la porte ET (rendant impossible l'ouverture de la porte). Lorsque l'on se trompe dans le code, il faut pouvoir remettre à zéro le système, afin de tenter une nouvelle fois d'entrer le code. Pour cela, il suffit juste de relier les entrées R (qui correspondent au reset de chaque RS NON-OU) entre elles, puis de mettre un bouton pour pouvoir contrôler la remise à zéro.

Il est possible de supprimer le bouton reset à l'aide d'un système de reset automatique, permettant ainsi d'éviter des allez-et-retours vite embêtants.

Circuit avec porte ET[modifier | modifier le wikicode]

ANDLock.jpg

Contrairement au circuit précédent, ce mécanisme prend moins de place : il est assez concentré, ce qui permet de le cacher facilement. Cependant, il a lui aussi des défauts. Tout d'abords, il lui faut obligatoirement des leviers pour sélectionner le code. En effet, le circuit ne comporte aucune mémoire (pas même une RS NON-OU), donc il serait impossible pour le joueur d'entrer le code puis de passer la porte avec des boutons. De plus, si le code est mauvais, vous devrez alors abaisser tout les leviers, puis recommencer.

Dans notre exemple, une validation est rajoutée, ce qui permet d'éviter que le joueur trouve la combinaison, en abaissant les leviers au hasard. Le joueur doit donc après chaque tentative utiliser le levier de validation pour confirmer le code. Cet exemple utilise quatre leviers ; le bon code est A et C baissés et B et D levés. Pour commencer, il faut relier chaque levier par une ou plusieurs portes ET. Dans notre exemple, les entrées A et B sont reliées à l'aide d'une porte ET à deux entrées ainsi que les portes C et D. Pour mémoriser le code valide sans RS NON-OU, il faut inverser les entrée A et C, car elles ne doivent pas être activées pour que le code soit valide. En étant inversées, ces deux entrées activeront une des conditions (lorsque le levier est baissé) de la porte ET tandis que la deuxième est activée en levant le levier. En suite, il faut relier les sorties des portes ET entre elles, à l'aide d'une nouvelle porte ET. Si les deux sorties (alors devenues entrées) sont activées, alors la sortie de cette dernière porte ET s'active. Pour rajouter la validation, il suffit juste d'ajouter une dernière porte ET, reliant la sortie du circuit ainsi que le levier de validation. De ce fait, il faudra que le code soit valide ET que le levier soit activé, pour que la porte s'ouvre.

Circuit avec porte OU[modifier | modifier le wikicode]

ORLock.jpg

Ce circuit ressemble au précédent, sauf qu'il est beaucoup plus compact, grâce à l'utilisation des portes OU. Cela rend donc ce circuit très utile lors de la construction d'une mémoire (RAM) plus importante qu'un simple verrou RS NON-OU. Cependant, tout comme la version avec des portes ET, l'utilisation de leviers est obligatoire, pour les mêmes raisons. De plus vous pouvez rajouter très facilement des leviers pour compliquer votre code, cela ne prendra pas beaucoup plus de place, et le système reste le même (vous n'êtes pas obligé de rajouter des portes supplémentaires contrairement à la version avec les portes ET).

Le système n'est là non plus, pas très compliqué à comprendre, mais du fait de sa taille compacte, il n'est pas forcément clair au début. Dans notre exemple, il y a 5 leviers et le code bon est A, B et D levés et C et E baissés. Pour commencer, il faut relier toutes les entrées sur des portes OU (dans notre exemple, les portes OU sont compactes). Une fois reliées, les entrées seront toutes désactivées lorsque les leviers sont abaissés. Pour choisir la combinaison, il suffit de mettre des inverseurs aux entrées concernées. De ce fait, si vous levez les leviers avec les inverseurs (tous ces leviers), le circuit se désactivera. En effet, le fait d'avoir mis des inverseurs (et donc des torches de redstone), alimente en permanence le circuit. En résumé, si vous laissez les leviers baissés, le circuit s'allume, si vous levez les leviers du bon code, alors le circuit s’éteint. Comme la sortie du circuit est éteinte lorsque le bon code est entré, alors il faut rajouter un inverseur à cette sortie pour qu'elle s'allume lorsque le code entré est le bon.

Verrou à combinaison avec ordre[modifier | modifier le wikicode]

Une porte qui s'ouvre quand des boutons sont pressés dans un certain ordre.

(Note: Une compréhension modérée des portes logiques est utile pour ce dispositif.)

Placez une série de boutons, et n'en connectez qu'un seul à un verrou RS NON-OU (RS NOR latch). Connectez ensuite le verrou RS NON-OU et le second bouton à une porte ET, qui alimente un autre verrou RS NON-OU. Recommencez jusqu'à ce que vous ayez raccordé tous les boutons ou que vous soyez satisfait de la serrure. Connectez le verrou RS NON-OU final à une porte ET séparée avec un signal depuis un bouton d'entrée.


Alimentez ceci à la sortie de l RSNOR latch, puis connectez n'importe lequel des boutons de gauche au bouton d'entrée et envoyez des signaux de reset à toutes les RSNOR latchs. Une plaque de pression posée à côté de la porte peut faire office de reset. Ce type de verrou doit respecter des règles de sécurité. Tous les boutons ne peuvent faire partie du code ou il n'y aurait alors plus rien chargé d'effectuer le reset du système.

Pour un verrou ayant une combinaison de n'importe quelle taille utilisant tous les boutons, et qui assure tout de même le reset du système en cas de mauvaise combinaison, il vous faudra utiliser une autre technique. Pour construire ceci, respectez les étapes suivantes : - branchez plusieurs boutons (n'importe quel nombre, 4 étant le plus pratique en terme de raccord) à une série de répéteurs adjacents. - placez un bloc conducteur en face de chaque répéteur et répétez le schéma jusqu'à ce que le nombre de rangées correspondent aux nombres de boutons de la pancarte. - placez sur chaque rangée (4 dans notre exemple) des torches correspondants au boutons incorrects. Ainsi, chaque rangée aura un bloc de libre correspondant au bouton à activer. Vous pouvez donc définir votre combinaison de boutons. - Placez une ligne de redstone en dessous de chaque rangée de bloc, chaque ligne conduisant à une RSNOR latch. - recouvrez les torches avec une nouvelle rangée de bloc recouverte de redstone. Reliez chaque rangée de redstone au reset de la RSNOR latch associée avec un délai suffisant (un répéteur au maximum).

La puissance sera alimentée par les boutons à travers les rangées de répéteurs et de blocs pour autant de lignes qu'il y a de chiffres dans le numéro PIN. Connectez la redstone du bon bouton à l'autre moitié de la porte ET provenant du premier RS ​​NOR Latch. Seulement si les deux conditions sont rencontrées, que le premier bouton a été poussé correctement, en réglant le premier RS ​​NOR Latch, et que le second bouton est poussé correctement, la porte ET enverra un signal pour régler le second RS NOR Latch. Encore une fois, connectez une ligne de réinitialisation des torches du bouton incorrect à la réinitialisation du deuxième RS NOR Latch. REMARQUE: Retardez les signaux de réinitialisation par un répéteur complet pour laisser le temps au prochain RS NOR Latch d'être réglé avant la réinitialisation. Continuez à construire le tableau de la même manière jusqu'à ce que vous atteigniez le nombre désiré de chiffres. En fonctionnement, lorsqu'un bouton est touché, chaque RS NOR Latch vérifie (via la porte ET) pour voir si le précédent RS NOR Latch est réglé, et le bouton correct pour ce RS NOR Latch a été poussé. Ce n'est que lorsque les touches correctes sont pressées dans l'ordre, que le signal progressera à travers les verrous RS NOR conditionnels jusqu'à la fin. Connectez la sortie du dernier RS ​​NOR Latch à une porte et fixez une ligne à une plaque de pression à l'intérieur de la porte pour réinitialiser le dernier RS ​​NOR Latch. Voir la démonstration vidéo ci-dessous.

Binaire à Octal[modifier | modifier le wikicode]

3Bit Binary to Octal gates.

Cette série de portes permet de convertir une entrée binaire de 3 bits en une sortie en octal allant de 0 à 7. Ces portes sont très utiles, car compactes (la plus grande a des dimensions de 5x5x3).

Elles peuvent être liées à un ensemble de sources d'entrée, mais il est recommandé de placer un répéteur avant chaque entrée dans le circuit afin de les isoler d'une interaction non désirée avec d'autres circuits.

Nombre 0 1 2 3 4 5 6 7
Dimensions 5x3x2 5x3x3 5x5x3 5x5x3 5X3X3 5x4x3 5x5x3 5x5x3
Torches 1 2 2 3 2 3 3 4
Câbles 7 7 12 10 7 7 10 10

Binaire à Décimal/HexaDécimal[modifier | modifier le wikicode]

4Bit Binary to Decimal/HexaDecimal gates.

Une série de portes qui convertissent une entrée binaire 4 bits des entrées en une sortie décimale ou hexadécimale de 0-9 (si vous utilisez Decimal) ou 0-F (si vous utilisez HexaDecimal). Utile à bien des égards car ils sont compacts 3x5x2 au plus grand.

Ceux-ci peuvent être reliés en série à partir d'une source d'entrée, mais il est recommandé de placer un onduleur avant chaque entrée dans le circuit pour les empêcher d'interagir avec les autres circuits car certains conduisent une combinaison de courant élevé et faible.

Suivant l'image, la deuxième entrée est le deuxième levier sur la droite. La deuxième entrée est la première dans le deuxième levier sur la droite. Le troisième est le premier levier sur la gauche. Le quatrième et dernier levier est le deuxième à gauche.

Nombres 0 1 2 3 4 5 5 7 8 9 A B C D E F
Taill 3x3x2 3x4x2 3x4x2 3x4x2 3x4x2 3x5x2 3x5x2 3x5x2 3x4x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2 3x5x2
Torches 1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5
Redstone 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2

HexaDecimal à Binaire[modifier | modifier le wikicode]

Vous pouvez transformer un signal hexadécimal en signal 4-bit binaire. Ici vous n'avez pas besoin de portes, exceptées les "OU" de séparation. Donc vous devez mettre l'entrée [trough] un bloc.A partir de là, on met des lignes à travers les lignes de bits. Et séparez-les de l'entrée par la porte (non-non) ou une diode. Le point le plus approprié à séparer est directement après le point où vous différenciez l'entrée par les lignes de sortie. Vous devez séparer ces lignes, afin que l'illustration des bits soit correcte

Nombre 0 1 2 3 4 5 6 7 8 9 A B C D E F
4-bit 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
3-bit 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
2-bit 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1-bit 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Vous avez maintenant le signal converti en 4 bits dans les quatre lignes. Pour obtenir un Octal2Binary-MUXer, ignorez simplement les entrées, où la ligne de 4 bits est 1.

Exemple[modifier | modifier le wikicode]

Logic for a 3-digit key log, with digits 0-9. It's order-sensitive

L'exemple de droite utilise des OR (> = 1), des XNOR (=), des verrous RS-NOR (SR) et quelques retards (dt *). Pour les XNOR je préférerais le C-design.

L'exemple sur la droite utilise une conception à 4 bits, de sorte que vous pouvez gérer une clé hexa-décimale. Vous pouvez donc utiliser 15 chiffres différents, [1, F] ou [0, E]. Vous ne pouvez utiliser que 15, car l'état (0) h == (0000) 2 n'active pas le système. Si vous voulez gérer 16 états, vous éditez la logique, pour interagir avec une entrée de 5 bits, où le 5ème bit représente l'état (0) h.

Dans ce qui suit, nous utiliserons (0) h: = (1111) 2. Et pour [1,9] le MUX-table sur. La clé utilise donc des chiffres décimaux. Par conséquent nous devons mux les boutons utilisés aux données binaires. Voici les deux premières colonnes. Le premier représente le chiffre d'entrée en (hexa) décimal, le second représente le chiffre d'entrée en code binaire. Ici vous pouvez ajouter aussi des boutons pour [A, E], mais je les ai désavoués préférant un meilleur arrangement. Le / b1 \ -box sort le premier bit, le / b2 \ -box le second, et ainsi de suite.

Maintenant vous voyez Key [i] avec i = 1..3, ici vous définissez la clé que vous voulez utiliser. La première sortie d'entre eux est le 1-bit, le second le 2-bit et ainsi de suite. Vous pouvez définir votre clé ici avec des leviers en cryptage binaire. Utilisez ici la table MUX sur, et pour (0) h: = (1111) 2. Si nous entrons le premier chiffre, nous devons comparer les bits par paires (b1 = b1, b2 = b2, b3 = b3, b4 = b4). Si chaque comparaison est correcte, nous établissons l'état, que le premier chiffre est correct.

Nous combinons donc (((b1 = b1 & b2 = b2) & b3 = b3) & b4 = b4) =: (b * = b *). Dans Minecraft nous devons utiliser quatre ANDs comme le côté gauche. Nous sauvegardons maintenant l'état sur le RS-loquet / A \. La comparaison fonctionne de la même manière pour Key [2] et Key [3].

Maintenant, nous devons nous assurer que l'état sera effacé si le chiffre suivant est faux. Par conséquent, nous gérons un événement key-press (- / b1 ou b2 ou b3 ou b4 \ - / dt - \ - / dt - \ -). Cherchez dans le diagramme les trois blocs près de "dt-". Ici, nous regardons, si une touche est pressée, et nous transmettons l'événement avec un léger retard. Pour réinitialiser / A \, si le deuxième chiffre est faux, nous combinons (touche enfoncée) & (pas B). Cela signifie: n'importe quelle touche est enfoncée et le deuxième chiffre de la clé est entré faux. Avec / A \ ne sera pas réinitialisé, si nous entrons le premier chiffre, / A \ devrait seulement être réinitialisé, si / A \ est déjà actif. Nous combinons donc (B * & A) =: (AB *). / AB * \ réinitialise maintenant la cellule de mémoire / A \, si le deuxième chiffre est entré faux et la première clé a déjà été entrée. Le retard majeur / dt + \ doit être utilisé, car / A \ se réinitialise si on appuie trop longtemps sur le bouton numérique. Pour éviter cet échec un petit peu, nous utilisons le delay / dt + \. Le OU après / AB * est utilisé, pour une réinitialisation manuelle, c'est-à-dire par une plaque de pression.

Maintenant, nous copions tout le circuit de réinitialisation pour Key [2]. Les seuls changements sont, que la réinitialisation manuelle vient de (pas A) et la réinitialisation automatique (mauvais chiffre après), vient de (C). La réinitialisation manuelle de A empêche B d'être activé, si le premier chiffre n'est pas entré. Donc, cette ligne s'assure que notre clé est sensible à la commande.

La question est, pourquoi nous utilisons le mineur-delay-blocks / dt- \. Visualiser / A \ est activé.

Maintenant, nous entrons un deuxième chiffre correct .Donc B sera allumé, et (pas B) est éteint. Mais alors que (pas B) est toujours activé, l'événement key-pressed-fonction fonctionne encore, donc A sera réinitialisé, mais ce ne devrait pas être le cas. Avec les blocs / dt - \ -, nous donnons à / B \ la chance d'agir, avant que l'événement key-pressed-event ne soit activé. Pour / C \ l'événement reset est seulement la ligne de réinitialisation manuelle, à partir de B. Donc, il est interdit d'être activé, avant que / B \ soit vrai. Et il sera désactivé, quand une plaque de pression se réinitialise / A \ et / B \.

avantages et inconvénients:

+ vous pouvez changer la clé de chaque chiffre, sans changer le circuit lui-même.
+ vous pouvez étendre la clé de n'importe quel nombre de chiffres, en copiant le circuit de comparaison. Dépend uniquement de la sortie précédente.
+ vous pouvez diminuer le nombre de chiffres d'un chiffre en réglant n'importe quel chiffre (sauf le dernier) sur (0000)b.
+ vous pouvez ouvrir la porte de façon permanente en réglant le dernier chiffre sur (0000)b
- la barre de réglage de la clé sera d'autant plus grande que la clé sera longue. Le réglage de la clé codée en dur est un compromis pour un circuit assez petit, lorsqu'on utilise des clés pas trop longues. Si vous souhaitez utiliser des touches très longues, vous devez également coder le paramétrage des touches par softcode. Mais sachez qu'en fait, le nombre de touches sera très faible, mais que le circuit sera beaucoup plus grand que si vous utilisez des touches codées en dur.

Ce n'est pas vraiment une arnaque : dans ce circuit, il se passe ce qui suit avec peut-être le code 311 : 3 appuyé, A activé ; 1 appuyé, B activé, C activé. Pour éviter cela, il suffit de régler un délai avec un répéteur entre (pas A) et (reset B). Ainsi, les éléments suivants ne seront pas activés avec le chiffre réel.

Si vous réglez cela, le circuit a la compétence suivante, selon la longueur de la touche. ( ||digit||| = 2n-1, possibilités : ||digit|||Longueur )

Length 1 2 3 4 5
2 bit 3 9 27 81 243
3 bit 7 49 343 2.401 16.807
4 bit 15 225 3.375 50.625 759.375
5 bit 31 961 29.791 923.521 28.629.151

Calculs[modifier | modifier le wikicode]

Par l'emploi de portes logiques, il est possible d'effectuer des calculs binaires, comme un ordinateur. Si vous utilisez les portes logiques ci-dessous, faites attention aux entrées et sorties.Vous pouvez être amenés à vous demander pourquoi il y a tant de signaux inversés au lieu de signaux "classiques". Les additionneurs ci-dessous utilisent des portes XNOR plutôt que des portes XOR car elles sont plus compactes. En résultat, les portes IMPLIQUE doivent être utilisées au lieu d'une porte ET, ce qui le rend aussi plus compact. Par conséquent, il faudra employer une inversion du signal pour créer l'additionneur le plus compact. Ces additionneurs sont trop complexes pour être lus sur un schéma de 2 étages par carré, c'est pourquoi chaque étage a été dessiné séparément pour faciliter le processus de construction.

Half Adder[modifier | modifier le wikicode]

Half Adder

Gates: XNOR, IMPLIES

Torches: 12

Redstone: 7

Blocks: 19

Size: 5X4X4

Cet additionneur prendra 2 bits et les ajoutera ensemble. Le bit résultant sera la sortie de S (somme). Si les deux bits sont à 1, il y aura un report, et C deviendra 1 (C deviendra 0). Ce demi-additionneur peut être modifié pour créer une sortie C non inversée, mais cette configuration est utilisée pour qu'il puisse être implémenté comme le début d'une chaîne d'additionneurs complets.

Full Adder (1 Bit Adder)[modifier | modifier le wikicode]

COMME UNE MISE EN GARDE, CE DESIGN EST FAUX ! Il utilise un OU au lieu d'un ET pour combiner les deux demi-additionneurs. La conception utilise une porte XOR, qui fonctionne parfaitement.

Full Adder (1 Bit Adder)

Gates: XNOR (2), IMPLIES, NOT, OR, AND

Torches: 16

Redstone: 32

Blocks: 48

Size: 6X12X5 Ceiling to floor, including I/O spaces.

Cet opérateur utilisera 2 données numériques ( binaires ) et une retenue et les ajoute. En résulte un résultat (S) et une retenue (C).

Pour faire un soustracteur, intervetissez juste une des entrées binaires. Si le nombre est négatif, le résultat sort inversé. En réalité, le dernier Bit du système indique si le nombre est négatif ou positif; ou si c'est juste un énorme nombre.

Alternate Full Adder[modifier | modifier le wikicode]

Full Adder

Source: "red stuff" logic gates

L'entrée et le sortie de la retenue sont alignées pour connecter plus facilement les modules en séries.

Torches: 14

Redstone wire: 15

Size: 5x6x3

4 Bit Adder[modifier | modifier le wikicode]

4 bit Adder

A noter ! Le chiffre le moins significatif (chiffre "ones") se trouve à gauche du diagramme afin que la progression d'un demi-sommateur vers les additionneurs complets soit plus clairement visible. Inversez le diagramme si vous voulez une entrée conventionnelle de gauche à droite.

'Attention! Le chiffre le moins significatif ("ceux" digit) est sur la gauche du schéma de sorte que la progression de la demi-additionneur aux additionneurs complets peut être vu plus clairement. Inverser le schéma si vous voulez une gauche traditionnelle à l'entrée droite. '

Gates: XNOR (7), IMPLIES (4), NOT (4), OR (3), AND (3)

Torches: 56

Redstone: 108

Blocks: 164

Size: 23X12X5

Cet opérateur prendra deux nombres de 4 bits (A et B) et les additionnera. En résultera une réponse (S) (longue de 4 bits) et une retenue pour tout le résultat. Les bits de la réponse sont dans le même ordre que les entrées, ce qui sur le diagramme signifie que la sortie S la plus à gauche est le dernier chiffre significatif pour la réponse. Ce n'est qu'un exemple avec de petites adresses ; des opérateurs peuvent être construits de cette manière pour des nombres plus gros.

ALU/CPU creation[modifier | modifier le wikicode]

Une ALU (Arithmetic Logic Unit) est un système capable de réaliser plusieurs calculs mathématiques (ajouter, soustraire, conditions logiques) et vous permet de choisir la fonction effectuée. Un CPU (Central Processing Unit) possède une ALU, couplée avec une mémoire RAM pour stocker nombres et réponses, permettant à l'ALU de travailler.Un exemple de CPU peut être trouvé ici Un ordinateur comporte nu CPU, une mémoire programmable, une horloge et enfin une interface vous permettant d’exécuter des commandes issues de la mémoire programmable.

Logic units[modifier | modifier le wikicode]

Dans des circuits il pourra être utile d'avoir des portes logiques qui pourront, en fonction des entrées, décider quelle sortie est à choisir. Certaines de ces unités peuvent être utilisées dans des circuits plus complexes comme des ALU.

Ceci est un exemple d'un porte logique de 2 bits qui aura 4 état dépendants de l'entrée.

Logic unit.gif

Les sorties sont dans la rangée supérieure, avec l'ordre 11, 00, 01, 10 (ordre des entrées : première en premier, seconde en dernier).

Voici un autre exemple de version simplifiée utilisant les codes Gray. La sortie apparaît au niveau des torches à la fin des lignes supérieures. Cette conception peut être étendue à un nombre quelconque de bits, mais des limitations pratiques dues à des considérations de temps limitent l'utilisation de plus d'un octet ou plus. Les sorties sont déclenchées par les entrées 11, 01, 00, 10, respectivement.

Logic unit 3.gif

Exemples de machines à redstone complexes[modifier | modifier le wikicode]

" Création des machines par l'anglais Jamieson12O

Voir aussi[modifier | modifier le wikicode]