Traffic Light

The Traffic Light is a road signal with three lamps, red on top, amber in the middle and green at the bottom, like the first electric signals of the 1910s. On its own it follows redstone. Once a computer sets it, it shows whatever your program asks for, and redstone no longer moves it until the program hands it back.

local light = peripheral.wrap("left")
light.set("green")

#Setting up

Placing it. The lamps face you when you place the block, so stand where the drivers will come from. A Create Wrench turns it afterwards.

On its own, it follows redstone. The strongest signal it receives chooses the aspect. A redstone clock, a comparator or a Create Redstone Link can run a crossing without any computer:

Reaching it from a computer. Put the light against any face of the computer and name it by that face: peripheral.wrap("left"). On a Minicomputer or a newer computer, it can also touch a Data Cable of the computer's network: it is then named after its coordinates, like traffic_light@120,64,-35. And peripheral.find("traffic_light") takes the first light it finds (the faces first) without any name. Every computer can drive it, the Tube Computer included. See Peripherals and Every device.

#Control

local light = peripheral.wrap("left")
light.set("red")
sleep(10)
light.set("red_amber")
sleep(2)
light.set("green")

local light = peripheral.find("traffic_light")
if light.get() == "red" then
  rs.set("top", true)  -- lowers the barrier of the level crossing
end

local light = peripheral.wrap("left")
light.set("green")   -- the fire engine goes through
sleep(15)
light.release()      -- the redstone timer takes over again
print(light.get())

#Examples

#A full light cycle

The classic sequence, as in Britain or Germany: green, amber, red, then red and amber together just before green. Save it as startup so the crossing starts again by itself when the chunk loads.

local light = peripheral.wrap("left")
if light == nil then
  error("no traffic light on the left")
end
while true do
  light.set("green")
  sleep(20)
  light.set("amber")
  sleep(3)
  light.set("red")
  sleep(20)
  light.set("red_amber")
  sleep(2)
end

A real crossroads has two lights that must never be green together: the Smart intersection recipe drives them from one computer. The built-in traffic program waits for a car on an Inductive Loop Detector before it turns red.

#A pedestrian crossing

The road stays green until someone presses the button. One light faces the road, a second one faces the crossing (green means walk), and a stone button sits on the front of the computer.

local cars = peripheral.wrap("left")
local walkers = peripheral.wrap("right")
cars.set("green")
walkers.set("red")
while true do
  os.pull_event("redstone")
  if rs.get("front") > 0 then
    sleep(3)                 -- the cars cannot stop at once
    cars.set("amber")
    sleep(3)
    cars.set("red")
    sleep(1)
    walkers.set("green")
    sleep(10)
    walkers.set("flashing")  -- hurry up
    sleep(4)
    walkers.set("red")
    sleep(1)
    cars.set("red_amber")
    sleep(2)
    cars.set("green")
  end
end

os.pull_event("redstone") sleeps until a redstone input of the computer changes, so the program costs nothing while nobody comes. The check rs.get("front") > 0 keeps only a button pressed right now: the event of the button popping back out starts nothing, and neither does an older press made while people were crossing (a stone button stays in for one second).