rs

The redstone signal arriving on a face, from 0 (nothing) to 15.

Reading is instant: the computer keeps its six inputs up to date as the blocks around it change, and rs.get only looks the value up.

if rs.get("left") > 0 then
  print("the lever is on")
end

A face name that does not exist stops the program: rs.get("up") fails with bad side 'up' (front, back, left, right, top, bottom). Names are case sensitive, so "Left" fails too.

Count pulses. A Smart Observer watching a belt gives a pulse each time an item passes in front of it (when the items are spaced out). To count pulses, count the moments the input goes from off to on, not the events: each pulse sends two events (when it starts and when it ends), and a change on another face sends one too. This is called edge detection. Here it is on a list of readings:

local was = false
local count = 0
for _, power in ipairs({0, 15, 15, 0, 15, 0, 0, 15}) do
  local now = power > 0
  if now and not was then
    count = count + 1
  end
  was = now
end
print(count .. " pulses")

3 pulses

And the same idea on a real face:

-- counts the items a Smart Observer on the left sees pass on a belt
local count = 0
local was = rs.get("left") > 0
while true do
  os.pull_event("redstone")
  local now = rs.get("left") > 0
  if now and not was then
    count = count + 1
    print("items: " .. count)
  end
  was = now
end

The built-in counter program works the same way.

Read how full a container is. A Redstone Comparator reading a chest, a barrel or a Create Item Vault gives 0 when it is empty, 15 when it is full, and a strength in between that grows with the contents. Point the comparator at the computer, and the face reads the level:

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

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

-- a Comparator reads the iron vault and points at the left face
local function bar(level)
  return "[" .. string.rep("#", level) .. string.rep(".", 15 - level) .. "]"
end

while true do
  local level = rs.get("left")
  term.clear()
  term.set_cursor(1, 1)
  print("Iron vault " .. bar(level))
  if level == 0 then
    print("EMPTY")
  elseif level == 15 then
    print("FULL")
  end
  os.pull_event("redstone")
end

A comparator tells how full, not how many. For an exact count of each item, drive the vault as a peripheral: inventory.count().

See also rs.set() rs.sides() os.pull_event()

Sends a redstone signal out of a face.

rs.set("top", 15)     -- the lamp on top at full power
rs.set("top", true)   -- the same
rs.set("top", false)  -- off
rs.set("left", 7)     -- a weaker signal, for a comparator circuit

A strength above 15 becomes 15, below 0 becomes 0. It must be a whole number: rs.set("top", 7.5) stops the program with bad argument #2 to 'set' (number has no integer representation), so round it first with math.floor. A missing strength gives bad argument #2 to 'set' (number expected, got no value).

The built-in blink program blinks a lamp, and sequencer plays a sequence on two faces.

A door with a timer. A button on the left opens the iron door on the right for 5 seconds. Pressing it again while the door is open starts the 5 seconds over. The program waits for any event: a press of the button (a redstone event) or the end of its timer (a timer event, see os.start_timer).

local OPEN_TIME = 5
local timer = nil
local was = false

while true do
  local e = os.pull_event()
  if e.name == "redstone" then
    local pressed = rs.get("left") > 0
    if pressed and not was then
      rs.set("right", true)
      timer = os.start_timer(OPEN_TIME)  -- a new timer: the old one no longer counts
    end
    was = pressed
  elseif e.name == "timer" and e.id == timer then
    rs.set("right", false)
    timer = nil
  end
end

A number on four lamps. Four faces can show a number from 0 to 15 in binary, one lamp per bit. The back holds the shaft and the front the screen, so the bits use the four other faces (the computer can sit on its bottom lamp, a Redstone Lamp is a full block). The helper turns each bit into true or false and returns the bits as text:

local lamps = {"right", "top", "left", "bottom"}  -- bits worth 1, 2, 4 and 8

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

print(show(11))
print(show(6))

1011
0110

With it, a counter that climbs from 0 to 15, one step a second:

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

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

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

See also rs.get_output() rs.get()

The strength the computer sends out of a face: the last value set there, or 0. It is the computer's own output, not what the face receives (that is rs.get).

It gives the new value as soon as rs.set returns, even before the world sees it at the end of the tick. A switch that flips the lamp on top each time it is called:

local function toggle(side)
  rs.set(side, 15 - rs.get_output(side))
end
toggle("top")

Since outputs outlive the program that set them, a program can also tidy up what an earlier one left on:

for _, side in ipairs(rs.sides()) do
  if rs.get_output(side) > 0 then
    print("switching off " .. side)
    rs.set(side, 0)
  end
end

See also rs.set() rs.get()

The list of the six face names, to go over every face in a loop.

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

Each line shows a face, the signal it receives, then the signal it sends. With a lever switched on at the left and the lamp on top lit by the computer, the screen reads:

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

The same names work with peripheral: the block touching a face is peripheral.wrap("left").

#Good to know

• Keep inputs and outputs on different faces. A face that powers a solid block can read its own signal back from that block.
• Far away? Rather than a long line of dust, use a Create Redstone Link with link: the computer transmits and receives without any block.
• Machines. A Create Clutch disconnects while powered and a Gearshift reverses, so rs.set stops or reverses a whole line. For an exact speed, drive a Rotation Speed Controller instead: kinetic.set_speed().
• More on wiring computers to redstone: Redstone and Create links.

See also rs.get() peripheral.list()