Machines de précision

Les machines de précision de Computing Ages fonctionnent comme une Presse mécanique de Create : elles sont suspendues au-dessus d'un tapis roulant ou d'un dépôt et descendent leur tête sur la pièce qui passe dessous, une étape de tube à vide ou de puce à la fois. Elles contiennent ce avec quoi elles travaillent (une bobine de fil, un dopant, un photomasque...) et demandent de la rotation, souvent rapide. Quand une machine attend, les Lunettes d'ingénieur disent pourquoi : trop lente, un ingrédient manquant... Un ordinateur lit la même chose, et peut agir : accélérer la ligne, réclamer du fil, vous prévenir.

local implanteur = peripheral.find("ion_implanter")
if implanteur.running() then
  print("au travail : " .. math.floor(implanteur.progress() * 100) .. " %")
else
  print("en attente : " .. (implanteur.problem() or "rien à corriger"))
end

#Installation

Cinq machines, les mêmes méthodes. Chaque machine a son propre type, celui que vous cherchez ; les cinq ont les méthodes de cette page, notées ici precision_machine.*.

precision_machine n'est pas un type : peripheral.find("precision_machine") renvoie nil. Demandez la machine que vous voulez, par exemple peripheral.find("coil_winder"). Sur un Câble de données (Mini-ordinateur et plus récents), une machine prend le nom de son type et de sa place : ion_implanter@120,64,-35.

Aussi cinétiques et inventaires. Une machine de précision tourne et contient des objets : c'est donc aussi un bloc cinétique et un inventaire, avec toutes leurs méthodes. machine.speed() lit sa vitesse en tr/min, machine.overstressed() dit si son réseau s'est arrêté, et machine.list() montre les cases du tableau ci-dessus (le fil qui reste sur une Bobineuse, par exemple). peripheral.find("inventory") les trouve aussi.

