Redstone Card

local west = sys.ioctl(fd, "get", {"west"}).west.level

sys.ioctl(fd, "set", {north = {powered = 15}, up = {powered = 0}})

local event = sys.ioctl(fd, "pull")  -- {name = "redstone", side = "west", level = 9, powered = 0}

local f = io.open("/dev/redstone0", "w")
f:write("north 15\n")  -- "face strength": 0 to 15
f:close()

local f = io.open("/dev/redstone0")
local text = f:read("a")  -- one line a face: "west 9 0"
local level = tonumber(text:match("west (%d+)"))
print("west is " .. level)

-- Blink whatever is on the redstone card's north face: on half a second, off half a second, forever.
--
-- There is no event loop and nothing to yield: this is a plain loop. sys.sleep waits (the
-- computer does other work meanwhile) and the loop goes on until you stop it with Ctrl+C.
local sys = require("sys")

local FACE = "north"  -- any face: north, south, east, west, up, down (or front, back, left, right)
local HALF = 0.5      -- seconds on, and seconds off

-- A line written to the card's file is "face strength" and takes effect at once.
local card = io.open("/dev/redstone0", "w")

local function set(strength)
  card:write(FACE, " ", strength, "\n")
  card:flush()
end

while true do
  set(15)
  sys.sleep(HALF)
  set(0)
  sys.sleep(HALF)
end

-- Copy the signal coming in on the west face out of the east face, and keep doing it.
--
-- The card's file says "face level powered" for each face: the level of the signal there, and how
-- much of it is this card's own. sys.poll waits (it blocks, it does not yield) until the card
-- reports a change, so the program uses no time while nothing happens.
local sys = require("sys")

local FROM = "west"
local TO = "east"

local reader = io.open("/dev/redstone0")
local writer = io.open("/dev/redstone0", "w")
local watch = {[sys.fileno(reader)] = {PRI = true}}  -- PRI: the device's state changed

-- Read the whole file from its start, and pick out one face's level.
local function level(face)
  reader:seek("set", 0)
  return tonumber(reader:read("a"):match(face .. " (%d+)")) or 0
end

local last = -1
while true do
  local now = level(FROM)
  if now ~= last then
    writer:write(TO, " ", now, "\n")
    writer:flush()
    last = now
  end
  sys.poll(watch)  -- block until the card changes
end

-- A door that opens when a button on the west face is pressed, and closes by itself once nothing
-- has changed for a few seconds (a pressure plate or a button held keeps it open).
--
-- The door (an iron door, a piston) is on the north face. It uses the card's methods, through its
-- file's ioctls: get to read the button, set to power the door. sys.poll waits for the card to
-- change (PRI), and with a time limit for the door to stay open. A redstone file's PRI stays on
-- until the file is sought back to its start, so the program seeks after each wake.
local sys = require("sys")

local BUTTON = "west"
local DOOR = "north"
local HOLD = 3 -- seconds the door stays open after the last change

local card = assert(sys.open("/dev/redstone0"))
local watch = {[card] = {PRI = true}}

-- Waits until the card changes, or 'seconds' pass: whether it changed.
local function changed(seconds)
  local ready = sys.poll(watch, seconds)
  sys.lseek(card, 0, "set") -- (PRI again only for a newer change)
  return ready[card] ~= nil
end

local function pressed()
  return sys.ioctl(card, "get", {BUTTON})[BUTTON].level > 0
end

local function door(strength)
  sys.ioctl(card, "set", {[DOOR] = {powered = strength}})
end

door(0)
while true do
  if pressed() then
    door(15)
    while changed(HOLD) do -- (each change, the button let go too, starts the wait again)
    end
    door(0)
  end
  changed() -- wait for the next press
end

-- Count the pulses that come in on the west face (a button, a hopper clock, a daylight sensor) and
-- log how many came each minute, a line a minute: "Day 3 08:12:00 4".
--
-- It uses the card's methods, through its file's ioctls: get for a face's level now, and pull for
-- each change the card kept since the last look. The card keeps its changes (32 at most) while the
-- program sleeps, so sys.sleep is the whole wait and no pulse between looks is missed. A change it
-- had to drop shows as "lost" on the next one.
local sys = require("sys")

local FACE = "west"            -- where the pulses come in
local PERIOD = 60              -- seconds between counts
local LOG = "/home/pulses.log" -- a line a count, appended

local card = assert(sys.open("/dev/redstone0"))

-- Every change the card kept, oldest first (pull answers nil when there are none left).
local function changes()
  local list = {}
  local event = sys.ioctl(card, "pull")
  while event do
    list[#list + 1] = event
    event = sys.ioctl(card, "pull")
  end
  return list
end

changes() -- (what changed before the program started is not counted)
local was = sys.ioctl(card, "get", {FACE})[FACE].level

while true do
  sys.sleep(PERIOD)
  local pulses, lost = 0, 0
  for _, event in ipairs(changes()) do
    lost = lost + (event.lost or 0)
    if event.side == FACE then
      if event.level > 0 and was == 0 then
        pulses = pulses + 1 -- off to on: a pulse
      end
      was = event.level
    end
  end
  local log = assert(io.open(LOG, "a"))
  log:write(os.date("%c"), " ", pulses, lost > 0 and " (some changes lost)" or "", "\n")
  log:close() -- (a disk's file shows what's written when it's closed)
end