def plant(T, initD):
gain = sm.Gain(T)
delay_x = sm.R(0)
delay_y = sm.FeedbackAdd(sm.Gain(1), sm.R(initD))
return sm.Cascade(sm.Cascade(gain, delay_x), delay_y)
def wallFinderSystem(T, initD, k):
controller_v = controller(k)
plant_v = plant(T, initD)
sensor_v = sensor(initD)
return sm.Cascade(
sm.Gain(-1), sm.FeedbackAdd(sm.Cascade(controller_v, plant_v),
sensor_v))
def setup():
mapper = mapMaker.MapMaker(xMin, xMax, yMin, yMax, gridSquareSize)
replannerSM = replanner.ReplannerWithDynamicMap(goalPoint)
robot.behavior = \
sm.Cascade(sm.Parallel(sm.Cascade(sm.Parallel(mapper, sm.Wire()),
replannerSM),
sm.Wire()),
move.MoveToDynamicPoint())
def __init__(self):
self.sm1 = BA1
self.sm1_inst = BA1()
self.sm2 = BA2
self.sm2_inst = BA2()
self.ba1 = PureFunction(self.sm1_inst.getNextValues)
self.ba2 = PureFunction(self.sm2_inst.getNextValues)
self.double_bank = sm.Cascade(sm.Parallel2(self.ba1, self.ba2),
Adder())
self.startState = (0, 0)
def accumulatorDelay(init):
"""
Args:
init (int): the output at time 0
Returns:
y: a state machine whose output at time n is the sum of its inputs up to
and including time n-1
"""
xDelay = sm.Delay(0)
y = sm.Cascade(xDelay, accumulator(init))
return y
def wallFinderSystem(t, initD, k):
"""
Returns a state machine whose input is the desired distance from the wall
and whose output is the actual distance from the wall.
Args:
t - the duration of a time step
initD - the starting distance from the wall
k - Scalar for velocity of movement
"""
return sm.FeedbackAdd(sm.Cascade(controller(k), plant(t, initD)),
sensor(initD))
def accumulatorDelayScaled(s, init):
"""
Args:
s (int): the scale factor
init (int): the output at time 0
Returns:
y: a state machine whose output at time n is the sum of the scaled
inputs (each scaled by s) up to and including time n-1
"""
xScale = sm.Gain(s)
y = sm.Cascade(xScale, accumulatorDelay(init))
return y
def accumulatorDelay(init):
"""
Returns a state machine such that y[n] = y[n-1] + x[n-1] witgh a starting state of init.
"""
return sm.Cascade(accumulator(init), sm.R(init))
v = sonarDist.getDistanceRight(inp.sonars)
print 'Dist from robot center to wall on right', v
return (state, v)
# inp is the distance to the right
class WallFollower(sm.SM):
startState = None
def getNextValues(self, state, inp):
################
# Your code here
################
sensorMachine = Sensor()
sensorMachine.name = 'sensor'
mySM = sm.Cascade(sensorMachine, WallFollower())
######################################################################
#
# Running the robot
#
######################################################################
def setup():
robot.gfx = gfx.RobotGraphics(drawSlimeTrail=False)
robot.gfx.addStaticPlotSMProbe(y=('rightDistance', 'sensor',
'output', lambda x:x))
robot.behavior = mySM
robot.behavior.start(traceTasks = robot.gfx.tasks())
def step():
def accumulatorDelayScaled(s, init):
x_scale = sm.Gain(s)
return sm.Cascade(x_scale, accumulatorDelay(init))
def accumulatorDelayScaled(s, init):
"""
Returns a state machine such that y[n] = y[n-1] + sx[n-1].
"""
return sm.Cascade(accumulatorDelay(init), sm.Gain(s))
import lib601.sm as sm
def neg(inp):
return not(inp)
negate = sm.PureFunction(neg)
alternating = sm.Feedback(sm.Cascade(negate, sm.Delay(True)))
print alternating.transduce([1,2,3,True,False])
def accumulatorDelay(init):
x_delay = sm.R(0)
return sm.Cascade(x_delay, accumulator(init))
def makeCounter(init, step):
return sm.Feedback(sm.Cascade(Increment(step), Delay(init)))
################
# Input is SensorInput instance; output is a delayed front sonar reading
class Sensor(sm.SM):
def __init__(self, initDist, numDelays):
self.startState = [initDist] * numDelays
def getNextValues(self, state, inp):
print inp.sonars[3]
output = state[-1]
state = [inp.sonars[3]] + state[:-1]
return (state, output)
mySM = sm.Cascade(Sensor(1.5, 1), Controller())
mySM.name = 'brainSM'
######################################################################
###
### Brain methods
###
######################################################################
def plotSonar(sonarNum):
robot.gfx.addStaticPlotFunction(
y=('sonar' + str(sonarNum), lambda: io.SensorInput().sonars[sonarNum]))
def setup():
reload(ffSkeleton)
from secretMessage import secret
# Set to True for verbose output on every step
verbose = False
# Rotated square points
squarePoints = [util.Point(0.5, 0.5), util.Point(0.0, 1.0),
util.Point(-0.5, 0.5), util.Point(0.0, 0.0)]
goal_generator = ffSkeleton.FollowFigure(secret)
# goal_generator = sm.Constant(util.Point(1.0, 0.5))
dynamic_move_machine = dynamicMoveToPointSkeleton.DynamicMoveToPoint()
# Put your answer to step 1 here
mySM = sm.Cascade(sm.Parallel(goal_generator, sm.Wire()), dynamic_move_machine)
######################################################################
###
### Brain methods
###
######################################################################
def setup():
robot.gfx = gfx.RobotGraphics(drawSlimeTrail = True)
robot.behavior = mySM
def brainStart():
robot.behavior.start(traceTasks = robot.gfx.tasks(),
verbose = verbose)
self.f = f def getNextValues(self,state,inp): return (state,self.f(inp)) # Part 1: Maximize # Make a state machine that computes the balances of both types of accounts # and outputs the maximum of the two balances # The input is a number # Start by constructing a state machine whose input is a number and whose # output is a tuple with two balances: # Then combine this machine with sm.PureFunction a1 = BA1() a2 = BA2() maxAccount = sm.Cascade(sm.Parallel(a1,a2),sm.PureFunction(max)) # maxAccount.transduce([1000,1500,2000,500],verbose = True) # Part 2: Investment # I put any deposit or withdrawal whose magnitude is > 3000 in the account1 # and all others in the account of type 2. On every step both bank accounts # should continue to earn relevant interest. The output should be the sum # of the balances in the two accounts. Implement this by composing the two # bank accoutns using sm.Parallel2 and cascading it with two simple machines # you implement using sm.PureFunction class Switcher(sm.SM): startState = None def getNextValues(self,state,inp): if abs(inp) > 3000:
def wallFinderSystem(T, initD, k):
return sm.FeedbackSubtract(sm.Cascade(controller(k), plant(T, initD)),
sensor(initD))
if inp != 0:
newState += inp - 100
return (newState, newState)
class BA2(sm.SM):
startState = 0
def getNextValues(self, state, inp):
newState = state * 1.01 + inp
return (newState, newState)
bank_one = BA1()
bank_two = BA2()
combined_bank = sm.Cascade(sm.Parallel(bank_one, bank_two), PureFunction(max))
def is_large_transaction(amount):
return abs(amount) > 3000
def add(args):
return args[0] + args[1]
class SwitchMachine(sm.SM):
startState = None
def getNextValues(self, state, inp):
if is_large_transaction(inp):
class Increment(sm.SM):
startState = 0
def __init__(self, incr):
self.incr = incr
def getNextValues(self, state, inp):
return (state, inp + self.incr)
# Fill in the behavior tables
# Note: list indexes correspond to times, e.g. list[1] -> list at t=1
# 1.
sm1 = Delay(1)
sm2 = Delay(2)
c = sm.Cascade(sm1, sm2)
c.transduce([3, 5, 7, 9])
# cascade means we take the output of the first sm as the input
# for the second
sm1input = [3, 5, 7, 9]
sm1state = [1, 3, 5, 7, 9]
sm1output = [1, 3, 5, 7]
sm2input = [1, 3, 5, 7]
sm2state = [2, 1, 3, 5, 7]
sm2output = [2, 1, 3, 5]
# 2.
sm1 = Delay(1)
sm2 = Increment(3)
c = sm.Cascade(sm1, sm2)
def accumulatorDelayScaled(init, s):
return sm.Cascade(sm.FeedbackAdd(sm.R(init), sm.Gain(1.0)), sm.Gain(s))
if inp != 0:
return state * 1.02 + inp - 100
else:
return state * 1.02
class BA2(sm.SM):
startState = 0
def getNextState(self, state, inp):
return state * 1.01 + inp
ba1 = BA1()
ba2 = BA2()
maxAccount = sm.Cascade(sm.Parallel(ba1, ba2), sm.PureFunction(max))
print ba1.transduce([0, 100, 10000, -300])
print ba2.transduce([0, 100, 10000, -300])
print maxAccount.transduce([0, 100, 10000, -300])
def switchInput(inp):
if inp > 3000 or inp < -3000:
return (inp, 0)
else:
return (0, inp)
switchAccount = sm.Cascade(
sm.Cascade(sm.PureFunction(switchInput), sm.Parallel2(ba1, ba2)),
def plant(T, initD):
return sm.Cascade(sm.Gain(-T), sm.FeedbackAdd(sm.R(initD), sm.Wire()))
forwardVelocity = 0.1
# No additional delay
class Sensor(sm.SM):
def getNextValues(self, state, inp):
return (state, sonarDist.getDistanceRight(inp.sonars))
# inp is the distance to the right
class WallFollower(sm.SM):
def getNextValues(self, state, inp):
################
# Your code here
################
mySM = sm.Cascade(Sensor(), WallFollower())
######################################################################
#
# Running the robot
#
######################################################################
def plotDist():
func = lambda: sonarDist.getDistanceRight(io.SensorInput().sonars)
robot.gfx.addStaticPlotFunction(y=('d_o', func))
def setup():
robot.gfx = gfx.RobotGraphics(drawSlimeTrail=False)
plotDist()
robot.behavior = mySM
class Increment(sm.SM):
startState = 0
def __init__(self, incr):
self.incr = incr
def getNextValues(self, state, inp):
# print(type(inp))
# print type(self.incr)
if isinstance(inp, type(2)):
return (state, inp + self.incr) # need safe add
else:
return (state, self.incr)
sm1 = Delay(1)
sm2 = Delay(2)
c = sm.Cascade(sm1, sm2)
print c.transduce([3,5,7,9])
sm1 = Delay(1)
sm2 = Increment(3)
c = sm.Cascade(sm1, sm2)
print c.transduce([3,5,7,9])
'''3-1-2'''
class Cascade(sm.SM):
def __init__(self, sm1, sm2):
self.startState = (sm1.startState, sm2.startState)
self.sm1 = sm1
self.sm2 = sm2
def getNextValues(self, state, inp):
import lib601.sm as sm # Define negate to be an instance of sm.PureFunction that takes a boolean # and returns the negation of it def negFunct(boolean): return not boolean class PureFunction(sm.SM): def __init__(self, f): self.f = f def getNextValues(self,state,inp): return (state,self.f(inp)) negate = sm.PureFunction(negFunct) # negate.transduce([True,False],verbose = True) # Use sm.Feedback,sm.Cascade, and negate to construct an instance whose output alternates # between True and False for any input sequence; starting with true. alternating = sm.Feedback(sm.Cascade(sm.Delay(False),negate)) alternating.transduce([1,True,False,True,False,True,False],verbose = True) # Not totally sure how I made this work, but hey it does.