Où est la pièce. Une machine travaille sur la pièce posée sur le tapis roulant ou le dépôt deux blocs plus bas (avec un bloc d'air entre les deux, comme pour une Presse mécanique), ou, quand il n'y a là ni tapis ni dépôt, sur un objet posé au sol juste en dessous d'elle.

La Tireuse de cristaux travaille au-dessus d'un Bassin et a ses propres méthodes : voyez sa section à la fin de cette page.

Quand la machine a disparu, ses méthodes arrêtent le programme avec machine removed (crystal puller removed pour la Tireuse de cristaux) ; quand son chunk n'est pas chargé, avec peripheral is not loaded.

#La tête

local bobineuse = peripheral.find("coil_winder")
while true do
  rs.set("top", bobineuse.running())
  sleep(0.5)
end

local chambre = peripheral.find("vacuum_chamber")
print("cycle sous vide : " .. math.floor(chambre.progress() * 100) .. " %")

#La pièce en dessous

local litho = peripheral.find("lithography_machine")
local piece = litho.item()
if piece then
  print("sous la machine : " .. piece.display)
else
  print("pas de wafer dessous")
end

local implanteur = peripheral.find("ion_implanter")
local r = implanteur.recipe()
if r then
  print("fabrique " .. r.output .. ", à " .. r.min_speed .. " tr/min ou plus")
end

#Pourquoi elle attend

local bobineuse = peripheral.find("coil_winder")
local probleme = bobineuse.problem()
if probleme == "missing_ingredient" then
  print("la Bobineuse a besoin d'une nouvelle bobine de fil")
elseif probleme == "too_slow" then
  print("la Bobineuse ne tourne pas assez vite")
end

local litho = peripheral.find("lithography_machine")
local r = litho.recipe()
if r and litho.tier() < r.tier then
  print("ce masque demande une source lumineuse de niveau " .. r.tier)
end

#Tireuse de cristaux

La Tireuse de cristaux fait croître un monocristal dans le bain fondu du Bassin placé deux blocs plus bas, par le procédé Czochralski : une boule de silicium à partir de silicium fondu, ou du quartz synthétique. Son type est crystal_puller, et c'est aussi un bloc cinétique.

Elle veut un arbre lent. Au-delà de sa vitesse limite (32 tr/min par défaut), le cristal casserait : la tireuse ne démarre pas, et un tirage déjà commencé attend que l'arbre ralentisse. En dessous de la limite, plus elle tourne lentement, plus le tirage est long : deux fois plus long à la moitié de la limite, jusqu'à huit fois plus long. La durée est fixée au début du tirage : la meilleure vitesse est donc la limite elle-même, réglée avant que le tirage commence.

local tireuse = peripheral.find("crystal_puller")
print(tireuse.running())

local tireuse = peripheral.find("crystal_puller")
if tireuse.running() then
  print("boule tirée à " .. math.floor(tireuse.progress() * 100) .. " %")
end

local tireuse = peripheral.find("crystal_puller")
local regulateur = peripheral.find("speed_controller")
regulateur.set_target_speed(tireuse.max_speed())

local tireuse = peripheral.find("crystal_puller")
if tireuse.problem() == "too_fast" then
  print("ralentissez : " .. tireuse.max_speed() .. " tr/min au plus")
end

#Exemples

#Jamais trop lent

Les recettes de l'Implanteur ionique demandent 128 tr/min. Un Contrôleur de vitesse de rotation l'entraîne, et ce programme monte le contrôleur pas à pas tant que l'implanteur est trop lent, jusqu'à la limite de Create. Quand le réseau est surchargé, plus de vitesse ne ferait qu'empirer les choses : le programme le dit plutôt.

local implanteur = peripheral.find("ion_implanter")
local regulateur = peripheral.find("speed_controller")
local PAS = 16   -- tr/min ajoutés à chaque fois

while true do
  if implanteur.overstressed() then
    print("surcharge : ajoutez de la puissance, plus de vitesse n'aiderait pas")
  elseif implanteur.problem() == "too_slow" then
    local cible = regulateur.target_speed()
    if math.abs(cible) >= 256 then
      print("le contrôleur est déjà à pleine vitesse")
    else
      local tours = math.min(256, math.abs(cible) + PAS)
      if cible < 0 then
        tours = -tours   -- garde le sens de rotation
      end
      regulateur.set_target_speed(tours)
      print("trop lent : contrôleur réglé à " .. tours .. " tr/min")
    end
  end
  sleep(2)
end

Il fonctionne quels que soient les engrenages entre le contrôleur et l'implanteur, puisqu'il ne surveille que le problème de l'implanteur lui-même. overstressed() vient des méthodes cinétiques qu'a chaque machine.

#Un tableau d'état de la ligne

Un Mini-ordinateur sur le Câble de données qui longe une ligne de puces affiche une ligne par machine qu'il atteint : au travail avec son avancement, en attente avec son problème, ou au repos. La Tireuse de cristaux a elle aussi running, progress et problem : elle trouve sa place sur le même tableau.

local NOMS = {
  coil_winder = "Bobineuse",
  vacuum_chamber = "Chambre à vide",
  lithography_machine = "Photolithographie",
  ion_implanter = "Implanteur ionique",
  pick_and_place = "Placeuse CMS",
  crystal_puller = "Tireuse",
}

local function etat(machine)
  if machine.running() then
    return "au travail, " .. math.floor(machine.progress() * 100) .. " %"
  end
  return machine.problem() or "au repos"
end

while true do
  term.clear()
  term.set_cursor(1, 1)
  for _, nom in ipairs(peripheral.list()) do
    local libelle = NOMS[peripheral.type(nom)]
    if libelle then
      print(string.format("%-18s %s", libelle, etat(peripheral.wrap(nom))))
    end
  end
  sleep(2)
end

peripheral.type donne le premier type de chaque nom, qui pour ces blocs est le leur (coil_winder...), et non kinetic ou inventory.