Périphériques

$\text{[math]}$ Blocs cinétiques de Create

Vitesse, stress et capacité de n'importe quel bloc de Create qui tourne, et un Contrôleur de vitesse de rotation piloté par programme.

Tout bloc de Create qui tourne est un périphérique de type kinetic : arbres et roues dentées, moteurs, roues à eau, presses, mixeurs, ventilateurs, meules, roues de concassage, compteurs... Un programme lit sa vitesse, le stress de tout son réseau et ce que ce réseau peut fournir, et sait quand il est surchargé, le tout sans Stressomètre ni Lunettes d'ingénieur. Sur un Contrôleur de vitesse de rotation, le programme règle aussi la vitesse.

Brass

local presse = peripheral.wrap("left")
print(presse.speed() .. " tr/min")
print(presse.stress() .. " / " .. presse.capacity() .. " us")

Méthodes

`machine.speed()`	À quelle vitesse tourne le bloc, en tours par minute.
`machine.stress()`	Le stress total du réseau dont fait partie ce bloc : ce qu'un Stressomètre affiche comme utilisé.
`machine.capacity()`	La capacité totale du réseau : ce que ses moteurs, roues à eau, moulins à vent et moteurs à vapeur fournissent à leur vitesse actuelle.
`machine.overstressed()`	Indique si le réseau est surchargé, au sens de Create.
`machine.set_speed(rpm)`	Règle la vitesse visée d'un Contrôleur de vitesse de rotation : la vitesse de la grande roue dentée posée dessus.

Installation

Contre l'ordinateur. Tout bloc cinétique posé contre une face de l'ordinateur est un périphérique, simples arbres compris. L'arbre qui entraîne l'ordinateur compte aussi : il entre par l'arrière (par le dessous sur un Microcontrôleur), donc peripheral.wrap("back") lit le réseau même qui alimente votre ordinateur.

Sur un Câble de données (Mini-ordinateur et plus récents), les machines s'appellent par exemple kinetic@120,64,-35. Les simples pièces de transmission sont laissées de côté exprès, pour qu'un câble qui longe un train d'engrenages ne remplisse pas peripheral.list() : arbres, roues dentées, arbres et roues dentées dans un boitier, boîtes à roues dentées, embrayages et inverseurs de rotation. Posez-en un contre l'ordinateur si vous le voulez, ou lisez plutôt n'importe quelle machine du même réseau : toutes donnent le même stress et la même capacité.

Les blocs à plusieurs métiers. Une meule tourne et contient des objets : elle est à la fois kinetic et inventaire, avec les méthodes des deux. Son type, et son nom sur un câble, est kinetic, et peripheral.find("inventory") la trouve aussi. Voir Périphériques.

Les unités de stress. Create compte en unités de stress (« us » dans le jeu). Chaque machine consomme son impact de stress multiplié par sa vitesse ; moteurs, roues à eau et moteurs à vapeur fournissent une capacité, qui grandit elle aussi avec la vitesse. Quand les machines demandent plus que ce que les sources fournissent, le réseau est surchargé : tout s'y arrête jusqu'à ce que vous retiriez de la charge ou ajoutiez de la puissance.

Mesures

`machine.speed()`

→ number

À quelle vitesse tourne le bloc, en tours par minute.

Renvoie

number: la vitesse du bloc en tr/min, négative quand il tourne dans l'autre sens, 0 à l'arrêt

Le signe donne le sens, tel que Create le voit : une roue dentée engrenée sur une autre tourne en sens inverse, l'une lit donc 64 et l'autre -64. Prenez math.abs quand seule la vitesse compte. Les vitesses montent jusqu'à 256 tr/min, sauf si le serveur a changé la limite de Create.

Brass

local moteur = peripheral.wrap("back")  -- l'arbre qui fait tourner l'ordinateur
local tours = math.abs(moteur.speed())
print("processeur à " .. math.floor(math.min(tours, 256) / 256 * 100) .. " %")

Un ordinateur tourne à pleine vitesse à 256 tr/min : ce petit programme montre donc à quelle allure va son propre processeur.

speed() lit 0 tant que le réseau est surchargé, puisque Create l'arrête. Sur un Contrôleur de vitesse de rotation, c'est la vitesse de l'arbre qui traverse le contrôleur (son entrée), pas celle de la roue dentée du dessus.

Quand le bloc n'est plus un bloc cinétique (cassé, remplacé), toutes les méthodes de cette page arrêtent le programme avec not a kinetic block anymore.

Voir aussi kinetic.set_speed()

`machine.stress()`

→ number⚙ coût 1 par bloc du réseau

Le stress total du réseau dont fait partie ce bloc : ce qu'un Stressomètre affiche comme utilisé.

Renvoie

number: le stress que consomment les machines du réseau, en us, 0 quand le bloc n'est sur aucun réseau

N'importe quel bloc du réseau donne la même réponse : prenez celui qui vous arrange. L'appel parcourt tous les blocs du réseau, ce qui coûte une instruction par bloc : sur une usine de 2000 blocs cinétiques, un Calculateur à tubes attend un bon moment sa réponse. Lisez-le toutes les secondes environ, pas dans une boucle serrée.

Brass

local machine = peripheral.wrap("left")
local utilise = machine.stress()
local capacite = machine.capacity()
print(utilise .. " us utilisées, " .. (capacite - utilise) .. " us libres")

