peripheral

A peripheral is a block the computer can talk to: a chest, a Create machine, a Traffic Light, a monitor, a sensor of Create Aeronautics. The peripheral library finds these blocks and hands the program an object that carries the block's own functions, its methods: chest.count(), light.set("green"), controller.set_speed(64). Every computer has it.

local chest = peripheral.wrap("left")
print(chest.count("minecraft:iron_ingot") .. " iron ingots")

Blocks against the computer are named after the face they touch: "front", "back", "left", "right", "top" and "bottom", as for rs (left and right as seen facing the screen). The block that drives the computer counts too: the shaft at the back (below a Microcontroller) is a kinetic peripheral.

Blocks on the Data Cable. From the Minicomputer on, every block touching the computer's Data Cable network is a peripheral as well, named type@x,y,z: its type and its coordinates, as F3 shows them, like inventory@120,64,-35. The name stays the same as long as the block is there.

• Plain shafts, cogwheels and gearboxes along a cable are not peripherals of the network, so a cable can run along a gear train. Against the computer itself, they are.
• Other computers on the cable are not peripherals: computers talk to each other with net.
• A side of a cable cut with a wrench lets nothing through.
• A network reaches 2048 cables at most, and only in loaded chunks. A new cable is seen at once, a block placed against a cable within a second.
• The Tube Computer and the Transistor Mainframe have no network port: they only reach their six faces.

Types. What a block can do is its type. The methods of each type are on its page:

The last two rows only exist when Create Aeronautics is installed. What every object has in common is on Every device.

Several types. A block can be several things at once: a Create Millstone turns (kinetic) and holds items (inventory), a Basin holds items and fluids. Its object then has the methods of all its types together: millstone.speed() and millstone.count(). peripheral.type, the type() method and the network name give the first type, in the order of the table above (the Aeronautics types first); peripheral.list(type) and peripheral.find(type) look at all of them, so peripheral.find("inventory") finds the Millstone, named kinetic@x,y,z on the cable.

Seen from one side. An inventory or a tank is seen from its face that touches the computer (or the cable), the way a hopper on that side would see it: a Furnace shows its input slot from above, its fuel slot from the side, and its result from below.

Costs. Most calls cost one instruction, but scanning a cable network costs more, because every block around it is asked what it is:

A straight cable 20 blocks long has about 80 blocks around it: peripheral.list() then takes about 340 instructions, more than a whole tick of a Minicomputer. Find your peripherals once at the start of the program, keep the objects, and only scan again when the installation changes. The methods themselves have their own costs, listed on the pages of each type. See also Speed, memory and limits.

#Finding peripherals

for _, name in ipairs(peripheral.list()) do
  print(name, peripheral.type(name))
end

back    kinetic
left    kinetic
inventory@120,64,-35    inventory
inventory@121,64,-35    inventory

local chests = {}
for _, name in ipairs(peripheral.list("inventory")) do
  if string.find(name, "@") then  -- cable names only: see below
    table.insert(chests, peripheral.wrap(name))
  end
end
print(#chests .. " inventories on the cable")

while true do
  local iron = 0
  for _, chest in ipairs(chests) do
    iron = iron + chest.count("minecraft:iron_ingot")
  end
  display.set({"Iron in storage", tostring(iron)})
  sleep(10)
end

local light = peripheral.find("traffic_light")
if light == nil then
  error("no traffic light found")
end
light.set("green")

local storage = peripheral.find("inventory")
local tank = peripheral.find("tank")
local light = peripheral.find("traffic_light")

while true do
  term.clear()
  term.set_cursor(1, 1)
  if storage then
    print("items: " .. storage.count() .. " in " .. storage.size() .. " slots")
  end
  if tank then
    for _, t in ipairs(tank.tanks()) do
      print((t.fluid or "empty") .. ": " .. t.amount .. "/" .. t.capacity .. " mB")
    end
  end
  if light then
    print("traffic light: " .. light.get())
  end
  if not (storage or tank or light) then
    print("nothing to watch here")
  end
  sleep(1)
end

while peripheral.type("left") ~= "inventory" do
  print("place a chest on the left")
  sleep(2)
end
print("chest found")

#Driving a peripheral

local vault = peripheral.wrap("left")
if vault == nil then
  error("put the vault on the left")
end
print(vault.type())   -- inventory
print(vault.count())

local controller = peripheral.wrap("right")   -- a Rotation Speed Controller
local stock = peripheral.wrap("left")         -- the vault of raw iron
while true do
  if stock.count("minecraft:raw_iron") > 1000 then
    controller.set_speed(32)
  else
    controller.set_speed(128)
  end
  sleep(5)
end

peripheral.call("left", "set", "red")
local coal = peripheral.call("inventory@120,64,-35", "count", "minecraft:coal")
print(coal .. " coal")