Bibliothèques

$\text{[math]}$ `rs`

La redstone sur les six faces de l'ordinateur : lire des entrées, piloter des sorties.

Tous les ordinateurs

La bibliothèque rs relie un programme à la redstone. Chacune des six faces de l'ordinateur est à la fois une entrée et une sortie : rs.get lit le signal qui arrive sur une face, rs.set envoie un signal par cette face. Tous les ordinateurs l'ont, du Calculateur à tubes à l'Ordinateur moderne.

C'est le chemin le plus court vers le monde : une lampe de redstone, une porte, un piston, un embrayage de Create, un levier, un bouton, un comparateur qui lit un coffre. Rien à configurer, aucun câble : posez le bloc contre l'ordinateur, ou amenez-y de la poudre de redstone.

Brass

-- un levier à gauche allume la lampe du dessus
while true do
  rs.set("top", rs.get("left") > 0)
  os.pull_event("redstone")
end

Les signaux sont des nombres entiers de 0 (éteint) à 15 (pleine puissance), comme partout dans Minecraft. rs.set accepte aussi true (15) et false (0).

Les faces sont nommées depuis l'écran, en anglais et en minuscules, quelle que soit la langue du jeu :

nom	face
`front`	l'écran (l'avant)
`back`	l'arrière, à l'opposé de l'écran : l'arbre qui entraîne l'ordinateur y entre (le Microcontrôleur est entraîné par le dessous)
`left`, `right`	la gauche et la droite, vues debout face à l'écran
`top`, `bottom`	le dessus et le dessous

Astuce

Vous ne savez plus quelle face est laquelle ? Tapez brass à l'invite, puis rs.set("left", true) : la lampe qui s'allume est à gauche. Le programme intégré devices montre aussi, face par face, la redstone reçue et émise.

Fonctions

`rs.get(side)`	Le signal de redstone qui arrive sur une face, de 0 (rien) à 15.
`rs.set(side, power)`	Envoie un signal de redstone par une face.
`rs.get_output(side)`	La puissance que l'ordinateur envoie par une face : la dernière valeur réglée dessus, ou 0. C'est la sortie de l'ordinateur lui-même, pas ce que la face reçoit (ça, c'est `rs.get`).
`rs.sides()`	La liste des noms des six faces, pour passer sur chacune dans une boucle.

Entrées

Une face lit le signal le plus fort qui lui arrive, comme le ferait une lampe de redstone à la place de l'ordinateur : de la poudre de redstone qui mène à la face, un levier ou un bouton posé sur l'ordinateur ou sur un bloc qui le touche, un répéteur ou un comparateur tourné vers l'ordinateur, un bloc plein alimenté par l'un d'eux.

**L'évènement redstone.** Quand le signal change sur l'une des faces, l'ordinateur met en file un évènement redstone. Sa table ne contient que son nom : elle ne dit ni quelle face a changé, ni la nouvelle puissance. Lisez les faces qui vous intéressent avec rs.get et comparez avec votre dernière lecture. Attendre l'évènement ne coûte rien tant que rien ne bouge, contrairement à une boucle qui relit rs.get sans arrêt.

Brass

local avant = rs.get("left")
while true do
  os.pull_event("redstone")
  local maintenant = rs.get("left")
  if maintenant ~= avant then
    print("gauche : " .. avant .. " -> " .. maintenant)
    avant = maintenant
  end
end

Note

os.pull_event("redstone") jette tous les autres évènements pendant qu'il attend (clics, minuteries, messages). Un programme qui en a aussi besoin appelle os.pull_event() sans nom et regarde e.name, comme la porte plus bas. Voir Évènements et Évènements.

`rs.get(side)`

→ number

Le signal de redstone qui arrive sur une face, de 0 (rien) à 15.

Paramètres

side string: une face : "front", "back", "left", "right", "top" ou "bottom"

Renvoie

number: la puissance du signal qui arrive sur cette face, de 0 à 15

La lecture est immédiate : l'ordinateur tient ses six entrées à jour à mesure que les blocs voisins changent, et rs.get ne fait que lire la valeur.

Brass

if rs.get("left") > 0 then
  print("le levier est activé")
end

Un nom de face qui n'existe pas arrête le programme : rs.get("up") échoue avec bad side 'up' (front, back, left, right, top, bottom). Les majuscules comptent : "Left" échoue aussi.

Compter des impulsions. Un observateur intelligent qui surveille un tapis roulant donne une impulsion à chaque objet qui passe devant lui (quand les objets sont espacés). Pour compter des impulsions, comptez les moments où l'entrée passe d'éteinte à allumée, pas les évènements : chaque impulsion en envoie deux (à son début et à sa fin), et un changement sur une autre face en envoie un aussi. On appelle cela détecter un front montant. Le voici sur une liste de mesures :

Brass

