#
# Ruby circuit simulation classes. This file contains a base class Gate,
# and several derived classes describing digital logic gates. There are
# also classes for input and display. There's also a flip-flop.
#
class Gate
# This is a count of the "active" gates, which are ones which have received
# a signal but not resolved it.
@@active = 0
# This is a list of gates which have registered that they want to be
# notified when the circuit is quiet. They give an integer priority,
# and are notified in increasing priority order.
@@needquiet = { }
def quiet_register(pri)
if ! @@needquiet.key?(pri) then @@needquiet[pri] = [ ] end
@@needquiet[pri].push(self)
end
# Here's how we set stuff. There are static and object versions of
# each, since I may want to activate from other spots.
def Gate.activate
@@active += 1
end
def activate
Gate.activate
end
def Gate.deactivate
@@active -= 1
if @@active == 0 then
@@needquiet.keys.sort.each \
{ |p| @@needquiet[p].each { |g| g.onquiet } }
end
end
def deactivate
Gate.deactivate
end
# This is the default quiet action (nothing).
def onquiet
end
# A signal is directed to a particular port on a particular gate. This
# encapsulates those two data. When a gate connects to us, we send back
# one of these to direct its later signal changes.
class LinkHandle
def initialize(sink_gate, sink_port)
@sinkg = sink_gate
@sinkp = sink_port
end
# The sending gate uses this method to forward the signal to the
# downstream gate.
def signal(value)
@sinkg.signal(@sinkp,value)
end
attr_reader :sinkg, :sinkp
end
def initialize(ival = false)
@inputs = [ ] # Array of inputs (boolean values)
@outputs = [ ] # Array of LinkHandle objects where to send output
@outval = ival # Present output value.
end
# This is called when a input gate sends us a signal on a particular input.
# We recompute our output value, and, if it changes, we send it on to all
# of our outbound connections.
def signal(port, val)
# The derived class needs to implement the value method.
self.activate
@inputs[port] = val
newval = self.value
if newval != @outval then
@outval = newval
@outputs.each { | c | c.signal(newval) }
end
self.deactivate
end
# Call this to connect your output to the next one of our inputs.
def connect(v)
port = @inputs.length
@inputs.push(v)
c = LinkHandle.new(self, port)
self.signal(port, v)
return c
end
# Join me to another gate.
def join(g)
@outputs.push(g.connect(@outval))
end
def joinmany(*p)
p.each { |i| self.join(i); }
end
attr_reader :outval
# Some printing help
def name
return self.class.to_s
end
def insstr
return (if @inputs.length == 0 then "-" else @inputs.join('.') end)
end
def to_s
return name + " " + insstr + " => " + @outval.to_s
end
# Create another object of the same type.
def another
return self.class.new
end
def manyothers(n)
ret = []
n.times { ret.push(self.another) }
return ret
end
# This manufactures any number of objects. It is a static method, and
# inherited by the real gates. The expression self.new, then, runs the
# new method on the actual object, which the inheriting class. Therefore,
# it will create any gate.
def Gate.many(n)
ret = [ ]
n.times { ret.push(self.new) }
return ret
end
# Dump a whole circuit. Yecch.
def outlinks
return @outputs
end
def Gate.dump(*roots)
ct = -1
gatemap = { }
for g in roots
gatemap[g] = (ct += 1) unless gatemap.has_key?(g)
end
printed = { }
while roots.length > 0
g = roots.shift
next if printed.has_key?(g)
print "[", gatemap[g], "] ", g, ":"
for c in g.outlinks
og = c.sinkg
gatemap[og] = (ct += 1) unless gatemap.has_key?(og)
print " ", gatemap[og], "@", c.sinkp
roots.push(og)
end
print " [none]" if g.outlinks.length <= 0
print "\n"
printed[g] = true
end
end
end
# Standard and gate
class AndGate < Gate
def initialize
super(true)
end
def value
for i in @inputs
return false if !i
end
return true
end
end
class NandGate < AndGate
def value
return ! super
end
end
# Standard or gate
class OrGate < Gate
def value
for i in @inputs
return true if i
end
return false
end
end
class NorGate < OrGate
def value
return ! super
end
end
# Standard xor gate
class XorGate < Gate
def value
ret = false
for i in @inputs
ret ^= i
end
return ret
end
end
# Gates with a limited number of input connections.
class LimitedGate < Gate
def initialize(max=1,i=false)
super(i)
@max = max
end
# Enforce connect limit.
def connect(v)
if @inputs.length >= @max then
raise TypeError.new("Too many input connections.")
end
super(v)
end
end
# Not gate.
class NotGate < LimitedGate
def initialize
super(1,true)
end
def value
return ! @inputs[0]
end
end
# This is a "yes gate" or amplifier. It just forwards its input to all its
# outputs
class Connector < LimitedGate
def value
return @inputs[0]
end
# We can also use it as a one-bit input device.
def send(v)
self.signal(0,v)
end
end
# D Flip-Flop. Level-triggered. First input is D, second is clock.
class FlipFlop < LimitedGate
def initialize
super(2)
end
def value
return (if @inputs[1] then @inputs[0] else @outval end)
end
end
# D Flip-Flop. Edge-triggered. First input is D, second is clock.
# I think the level-triggered might make a lot more sense with this
# simulation, though these are better in circuits.
class FlipFlopET < FlipFlop
def initialize
super
@newval = false
end
def value
return @newval
end
def signal(port, val)
# Need to stick our fingers in this thing to find the rising edge.
self.activate
@newval =
if port == 1 && !@inputs[1] && val then @inputs[0] else @outval end
super(port,val)
self.deactivate
end
end
# Simple test point
class Tester < LimitedGate
def initialize(name="Tester")
super(1)
@name = name
end
attr_writer :name
def value
print @name, ": ", if @inputs[0] then "on" else "off" end, "\n";
return @inputs[0]
end
end
# Numeric output device. Connect lines starting with LSB.
class NumberOut < Gate
@@quiet = false
def NumberOut.shush(q=true)
@@quiet = q
end
def initialize(name="Value", pri = 1)
@name = name
quiet_register(pri)
super()
end
attr_writer :name
# Print the value on quiet.
def onquiet
return if @@quiet;
val = 0
@inputs.reverse_each { |i|
val <<= 1
if i then
val |= 1
end
}
print @name, ": ", val, "\n"
end
def value
return false
end
end
# LED which prints when circuit becomes quiet.
class LED < NumberOut
def initialize(name="LED", pri = 1)
super(name, pri)
end
def onquiet
if @inputs.length > 0 && ! @@quiet then
print @name, ": ", if @inputs[0] then "on" else "off" end, "\n"
end
end
def connect(v)
if @inputs.length >= 1 then
raise TypeError.new("Too many input connections.")
end
super(v)
end
end
# Base for input devices. Mostly deals will collecting connections.
class InputDevice
def initialize
@targs = []
end
# Add a connection
def join(g)
@targs.push(g.connect(false))
end
def joinmany(*p)
p.each { |i| self.join(i); }
end
def outlinks
return @targs
end
end
# Switch bank. Connects to any number of gates, and will feed them a
# binary number (as a string). Connections start with LSB. Initially,
# all the switches are off.
class SwitchBank < InputDevice
# Send a number. Can take an integer or a string.
def set(n)
if n.is_a?(TrueClass) || n.is_a?(FalseClass) then
@targs.each { | x | x.signal(n) }
elsif n.is_a?(Integer) then
@targs.each { | x | x.signal(n&1 == 1); n >>= 1 }
else
# Assume n is an ascii string of 1's and 0's.
if n.length < @targs.length then
n = ('0' * (@targs.length - n.length)) + n
end
sub = n.length - 1
@targs.each { | x | x.signal(n[sub].chr != "0"); sub -= 1 }
end
end
# This is like switch, but it keeps the circuit active during each
# sending.
def value=(n)
Gate.activate
self.set(n)
Gate.deactivate
end
end
# Send a pulse (clock tick?)
class Pulser < InputDevice
def pulse
Gate.activate
@targs.each { |t| t.signal(true); }
@targs.each { |t| t.signal(false); }
Gate.deactivate
end
end
Ruby Example Code
Setting Variables