Voir aussi kinetic.capacity() kinetic.overstressed()

`machine.capacity()`

→ number⚙ coût 1 par bloc du réseau

La capacité totale du réseau : ce que ses moteurs, roues à eau, moulins à vent et moteurs à vapeur fournissent à leur vitesse actuelle.

Renvoie

number: le stress que les sources du réseau peuvent fournir, en us, 0 quand le bloc n'est sur aucun réseau

Le rapport stress() / capacity() est la charge du réseau, 1 voulant dire plein. Vérifiez que la capacité dépasse 0 avant de diviser : un bloc qu'aucune source n'entraîne a une capacité de 0.

Brass

local machine = peripheral.wrap("left")
local capacite = machine.capacity()
if capacite > 0 then
  print("charge : " .. math.floor(machine.stress() / capacite * 100) .. " %")
else
  print("rien n'entraîne ce réseau")
end

Voir aussi kinetic.stress() kinetic.overstressed()

`machine.overstressed()`

→ boolean

Indique si le réseau est surchargé, au sens de Create.

Renvoie

boolean: true quand le réseau demande plus de stress qu'il ne peut en fournir, et s'est arrêté

C'est le même état qui arrête les machines de Create et fait afficher un avertissement aux Lunettes d'ingénieur. Le demander ne coûte rien, contrairement à stress() et capacity() :

Brass

local machine = peripheral.wrap("left")
if machine.overstressed() then
  rs.set("top", true)  -- la lampe d'alerte
end

Contrôleur de vitesse de rotation

`machine.set_speed(rpm)`

Règle la vitesse visée d'un Contrôleur de vitesse de rotation : la vitesse de la grande roue dentée posée dessus.

Paramètres

rpm number: la vitesse visée, un nombre entier de tr/min, négatif pour tourner dans l'autre sens

Il fait ce que fait le réglage à la main de la valeur du contrôleur : la nouvelle valeur reste dans le contrôleur après la fin du programme. 0 arrête la sortie, une vitesse négative l'inverse. Les valeurs au-delà de la limite de Create (256 tr/min) y sont ramenées. Le contrôleur a toujours besoin de rotation sur son arbre d'entrée pour entraîner quoi que ce soit.

Brass

local controleur = peripheral.wrap("right")
controleur.set_speed(64)
controleur.set_speed(-64)  -- dans l'autre sens

Une nouvelle vitesse reconstruit le réseau cinétique : elle est donc appliquée à la fin du tick du programme, une seule fois, avec la dernière valeur demandée. Une boucle qui change la vitesse plusieurs fois par tick ne coûte au monde qu'une mise à jour. Pour la même raison, lire la vitesse de la sortie dans le même tick montre encore l'ancienne.

En cas d'échec :

sur tout autre bloc cinétique : set_speed needs a Rotation Speed Controller ;
avec un nombre à virgule : bad argument #1 to 'set_speed' (number has no integer representation). Arrondissez-le d'abord avec math.round.

Voir aussi kinetic.speed()

Exemples

Une alerte avant la surcharge

Create ne prévient que quand il est trop tard. Ce programme allume une lampe orange quand le réseau dépasse 80 % de sa capacité, et une lampe rouge avec une cloche quand il est surchargé. Le bloc pris peut être n'importe quelle machine du réseau.

Brass

local machine = peripheral.wrap("left")
while true do
  local capacite = machine.capacity()
  local charge = 0
  if capacite > 0 then
    charge = machine.stress() / capacite
  end
  rs.set("top", charge > 0.8)                   -- lampe orange
  rs.set("right", machine.overstressed())       -- lampe rouge et cloche
  display.set({"Charge " .. math.floor(charge * 100) .. " %", math.floor(capacite) .. " us disponibles"})
  sleep(1)
end

La recette Protection contre la surcharge construit une protection complète sur cette idée.

Une ligne de presses qui suit son stock

Un Contrôleur de vitesse de rotation entraîne une ligne de presses mécaniques qui fabrique des plaques de fer pour un Coffre à objet renforcé. Plus le coffre renforcé est vide, plus les presses vont vite ; au stock visé, elles s'arrêtent et ne consomment plus aucun stress.

Brass

local coffre = peripheral.wrap("left")
local controleur = peripheral.wrap("right")
local OBJECTIF = 2000  -- plaques de fer à garder en stock
local MAX = 128        -- vitesse maximale de la ligne, en tr/min
while true do
  local plaques = coffre.count("create:iron_sheet")
  local manque = math.max(0, OBJECTIF - plaques)
  local tours = math.round(MAX * manque / OBJECTIF)
  controleur.set_speed(tours)
  print(plaques .. " plaques, presses à " .. tours .. " tr/min")
  sleep(5)
end

Le programme intégré speed en fait la version la plus simple : vite tant qu'une entrée de redstone est allumée, lentement sinon.

#Installation

#Mesures

machine.speed()

machine.stress()

machine.capacity()

machine.overstressed()

#Contrôleur de vitesse de rotation

machine.set_speed(rpm)

#Exemples

#Une alerte avant la surcharge

#Une ligne de presses qui suit son stock

Installation

Mesures

`machine.speed()`

`machine.stress()`

`machine.capacity()`

`machine.overstressed()`

Contrôleur de vitesse de rotation

`machine.set_speed(rpm)`

Exemples

Une alerte avant la surcharge

Une ligne de presses qui suit son stock