Precision machines

The precision machines of Computing Ages work like a Create Mechanical Press: they hang above a belt or a depot and bring their head down on the part under them, one step of a vacuum tube or a chip at a time. They hold what they work with (a spool of wire, a dopant, a photomask...) and need rotation, often fast. When a machine waits, Engineer's Goggles tell why: too slow, an ingredient missing... A computer reads the same thing, and can act on it: speed the line up, call for more wire, warn you.

local implanter = peripheral.find("ion_implanter")
if implanter.running() then
  print("working: " .. math.floor(implanter.progress() * 100) .. " %")
else
  print("waiting: " .. (implanter.problem() or "nothing to fix"))
end

#Setting up

Five machines, one set of methods. Each machine has its own type, the one you look for; all five have the methods of this page, written precision_machine.* here.

precision_machine itself is not a type: peripheral.find("precision_machine") returns nil. Ask for the machine you want, like peripheral.find("coil_winder"). On a Data Cable (Minicomputer and newer), a machine is named after its type and its place: ion_implanter@120,64,-35.

Also kinetic and inventory. A precision machine turns and holds items, so it is also a kinetic block and an inventory, with all their methods: machine.speed() reads its RPM, machine.overstressed() tells whether its network has stopped, and machine.list() shows the slots of the table above (how much wire is left on a Coil Winder, for example). peripheral.find("inventory") finds them too.

Where the part is. A machine works on the part on the belt or the depot two blocks below it (with one block of air in between, as for a Mechanical Press), or, when there is no belt or depot there, on an item lying on the ground right under it.

The Crystal Puller works over a Basin instead, and has its own methods: see its section at the end of this page.

When the machine is gone, its methods stop the program with machine removed (crystal puller removed for the Crystal Puller); when its chunk is not loaded, with peripheral is not loaded.

#The head

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

local chamber = peripheral.find("vacuum_chamber")
print("vacuum cycle: " .. math.floor(chamber.progress() * 100) .. " %")

#The part below

local litho = peripheral.find("lithography_machine")
local part = litho.item()
if part then
  print("under the machine: " .. part.display)
else
  print("no wafer below")
end

local implanter = peripheral.find("ion_implanter")
local r = implanter.recipe()
if r then
  print("makes " .. r.output .. ", at " .. r.min_speed .. " RPM or more")
end

#Why it waits

local winder = peripheral.find("coil_winder")
local problem = winder.problem()
if problem == "missing_ingredient" then
  print("the Coil Winder needs a new spool of wire")
elseif problem == "too_slow" then
  print("the Coil Winder does not turn fast enough")
end

local litho = peripheral.find("lithography_machine")
local r = litho.recipe()
if r and litho.tier() < r.tier then
  print("this mask needs a light source of tier " .. r.tier)
end

#Crystal Puller

The Crystal Puller grows a single crystal out of the melt in the Basin two blocks below it, by the Czochralski process: a silicon boule from molten silicon, or synthetic quartz. Its type is crystal_puller, and it is also a kinetic block.

It wants a slow shaft. Above its speed limit (32 RPM by default) the crystal would break: the puller does not start, and a pull already under way waits until the shaft slows down. Below the limit, the slower it turns, the longer the pull: twice as long at half the limit, up to eight times as long. The length is set when the pull starts, so the best speed is the limit itself, set before the pull begins.

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

local puller = peripheral.find("crystal_puller")
if puller.running() then
  print("boule " .. math.floor(puller.progress() * 100) .. " % pulled")
end

local puller = peripheral.find("crystal_puller")
local controller = peripheral.find("speed_controller")
controller.set_target_speed(puller.max_speed())

local puller = peripheral.find("crystal_puller")
if puller.problem() == "too_fast" then
  print("slow down: " .. puller.max_speed() .. " RPM at most")
end

#Examples

#Never too slow

The recipes of the Ion Implanter ask for 128 RPM. A Rotation Speed Controller drives it, and this program raises the controller step by step while the implanter is too slow, up to Create's limit. When the network is overstressed, more speed would only make it worse: the program says so instead.

local implanter = peripheral.find("ion_implanter")
local controller = peripheral.find("speed_controller")
local STEP = 16   -- RPM added each time

while true do
  if implanter.overstressed() then
    print("overstressed: add power, more speed would not help")
  elseif implanter.problem() == "too_slow" then
    local target = controller.target_speed()
    if math.abs(target) >= 256 then
      print("the controller is at full speed already")
    else
      local rpm = math.min(256, math.abs(target) + STEP)
      if target < 0 then
        rpm = -rpm   -- keep the direction
      end
      controller.set_target_speed(rpm)
      print("too slow: controller set to " .. rpm .. " RPM")
    end
  end
  sleep(2)
end

It works through any gearing between the controller and the implanter, since it only watches the implanter's own problem. overstressed() comes from the kinetic methods every machine has.

#A status board for the line

A Minicomputer on the Data Cable that runs along a chip line prints one line per machine it reaches: working with its progress, waiting with its problem, or idle. The Crystal Puller has running, progress and problem too, so it fits on the same board.

local NAMES = {
  coil_winder = "Coil Winder",
  vacuum_chamber = "Vacuum Chamber",
  lithography_machine = "Photolithography",
  ion_implanter = "Ion Implanter",
  pick_and_place = "Pick-and-Place",
  crystal_puller = "Crystal Puller",
}

local function status(machine)
  if machine.running() then
    return "working, " .. math.floor(machine.progress() * 100) .. " %"
  end
  return machine.problem() or "idle"
end

while true do
  term.clear()
  term.set_cursor(1, 1)
  for _, name in ipairs(peripheral.list()) do
    local label = NAMES[peripheral.type(name)]
    if label then
      print(string.format("%-17s %s", label, status(peripheral.wrap(name))))
    end
  end
  sleep(2)
end

peripheral.type gives the first type of each name, which for these blocks is their own (coil_winder...), not kinetic or inventory.