Motion Sensor

local event = sys.ioctl(fd, "pull")  -- {mob = "minecraft:pig", x = 1.5, y = 0.0, z = -3.0}

local f = io.open("/dev/motion0")
local line = f:read("l")  -- blocks until the sensor has an event
print("something moved: " .. line)

-- Sound an alarm (a redstone signal on the north face) whenever the motion sensor sees something move.
--
-- Reading a sensor's file blocks until it has an event, so the loop below is a plain while loop:
-- the program sleeps in read() until something moves, with no event.pull and no yield.
local sys = require("sys")

local ALARM = "north"
local PULSE = 1  -- seconds the alarm stays on

local motion = io.open("/dev/motion0")
local alarm = io.open("/dev/redstone0", "w")

local function set(strength)
  alarm:write(ALARM, " ", strength, "\n")
  alarm:flush()
end

while true do
  local line = motion:read("l")  -- blocks until the sensor has something to say
  local mob, x, y, z = line:match("^(%S+) (%S+) (%S+) (%S+)$")
  if mob then  -- (a line "lost n" says n events were dropped: nothing to sound for)
    print(mob .. " at " .. x .. " " .. y .. " " .. z)
    set(15)
    sys.sleep(PULSE)
    set(0)
  end
end

-- Keep a census of what walks past: a count of each kind of mob the motion sensor reports, kept in
-- a file, a line a kind ("minecraft:pig 12"), sorted by name. `cat /home/census.txt` shows it.
--
-- It reads the sensor's file, a line an event ("minecraft:pig 1.5 0.0 -3.0"): read blocks until
-- the sensor has one, so the loop never spins. A mob that keeps moving is counted each time it is
-- seen moving: this counts sightings, not mobs.
local CENSUS = "/home/census.txt"

local counts = {}
local sensor = assert(io.open("/dev/motion0"))

local function save()
  local kinds = {}
  for kind in pairs(counts) do
    kinds[#kinds + 1] = kind
  end
  table.sort(kinds)
  local out = assert(io.open(CENSUS, "w"))
  for _, kind in ipairs(kinds) do
    out:write(kind, " ", counts[kind], "\n")
  end
  out:close()
end

for line in sensor:lines() do -- (each read waits for the next event)
  local mob = line:match("^(%S+) %S+ %S+ %S+$") -- ("lost n" lines are not sightings)
  if mob then
    counts[mob] = (counts[mob] or 0) + 1
    save()
  end
end

-- A light that grows brighter the closer something moves: four times a second, the redstone card's
-- up face is set from the nearest motion the sensor saw since the last look (15 right at the block,
-- fading to 0 at the sensor's range), and goes dark when nothing moved.
--
-- It uses the sensor's method, pull, through its file's ioctls: each event is a table, its x, y and
-- z numbers, with no text to parse. The sensor keeps its events (32 at most) while the program
-- sleeps, so a look takes all that came since the last.
local sys = require("sys")

local LAMP = "up"
local RANGE = 8      -- the sensor's range, in blocks
local LOOK = 0.25    -- seconds between looks

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

-- The distance of the nearest event waiting, or nil if there are none.
local function nearest()
  local best
  local event = sys.ioctl(sensor, "pull")
  while event do
    local d = math.sqrt(event.x ^ 2 + event.y ^ 2 + event.z ^ 2)
    if not best or d < best then
      best = d
    end
    event = sys.ioctl(sensor, "pull")
  end
  return best
end

local lit = -1
while true do
  local d = nearest()
  local strength = d and math.max(0, math.floor(15 * (1 - d / RANGE) + 0.5)) or 0
  if strength ~= lit then
    sys.ioctl(card, "set", {[LAMP] = {powered = strength}})
    lit = strength
  end
  sys.sleep(LOOK)
end