local avant = false
local compte = 0
for _, puissance in ipairs({0, 15, 15, 0, 15, 0, 0, 15}) do
  local allume = puissance > 0
  if allume and not avant then
    compte = compte + 1
  end
  avant = allume
end
print(compte .. " impulsions")

Écran

3 impulsions

Et la même idée sur une vraie face :

Brass

-- compte les objets qu'un observateur intelligent, à gauche, voit passer sur un tapis
local compte = 0
local avant = rs.get("left") > 0
while true do
  os.pull_event("redstone")
  local allume = rs.get("left") > 0
  if allume and not avant then
    compte = compte + 1
    print("objets : " .. compte)
  end
  avant = allume
end

Le programme intégré counter fonctionne de la même façon.

Note

L'évènement ne transporte pas la puissance : rs.get donne l'entrée telle qu'elle est au moment où le programme la lit. Un programme qui attend dans os.pull_event lit la face aussitôt, et attrape même l'impulsion brève d'un observateur. Un programme occupé ailleurs (un long calcul, un sleep) lit la face plus tard, quand une impulsion brève peut être déjà finie : il reçoit alors deux évènements et ne voit aucun changement.

Savoir si un conteneur est plein. Un comparateur qui lit un coffre, un tonneau ou un Coffre à objet renforcé de Create donne 0 quand il est vide, 15 quand il est plein, et entre les deux une puissance qui grandit avec le contenu. Tournez le comparateur vers l'ordinateur, et la face lit le niveau :

Brass

local function barre(niveau)
  return "[" .. string.rep("#", niveau) .. string.rep(".", 15 - niveau) .. "]"
end
print(barre(15))
print(barre(6))
print(barre(0))

Écran

