EECS 20 Lecture 11 (February 9, 2001) Tom Henzinger Feedback.

Slides:



Advertisements
Similar presentations
ENGIN112 L23: Finite State Machine Design Procedure October 27, 2003 ENGIN 112 Intro to Electrical and Computer Engineering Lecture 23 Finite State Machine.
Advertisements

Sequential Logic Circuits. Set-Reset Latch The Set-Reset latch or bistable is a simple sequential logic circuit that remembers what has happened to the.
Lecture 20 Finite State Machines CSCI – 1900 Mathematics for Computer Science Fall 2014 Bill Pine.
Finite State Machines (FSMs)
X=0 x
EECS 20 Lecture 14 (February 16, 2001) Tom Henzinger Nondeterminism.
EECS 20 Lecture 38 (April 27, 2001) Tom Henzinger Review.
EECS 20 Lecture 15 (February 21, 2001) Tom Henzinger Simulation.
CS 140 Lecture 7 Professor CK Cheng 4/23/02. Part II. Sequential Network (Ch ) 1.Flip-flops SR, D, T, JK, 2.SpecificationState Table 3.Implementation.
EECS 20 Lecture 13 (February 14, 2001) Tom Henzinger Minimization.
EECS 20 Lecture 16 (February 26, 2001) Tom Henzinger Determinization.
EECS 20 Lecture 8 (February 2, 2001) Tom Henzinger State Machines.
EECS 20 Lecture 9 (February 5, 2001) Tom Henzinger Transition Diagrams.
EECS 20 Lecture 3 (January 22, 2001) Tom Henzinger Sets, Tuples, Functions.
EECS 20 Lecture 6 (January 29, 2001) Tom Henzinger Transducive Systems.
Give qualifications of instructors: DAP
Contemporary Logic Design Finite State Machine Design © R.H. Katz Transparency No Chapter #8: Finite State Machine Design Finite State.
11/10/2004EE 42 fall 2004 lecture 301 Lecture #30 Finite State Machines Last lecture: –CMOS fabrication –Clocked and latched circuits This lecture: –Finite.
EECS 20 Lecture 7 (January 31, 2001) Tom Henzinger Reactive Systems.
EECS 20 Lecture 2 (January 19, 2001) Tom Henzinger Mathematical Language.
EECS 20 Lecture 4 (January 24, 2001) Tom Henzinger Block Diagrams.
EECS 20 Lecture 36 (April 23, 2001) Tom Henzinger Safety Control.
EECS 20 Lecture 10 (February 7, 2001) Tom Henzinger Product Machines.
EECS 20 Lecture 12 (February 12, 2001) Tom Henzinger Equivalence.
Lecture 17 General finite state machine (FSM) design
Finite State Machines – Page 1CSCI 1900 – Discrete Structures CSCI 1900 Discrete Structures Graphs and Finite State Machines Reading: Kolman, Sections.
1 KU College of Engineering Elec 204: Digital Systems Design Lecture 17 Design a clock synchronous sequential circuit with two inputs A, B and a single.
Objective 2.01 Test Review Name: Class Period:.
Elevator Controller We’re hired to design a digital elevator controller for a four-floor building st try: Design a counter that counts up.
FINITE STATE MACHINES - II
Finite-State Machines with Output
ECE2030 Introduction to Computer Engineering Lecture 16: Finite State Machines Prof. Hsien-Hsin Sean Lee School of Electrical and Computer Engineering.
An ordered n-tuple is a set of n objects with an order associated with them. If n objects are represented by x 1, x 2,..., x n, then we write the ordered.
Money By: Rachel Morello Teacher Page Click here!
Lecture 18 More Moore/Mealy machines.
1 Lecture 22 State encoding  One-hot encoding  Output encoding State partitioning.
1 CSE370, Lecture 19 Lecture 19 u Logistics n Lab 8 this week to be done in pairs íFind a partner before your lab period íOtherwise you will have to wait.
Counting Coins. The Basics Quarter 25 cents Dime 10 cents.
Let’s Learn About Money!
Name the United States Coins Count the Pennies 10 ¢
Coin Problems.
1 CSE370, Lecture 18 Lecture 20 u Logistics n HW6 due Wednesday n Lab 7 this week (Tuesday exception) n Midterm 2 Friday (covers material up to simple.
Lecture 5. Sequential Logic 2 Prof. Taeweon Suh Computer Science Education Korea University 2010 R&E Computer System Education & Research.
DLD Lecture 26 Finite State Machine Design Procedure.
© 2009 Pearson Education, Upper Saddle River, NJ All Rights ReservedFloyd, Digital Fundamentals, 10 th ed Digital Logic Design Dr. Oliver Faust.

CEC 220 Digital Circuit Design Sequence Detector Design Wednesday, April 01 CEC 220 Digital Circuit Design Slide 1 of 11.
1 State machine by nature are ideally suited to track state and detect specific sequence of events For example, we may design specific machines to track.
1 (c) W. J. Dally Digital Design: A Systems Approach Lecture 7: Data Path State Machines.
Test 2 Fall 2007 Post Mortem Topics Sequential Circuits November 20, 2007 CSCE 211 Digital Design.
Sequential Networks and Finite State Machines
Lecture 4. Sequential Logic #2
Sequential Networks and Finite State Machines
Factors, multiple, primes: Factors from prime factors
Motivation EECS 20 Lecture 1 (January 17, 2001) Tom Henzinger.
Name the United States Coins
Finite State Machines.
Lecture 8: Verilog Examples
State Machines EECS 20 Lecture 8 (February 2, 2001) Tom Henzinger.
CSE 370 – Winter Sequential Logic-2 - 1
Lecture 5 Binary Operation Boolean Logic. Binary Operations Addition Subtraction Multiplication Division.
Lecture 20 Logistics Last lecture Today HW6 due Wednesday
Warm-up: True/False Dry Run DIV / MOD 2nd If Then Program
CSE 140 Lecture 9 Sequential Networks
Lecture 22 Logistics Last lecture Today HW7 is due on Friday
Lecture 22 Logistics Last lecture Today HW7 is due on Friday
Factors, multiple, primes: Multiples
 Is a machine that is able to take information (input), do some work on (process), and to make new information (output) COMPUTER.
Mathematical Language
Digital System Design ASMD based Design
Presentation transcript:

EECS 20 Lecture 11 (February 9, 2001) Tom Henzinger Feedback

Parity LastThree Nats 0  Bools path without delay

The Parity System : States [ Parity] = { true, false } initialState [ Parity ] = true nextState [ Parity ] (q,x) = (q  x) output [ Parity ] (q,x) = q The LastThree System : States [ LastThree] = { 0, 1, 2 } initialState [ LastThree ] = 0 nextState [ LastThree ] (q,x) = output [ LastThree ] (q,x) = ( ( q = 2 )  x ) 0 if  x min (q+1, 2) if x {

Parity System truefalse true / true true / false false / true false / false States = Bools Inputs = Bools Outputs = Bools

LastThree System States = { 0, 1, 2 } Inputs = Bools Outputs = Bools 0 21 true / false false / false true / true true / false

A Run of the LastThree System Time Input t t t t f Output State

A Run of the LastThree System Time Input t t t t f Output State 0

A Run of the LastThree System Time Input t t t t f Output f State 0 1

A Run of the LastThree System Time Input t t t t f Output f f State 0 1 2

A Run of the LastThree System Time Input t t t t f Output f f t State

A Run of the LastThree System Time Input t t t t f Output f f t t State

A Run of the LastThree System Time Input t t t t f Output f f t t f State

Parity LastThree FeedbackLoop Nats 0  Bools  This block diagram is ok, because every cycle contains a delay.

Parity LastThree FeedbackLoop Nats 0  Bools  x y z u q1 q2

Parity LastThree FeedbackLoop Nats 0  Bools  x y z u q1 q2

A Run of the FeedbackLoop System Time Input x t t f t f Output y Aux z Aux u State q1 State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y Aux z Aux u State q1 t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t Aux z Aux u State q1 t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t Aux z f Aux u State q1 t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t Aux z f Aux u f State q1 t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t Aux z f Aux u f State q1 t t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t t Aux z f Aux u f State q1 t t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t t Aux z f f Aux u f State q1 t t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t t Aux z f f Aux u f f State q1 t t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t t Aux z f f Aux u f f State q1 t t t State q

A Run of the FeedbackLoop System Time Input x t t f t f Output y t t t t f Aux z f f t t f Aux u f f f t f State q1 t t t t f f State q

The FeedbackLoop System Inputs [ FeedbackLoop ] = Bools Outputs [ FeedbackLoop ] = Bools States [ FeedbackLoop ] = States [ Parity ]  States [ LastThree ] = { true, false }  { 0, 1, 2 } initialState [ FeedbackLoop ] = ( initialState [ Parity ], initialState [ LastThree ] ) = ( true, 0 )

The FeedbackLoop System, continued output [ FeedbackLoop ] ( ( q1, q2 ), x ) = output [ Parity] ( q1, any ) The value of this does not matter !

The FeedbackLoop System, continued output [ FeedbackLoop ] ( ( q1, q2 ), x ) = output [ Parity] ( q1, any ) Let this be y. nextState [ FeedbackLoop ] ( ( q1, q2 ), x ) 2 = nextState [ LastThree ] ( q2, y )

The FeedbackLoop System, continued output [ FeedbackLoop ] ( ( q1, q2 ), x ) = output [ Parity] ( q1, any ) Let this be y. nextState [ FeedbackLoop ] ( ( q1, q2 ), x ) 2 = nextState [ LastThree ] ( q2, y ) Let z = output [ LastThree ] ( q2, y ).

The FeedbackLoop System, continued output [ FeedbackLoop ] ( ( q1, q2 ), x ) = output [ Parity] ( q1, any ) Let this be y. nextState [ FeedbackLoop ] ( ( q1, q2 ), x ) 2 = nextState [ LastThree ] ( q2, y ) Let z = output [ LastThree ] ( q2, y ). nextState [ FeedbackLoop ] ( ( q1, q2 ), x ) 1 = nextState [ Parity ] ( q1, x  z )

If every cycle contains a delay, then all values can be computed. If there is a cycle without delay, then some values may not be well-defined.

An Ill-Defined System   Nats 0  Bools

An Ill-Defined System   Nats 0  Bools f f X

An Ill-Defined System   Nats 0  Bools f t X No legal output !

Another Ill-Defined System  id Nats 0  Bools

Another Ill-Defined System  id Nats 0  Bools f t

Another Ill-Defined System  id Nats 0  Bools f f Multiple legal outputs !

Example: Vending Machine

Coin Collector Collect Nats 0  {0, … 30 } Nats 0  Coins  1 2 Nats 0  Bools 1 2 reset funds Let Coins = { Nickel, Dime, Quarter }. cin cthru

Coin Collector (D,f)/(15,  ) ( ,f)/(15,  ) (N,f)/ (15,  ) ( ,t)/(15,  ) (Q,f)/(15,Q) (Q,t)/(15,  ) (N,t)/(15,  ) (D,t)/ (15,  )

Coin Collector Collect Nats 0  {0, … 30 } Nats 0  Coins  1 2 Nats 0  Bools 1 2 reset fundscin cthru

Soda Dispenser Disp Nats 0  Dispense  Nats 0  Select  Nats 0  Bools 1 2 Nats 0  { 0, … 30 } 1 2 funds reset 3 Nats 0  Coins  change select soda Let Select = { selectCoke, selectDiet }. Let Dispense = { dispenseCoke, dispenseDiet }.

Soda Dispenser none Diet Coke {(C,x)|x<25} / ( ,f,  ) (C,25) / (C,t,  ) (C,30) / (C,t,N) (D,20) / (D,t,  ) (D,25) / (D,t,N) (D,30) / (D,t,D) {(C,x)|x<20} / ( ,f,  ) {( ,x)|x  0} / ( ,f,  )

Soda Dispenser none Diet Coke {(C,x)|x<25} / ( ,f,  ) {( ,x)|x<25} / ( ,f,  ) {(D,x)|x<20} / ( ,f,  ) ( ,25) / (C,t,  ) ( ,30) / (C,t,N) (C,25) / (C,t,  ) (C,30) / (C,t,N) (D,20) / (D,t,  ) (D,25) / (D,t,N) (D,30) / (D,t,D)

Soda Dispenser Disp Nats 0  Dispense  Nats 0  Select  Nats 0  Bools 1 2 Nats 0  { 0, … 30 } Nats 0  Coins  funds reset change select soda

Vending Machine Disp Nats 0  Dispense  Nats 0  Select  Nats 0  Bools 1 3 Nats 0  { 0, … 30 } Nats 0  Coins  Collect Nats 0  Coins  resetfunds select soda change cin cthru

Vending Machine DispC Nats 0  Dispense  Nats 0  Select  Nats 0  Bools 1 3 Nats 0  { 0, … 30 } Nats 0  Coins  Collect Nats 0  Coins  resetfunds select soda change cin cthru

Time cin N  Q Q D select  C  D C funds soda change reset cthru State Coll 0 State Disp n

Time cin N  Q Q D select  C  D C funds soda   C D  change   N N  reset f f t t f cthru      State Coll State Disp n n C n n C

Quiz 1. Draw the transition diagram of the system Delay 0 : [ Nats 0  Bins ]  [ Nats 0  Bins ]  x  [ Nats 0  Bins ],  y  Nats 0, ( Delay 0 (x)) (y) = 2. Draw the transition diagram of the system 0 if y = 0 x (y-1) if y > 0 { Delay 0