[###############]
[######.........]
[...............]

Brass

-- un comparateur lit le coffre renforcé de fer et vise la face gauche
local function barre(niveau)
  return "[" .. string.rep("#", niveau) .. string.rep(".", 15 - niveau) .. "]"
end

while true do
  local niveau = rs.get("left")
  term.clear()
  term.set_cursor(1, 1)
  print("Fer " .. barre(niveau))
  if niveau == 0 then
    print("VIDE")
  elseif niveau == 15 then
    print("PLEIN")
  end
  os.pull_event("redstone")
end

Un comparateur dit à quel point c'est plein, pas combien il y en a. Pour le compte exact de chaque objet, pilotez le coffre renforcé comme périphérique : inventory.count().

Voir aussi rs.set() rs.sides() os.pull_event()

Sorties

Une face qui émet alimente fortement le bloc posé devant elle, comme un levier alimente le bloc sur lequel il est posé : une lampe de redstone, une porte, un piston, de la poudre de redstone ou un embrayage de Create sur cette face réagit, et quand ce bloc est un bloc plein (pierre, planches), les lampes, la poudre et les portes qui le touchent réagissent aussi.

Appliquées en fin de tick. Le monde voit le changement d'une sortie à la fin du tick de l'ordinateur. Quand un programme règle la même face plusieurs fois dans un même tick, seule la dernière valeur compte : une boucle qui allume et éteint une lampe sans attendre ne change rien. Pour clignoter, attendez entre deux changements avec sleep.

Les sorties restent. Une sortie garde sa puissance jusqu'à ce que le programme la change. La fin du programme ne l'éteint pas, qu'il se termine normalement, sur une erreur ou par Ctrl+T. Un redémarrage et un arrêt, si : ils remettent les six faces à 0 (et coupent aussi les fréquences de link et vident les lignes de display). Un ordinateur dont la rotation s'arrête garde ses sorties pendant qu'il attend. Quand son chunk se décharge, l'ordinateur s'éteint et ses sorties retombent à 0 ; quand le chunk se recharge, il démarre et lance son programme startup.

`rs.set(side, power)`

Envoie un signal de redstone par une face.

Paramètres

side string: une face : "front", "back", "left", "right", "top" ou "bottom"
power number|boolean: une puissance de 0 à 15, ou true (15) et false (0)

Brass

rs.set("top", 15)     -- la lampe du dessus à pleine puissance
rs.set("top", true)   -- la même chose
rs.set("top", false)  -- éteinte
rs.set("left", 7)     -- un signal plus faible, pour un circuit à comparateur

Une puissance au-dessus de 15 devient 15, en dessous de 0 devient 0. Elle doit être entière : rs.set("top", 7.5) arrête le programme avec bad argument #2 to 'set' (number has no integer representation), alors arrondissez d'abord avec math.floor. Sans puissance, c'est bad argument #2 to 'set' (number expected, got no value).

Le programme intégré blink fait clignoter une lampe, et sequencer joue une séquence sur deux faces.

Une porte à minuterie. Un bouton à gauche ouvre la porte en fer de droite pendant 5 secondes. Un nouvel appui pendant que la porte est ouverte relance les 5 secondes. Le programme attend n'importe quel évènement : un appui sur le bouton (un évènement redstone) ou la fin de sa minuterie (un évènement timer, voir os.start_timer).

Brass

local DUREE = 5
local minuterie = nil
local avant = false

while true do
  local e = os.pull_event()
  if e.name == "redstone" then
    local appuye = rs.get("left") > 0
    if appuye and not avant then
      rs.set("right", true)
      minuterie = os.start_timer(DUREE)  -- une nouvelle minuterie : l'ancienne ne compte plus
    end
    avant = appuye
  elseif e.name == "timer" and e.id == minuterie then
    rs.set("right", false)
    minuterie = nil
  end
end

Un nombre sur quatre lampes. Quatre faces peuvent montrer un nombre de 0 à 15 en binaire, une lampe par bit. L'arrière porte l'arbre et l'avant l'écran : les bits prennent donc les quatre autres faces (l'ordinateur peut reposer sur sa lampe du dessous, une lampe de redstone est un bloc plein). La fonction transforme chaque bit en true ou false et renvoie les bits sous forme de texte :

Brass

local lampes = {"right", "top", "left", "bottom"}  -- les bits valent 1, 2, 4 et 8

local function montrer(n)
  local bits = ""
  for i = 1, 4 do
    local allumee = n % 2 == 1
    rs.set(lampes[i], allumee)
    bits = (allumee and "1" or "0") .. bits
    n = n // 2
  end
  return bits
end

print(montrer(11))
print(montrer(6))

Écran

1011
0110

Avec elle, un compteur qui monte de 0 à 15, d'un pas par seconde :

Brass

local lampes = {"right", "top", "left", "bottom"}

local function montrer(n)
  for i = 1, 4 do
    rs.set(lampes[i], n % 2 == 1)
    n = n // 2
  end
end

while true do
  for n = 0, 15 do
    montrer(n)
    sleep(1)
  end
end

Voir aussi rs.get_output() rs.get()

`rs.get_output(side)`

→ number

La puissance que l'ordinateur envoie par une face : la dernière valeur réglée dessus, ou 0. C'est la sortie de l'ordinateur lui-même, pas ce que la face reçoit (ça, c'est rs.get).

Paramètres

side string: une face : "front", "back", "left", "right", "top" ou "bottom"

Renvoie

number: la puissance que cet ordinateur envoie par cette face, de 0 à 15

Elle donne la nouvelle valeur dès que rs.set a rendu la main, avant même que le monde la voie en fin de tick. Un interrupteur qui inverse la lampe du dessus à chaque appel :

Brass

local function basculer(face)
  rs.set(face, 15 - rs.get_output(face))
end
basculer("top")

Comme les sorties survivent au programme qui les a réglées, un programme peut aussi ranger ce qu'un précédent a laissé allumé :

Brass

for _, face in ipairs(rs.sides()) do
  if rs.get_output(face) > 0 then
    print("j'éteins " .. face)
    rs.set(face, 0)
  end
end

Voir aussi rs.set() rs.get()

Faces

`rs.sides()`

→ table

La liste des noms des six faces, pour passer sur chacune dans une boucle.

Renvoie

table: les noms des six faces : front, back, left, right, top, bottom, dans cet ordre

Brass

for _, face in ipairs(rs.sides()) do
  print(face, rs.get(face), rs.get_output(face))
end

Chaque ligne montre une face, le signal qu'elle reçoit, puis celui qu'elle envoie. Avec un levier activé à gauche et la lampe du dessus allumée par l'ordinateur, l'écran affiche :

Écran

front   0   0
back    0   0
left    15  0
right   0   0
top     0   15
bottom  0   0

Les mêmes noms servent à peripheral : le bloc qui touche une face est peripheral.wrap("left").

Bon à savoir

Séparez entrées et sorties. Une face qui alimente un bloc plein peut relire son propre signal à travers ce bloc.
C'est loin ? Plutôt qu'une longue ligne de poudre, utilisez une Liaison de redstone de Create avec link : l'ordinateur émet et reçoit sans aucun bloc.
Les machines. Un embrayage de Create débraye tant qu'il est alimenté et un inverseur de rotation inverse le sens : rs.set arrête ou renverse toute une chaîne. Pour une vitesse précise, pilotez plutôt un Contrôleur de vitesse de rotation : kinetic.set_speed().
Pour aller plus loin sur le câblage des ordinateurs à la redstone : Redstone et liaisons de Create.

Voir aussi rs.get() peripheral.list()

#Entrées

rs.get(side)

#Sorties

rs.set(side, power)

rs.get_output(side)

#Faces

rs.sides()

#Bon à savoir

Entrées

`rs.get(side)`

Sorties

`rs.set(side, power)`

`rs.get_output(side)`

Faces

`rs.sides()`

Bon à savoir