Document Sample

Chapter D Finite State Machines D1 The Notion of a State Finite state machines (FSMs) provide us with a very useful way of understanding systems which change at discrete events in time. The system could be a robot navigating through some obstacles, the behaviour of a cat or the functioning of a vending machine. Even speech recognition can be described as a FSM, or the machine translation (“parsing”) of Java source code to ultimately produce a running program. Also FSMs are fundamental in understanding what “computation” actually is from a theoretical perspective, more on this in Chapter ?? For the moment we shall consider a number of examples of FSMs, how they can be represented all the way from high- level symbolic diagrams to the lowest level of digital electronics. And we shall also see how biological systems implement FSMs. Let’s start by considering the states of Tom cat, a few of which are shown in Fig.1 . Figure 1. Here’s some pictures of Tom existing in a number of states, each with its own particular “activity” (output or response). There is hunting, hiding, sleeping and scratching. These are of course behavioural states, walking, sleeping, burying, hiding, grooming. Catch Tom in the garden and you’ll certainly find him in one of these states. But he does not stay in a single state for very long; he may be grooming until a mouse comes along. Tom will then make a transition into a new state, probably hunting, jumping or just plain being silly. The transition is caused by Tom receiving the input stimulus of catching sight of the mouse. The new state has an associated output or response, the actions associated with hunting. If we observed Tom for a significant period of time, we may well discover that we could describe his entire total behaviour as a collection of a limited (finite) number of states. We represent a state as a circle containing a label and the output behaviour of Tom associated with the state. Each state is linked to another state by one or more transition arrows, and each arrow would be labelled by an stimulus which would cause that transition between the states (see Fig.2). Moving from one state to another would only occur on receipt of the particular stimulus without debate or probability. The system is mechanical. Moreover, once the system is constructed it is complete in that Tom can never exist in a state we have not included in the diagram. But if we did find a new state in our analysis of Tom’s days, then of course we could extend his FSM. See dog S2 Hear noise hiding See dog S1 hunting See mouse See mouse See dog S5 playing S4 S3 cleaning wandering Feel bored See friend Feel an itch I’m tired Hear noise S7 scratching S6 sleeping Feel an itch Figure 2. An analysis of the life of a living Tom cat into states each with their associated behavioural activity, (“output” or response). Transitions between Tom’s states are shown by arrows labelled with the stimulus producing the transition. Each oval represents a state of behaviour: It is labelled with a state name and also the response output by each state Tom, represented by a Finite State Machine, lives in an environment. This is important, since this environment provides the stimuli inputs to the FSM and also is the arena in which the response behaviour is actioned. It is clear that this model is general: A soft-drink dispenser modelled as an FSM exists in an environment of customers, a robot-controller FSM exists within an environment of obstacles, a speech-recognition FSM exists within an environment of input spoken words. So we suggest that a natural system can be analysed into and FSM and an environment, and that the states and transitions of the FSM together with stimuli and responses, may be used to visualize, simulate and therefore understand its properties. Whether or not this is successful depends on the accuracy of our analysis. On the other hand the engineer, who has the freedom to construct a system (such as a soft- drink dispenser) from scratch, will be able to construct a perfect FSM to solve a particular problem. D2. The Definition of a State Machine The basic concept of an FSM is shown in Fig.3. The FSM is presented as a “black- box” (that’s the square which hides the details of the exact operation), situated within. The FSM is situated in an “environment” from which it receives input. stimuli (S) and to which it provides outputs or responses (R). The FSM consists of a number of states, labelled Q1,Q2,… Each state can be configured to receive one or more stimuli. On receipt of a particular stimulus the FSM can change state, e.g., from Q1 to Q2. Upon that transition into Q2, the output of the FSM becomes R2, associated with Q2. This replaces the previous output R1, associated with the previous state Q1. So as time unfolds, the FSM jumps between states with associated outputs, driven by input stimuli. FSM (a) Basic structure of a FSM. The Q2 square box contains the FSM Q1 which exists in a number of states S R Q1,Q2,Q3. The FSM is situated Q3 within an environment which provides input stimuli (S) to the FSM and which accepts the FSM’s output or response (R). Environment FSM Q1 S R Q2 (b) All states are able to receive the input stimuli, the response Q3 comes from the output of only one state, here Q1. FSM Q1 S R Q2 (c) Here an input stimulus has caused the FSM to change state from Q1 to Q2, whereupon the Q3 FSM outputs the response R from Q2 Figure 3. Structure and operation of a FSM. Think of the FSM as a “black box” which lives in an environment receiving input stimuli and emitting an output response The description is “deterministic”, there is no randomness or ambiguity of the output. There is a clear and well-defined movement between states and their associated outputs. There are several ways of representing a FSM. In this chapter we shall discuss several of these. Perhaps the easiest to understand is the “State Diagram” notation we introduced with Tom. This is graphical and represents states as circles and transitions as arcs, Figure 4. The state is labelled with a name (Q1,Q2,… or anything you like) inside the circle. The output associated with the state is also indicated in the circle, here shown within square brackets, e.g. [R1], “response 1”. Transitions between the states are labelled with the stimulus “S” which causes the transition. Finally, there are two special states, the starting state for the machine, indicated by an arrow onto the circle, and the end state, indicated by a double circle. Note that some FSMs (such as traffic-light controllers) do not have an end state, but run continually through some sequence of states. S Q1 Q2 Q1 Q2 [R1] [R2] [R1] [R2] (a) (b) (c) Figure 4. State Diagram notation. (a) States are shown as circles connected by arrows indicating which stimulus S causes a transition between the states. Each state is labelled with a name (Q1,Q2,…) and also the output or response which that state produces. This is enclosed in square brackets, [R1], [R2],… There are two special states, (b) the initial state indicated by the arrow and (c) the final state indicated by a double circle. We should also mention here that there are two “flavours” of FSMs, “Moore” and “Mealy”. The distinction between these will be discussed in section D18 and centres around when a new output is generated. The Moore machines (which we shall be using in the following examples) associates an output with a state. Mealy machines associate an output with a transition between states. D3. A Door Combination Lock Let’s take as our first example an electronic lock controlling entry to a door. I’m sure you’ve seen these locks, a polished aluminium box next to a restricted-entry door with keys labelled 0 to 9. Well’ we’re going to take a simpler (though equally powerful) keypad comprising just two keys, “0” and “1”. That sounds rather binary! The system is sketched in Fig.5(a) The binary keypad provides inputs S to the FSM which must decide whether the correct input sequence of 0s and 1s has been entered. Let’s agree that the entry code is the 4-bit sequence “0110”. If this sequence has been correctly input to the FSM, then the FSM moves into its end-state where it outputs a “1” or “open” command to the release mechanism (a solenoid operated lock). Any incorrect sequence outputs a “0” which means “do not open”. 0 0 open input FSM Release (a) 1 mechanism 1 Q1 0 Q2 1 Q3 1 Q4 0 Q5 (b) [0] [0] [0] [0] [1] Q1 0 Q2 (c) [0] [0] 1 Q1 0 Q2 [0] [0] (d) 1 0 Q1 0 Q2 1 Q3 [0] [0] [0] (e) 1 0 0 0 1 1 Q1 Q2 Q3 Q4 0 Q5 [0] [0] [0] [0] [1] 0 1 0 1 (f) Figure 5. FSM description of a door lock. (a) Shows the system structure and (b) – (f) shows stages in the development of the FSM State Diagram (see text). Starting in state Q1, the FSM will move to the ends state Q5 if the correct sequence of binary digits “0 1 1 0” is entered at the keypad. All states output “0” except Q5 which outputs a 1 to the release mechanism. Let’s work out how to build the FSM “State Diagram” in stages. First we have to work out how to detect the correct key sequence. This is easy, we need to detect a “0” then a “1” then a “1” then a “0”. This sequence can be represented as a straight linear graph of five states, see Fig.5(b). From the starting state, each correct input stimulus advances our journey, from left to right, along the stepping-stones of the states until we reach the end state Q5. Note that this state outputs the response [1] which signals the release mechanism to “open”; all the other states, Q1,… Q4 output the response [0] which clearly means “do not open”. Let’s reflect a moment on what these states represent: Q1 We have not received a “0”. Erroneous “1’s” have been keyed in Q2 We have received a “0”, the first correct key code Q3 We have received a “0” and a “1” correct two key codes in the sequence Q4 We have the three key codes “011” Q5 We’ve finally got everything “0110” This state diagram can recognize the correct sequence of input digits. But it cannot yet respond to an incorrect input, such as 0111. We must augment this basis state diagram with transitions which will handle incorrect input digits. The first incorrect digit will be a “1” instead of a “0”. When we are in Q1 If we input a “1”, then we must not allow the FSM to progress to Q2, we must return to Q1. So we augment the original FSM with a loop from Q1 to Q1 which is invoked on receipt of input “1”. This is shown in Fig.5(c). What about the next possible error? Assuming we have entered the correct first digit “0”, and so we are in state Q2 we are expected to enter a “1”, but let’s say we enter a “0”. What do we do? There are two options, first we could decide that the entire key code entered was incorrect, so we could return to state Q1 and start afresh. But we don’t need to do this. We have entered “00”, so we could interpret the second “0” as the “0” beginning the correct sequence “0110”. In other words, we should return to Q2, since this second (erroneous) “0” is at least a valid “0”! So we add the transition shown in Fig5(d) back to Q2. So let’s assume that we are in Q2 and then we input a “1” which brings us into state Q3 (that means we’ve correctly input “01”). Now we are expected to input a “1” (the next digit in the code sequence “0110”). If we input a “1” then we proceed to Q4 “010” but once again we err and input a “0”. To which state should we transit? Again or last input “0” could be interpreted as the start of the sequence “0110” so we return to Q2 which has recognised the “0”, Fig.5(e). Sooner or later we shall triumph over our forgetfulness and arrive in state Q4 where we have entered “011”. There is one more digit to go. If we enter “0” we proceed to Q5 and the door opens, but, no we key-in a “1”. So to which state do we transit? Well, we have entered “0111” There is no way in which any part of this string can be considered to belong to our desired “0110”, so there is but one choice, to return to the start, to state Q1. The complete state diagram for the door lock is shown in Fig.5(f). D4. A Parity Checker Our second example of a FSM is a parity checker. Of course, before we get to grips with the FSM we must understand what “parity” means. Parity is a useful concept used in transmission of data across a communication channel, like a serial connection, a USB port or an internet conversation. We know that all data and instructions are encoded as numbers, which at the fundamental level of electronic signals are present as “bits”. So, for example a the color of an object on a web age may be encoded as the hexadecimal number FF0000 (pure red, see chapter 1) which in binary is 1111 1111 0000 0000 0000 0000. This “stream” of 24 bits appears as an input (stimulus) to our program (FSM) and we must process these bits. One important processing function is to count the number of “1’s” in this incoming bit- stream. This count or “parity” can be used to check if there has been any error in communication. For example, if the communication protocol has been agreed to send a bit-stream comprising only odd-numbers of bits set to “1”, then we may check the data on receipt, to see if there is an odd number of high bits. If there is not, then an error has occurred in the communication channel, and we must then request that the data be re-sent. In this example we consider the case of odd parity. Any correctly received bit- stream must contain an ODD number of “1s”. The FSM must output a “1” whenever the bit-stream contains an odd number of “1s”, else it outputs a “0”. The block diagram description of this problem is shown in Fig6(a). The input stream of binary digits enters the FSM which analyzes this stream and outputs a message “odd” when the parity is odd. 0 Odd number Input stream Of 1s Output FSM Message 1 “odd” 1011011 (a) 1 Even Odd [0] [1] 0 (b) 0 1 Figure 6. Parity Detector FSM. (a) shows the general system structure, (b) the State Diagram describing the FSM. On input of an even number of 1s, the FSM will be in state “Even”, an odd number will place the FSM into state “Odd”. The FSM “State Diagram” is shown in Fig6(b). We start in the state “Even” which means zero bits received. There are two possible inputs or stimuli, “0” or “1”. If we receive a “0” then we return to the state “Even” (since “0” is an even number). But if we receive a “1” then we transit to the state “Odd” and we output a “1” indicating that we have found odd parity. In this state, any received “0” does not change the number of “1s” received and so the parity; we remain in state “Odd”. But if we receive a “1” then we have received in total two 1s, and so transit to the state “Even”. Clearly this FSM is capable of “counting” the number of 1s received, and if this is an odd number will output a “1”, or if this is an even number, will output a “0”. I guess’ you’ll figure out some other uses for this circuit. D5. Traffic Lights Let’s consider a problem in control engineering where an electronic controller, perhaps using a microprocessor, must be built, to control a set of traffic lights at a road junction. There are also sensors a and b placed on the roads A and B which respond to cars arriving there. The idea is that if the lights on road B are red, and a car arrives at sensor b, then the lights will cycle through a change so that B gets a green light. Road A behaves in the same way. This is sketched in Fig.7(a). To construct a FSM controller, we must first enumerate the smallest number of states we shall need to use, and to do that we go and find some traffic lights and observe them. Fig.7(b) shows the states (a) b B a A TO TO a Q1 Q2 Q3 Q4 (b) TO TO b TO TO Q8 Q7 Q6 Q5 Figure7. (a) Traffic Lights at the junction of roads A and B. Sensors a and b detect the arrival of a car at the lights on each road. (b) Finite state diagram showing the symbolic state of each pair of lights (left is A right is B) together with transitions which move between states. “TO” is a timeout (delay) stimulus provided internally by the controller. Input stimuli “a” and “b” are produced by the respective road sensor. Now for the transitions between the states. Some like Q2 -> Q3 Q4 -> Q5 are produced by the timeout delay circuits. These “timeout” transitions are indicated in Fig.7(b) as “TO” Now we must handle the stimuli from the road sensors. Let’s agree to start in State Q3 where cars are freely flowing along road B and let’s assume that no cars have arrived at a. Then a car arrives and triggers the sensor at a. This will make a transition from Q3 to Q4 to begin the cycle of light changes. States Q4 and Q5 are linked by the timeout and so are Q5 and Q6. Another timeout and the system is in state Q7 with traffic now halted on road B and flowing freely on road A. Then, when a car arrives at b it will trigger a transition Q7->Q8 and the dual steps of timeout will follow to get the lights back into state Q3, where the traffic flow will resort to its original state. There is an obvious limitation to the controller designed above; it responds immediately to cars arriving at its sensors which would interrupt reasonable traffic flow by a rapid switching of lights. Some delay needs to be build in between the receipt of a road sensor stimulus and its use to trigger a state change. An alternative would be to count the cars arriving at the sensor, and trigger a transition when this is above a threshold. D6. Counting People Entering a Room Here we wish to design a system which will count people entering and leaving a room, and at any time know how many people are in the room. We assume there’s an electronic entry and exit sensor near the doorway which generates events for our FSM. The simplest approach is shown in Figure 8. Here, an “in” event will cause a transition to the next state down the line, and each “out” event will return to the previous state. Each state outputs the count it represents. There is of course one problem with this FSM. At the moment we can only count up to 5 people. If we want to count more people, then we need more states. But what about the situation where we cannot know the number which has to be counted? This FSM cannot cope with this problem, and remain “Finite” in size. We’ll return to this in Chapter ?? when we discuss an extension of the FSM description into “Turing Machines”. 1 1 1 1 Q0 Q1 Q2 Q3 Q4 [0] [1] [2] [3] [4] 1 0 0 0 0 Figure 8. Counting people entering and leaving a room. Input S=1 is produced by a sensor when someone enters, input S=0 when some one leaves. Each state can output the number of people in the room at any time. When the output R=0, then the lights can be switched off. Note that this FSM can only count up to 4 people. D7. The usefulness of Finite State Machines Before we consider some further examples, it’ stime to sit back and reflect on the usefulness of FSM’s. Sure we have constructed some nice graphical diagrams to capture the behaviour of some systems, but what can be do with these? Let’s address this question here, and summarise the most important characteristics of FSMs 1. They give us a simple and intuitive way of describing a system which has discrete dynamics (that’s our State Transition Diagrams). 2. They give us a complete and unambiguous way of describing a system 3. An FSM is an “abstract machine” That means that we can make a mathematical description of the machine reason about its behaviour without actually building it. 4. Since the description is mathematical, we can use mathematical proof to be sure of the functioning of the machine. 5. They can be directly and unambiguously converted into a computer program (e.g. via the “SDL” language). 6. They can be directly and unambiguously converted into a digital electronic circuits. Wow, that’s something, but what does this all mean? Well, simply that you’ll see FSMs everywhere from now on! But of particular interest to the engineer are points (5) and (6) which tell us that if we can construct a FSM for a system, we can directly generate the computer program or digital electronic circuit which will make that system work: The above traffic-light FSM can be concerted into an electronic circuit to run the traffic-lights, and so can the door counter. Also the examples we shall soon see concerning recognition of words in sentences can be directly converted into computer programs. We shall return to discuss the mathematical aspects in chapter?? D8. Acceptors and Transducers - Recognising Laughter Imagine a microphone connected to your computer which was programmed to recognise whether someone was laughing in the room. It would have to recognise “Ha!”, “HaHa!”, “HaHaHa!” and so on. This is quite easy and could be constructed using the FSM shown below, where we assume that the FSM gets a series of characters as its input events. Have a look at Figure 9. From the starting state Q1, it may only exit if a “H” is observed. If any other character is received, (which is not an “H”) then it returns to itself, that’s the loop labelled “~H” where the tilde “~” is the logic symbol for “not”. Having received an “H” the FSM is in state Q2. If the next character received is then an “a”, then the machine proceeds to Q3. But any other character does not fit into the required substring Ha and so a transition back to the starting state must be made, this is labelled “~a”. Once in state Q3 three things can happen; (i) a “!” is received signalling the end of the “Ha”, in which case we exit to the terminal state Q4, (ii) a “h” is received in which case we return to Q2 in expectation of an associated “a”, or (iii) any other character is received in which case we have an incorrect string and we must exit to S1 the starting state. This FSM only outputs a response R=1 when it has recognised a specific pattern of input stimuli. Such FSMs are called “acceptors” since they are built to accept one or H a ! Q0 Q1 Q2 Q3 [0] [0] [0] [1] ~H ~a h ~(! or h) Figure 9. FSM for recognising laughter. From Q0 an input “H” transits to Q1, any other character returns to Q0. From Q1 we move to Q2 on receiving an “a”, which means we’ve got “Ha”. But if we don’t get an “a” then we return to Q0 to start afresh. From Q2 we accept either a “!” to signal we’ve received a single “Ha!”, or if we get an “h” then we recycle to Q1 in wait for an “a”. Anything else, then back to the beginning. This FSM recognises strings such as “Ha!”, “Haha!”, “Hahaha!” etc. more input strings. The door combination lock discussed in section D3 is another example of a acceptor. But we have also seen examples of FSMs which output a value at every state, like the people-counter in Section D4 Here the input stimulus was converted or “transduced” into a numerical value. So there are two classes of FSMs, “acceptors” and “transducers”. D9. Recognising Text – A Computer Program Parser When we write a computer program, we produce a bunch of text which is input into a compiler or interpreter which must ultimately convert this into a series of instructions which the CPU can execute. The part of the compiler which does this is called the “parser” and is fed by a stream of input characters and must “parse” this stream into a series of tokens which can be used to generate the machine code. There are also special symbols such as the semicolon, well-loved by C and Java programmers, whitespace “ “ and brackets “[“ and “]” familiar to us from out work on the Sam-2 CPU in Chapter 2. Let’s sketch here a simple FSM to parse the “mov ax,[3]” type of instruction we encountered in our Sam-2 work. There are various possible patterns we have to recognise: mov ax, [addr] mov bx, [addr] mov [addr], ax, mov [addr],bx We assume that we have a method in out program which can detect the tokens “mov” and “add” (that would be another FSM which would like the Laughter-detector above). A partial state diagram for this problem is shown in Fig.10. Q8 Error [e] ] Q7 ~ax or ~bx addr mov ax , [ Q1 Q2 Q3 Q5 Q6 bx , [ Q4 Q9 Q10 addr Figure 10. Acceptor FSM for parsing either “mov ax,[addr]” Q11 or “mov bx,[addr]. The error state is shown only receiving a transition “~ ax or ~bx”, ie if neither “ax” or “bx” have been ] recognised. Other states transit to the error state if their indicated input S is not received. Q12 Q1 The starting state is a new line of code From here if we receive a “mov” token then we transit to Q2 which represents “mov” received From here if we receive an “ax” then we transit to Q3 or if we receive a “bx” then we transit to Q4. If we receive anything else, we transit to SError which records the fact that there is a “syntax” error in our code and outputs an error message. Q3 We have parsed “mov ax” Q4 We have parsed “mov bx” From Q3 if we receive a comma “,” then we proceed to Q5 else we proceed to SError From Q5 if we receive a “[“ then we proceed to Q6 else we proceed to SError In Q6 we must receive a number “addr” we go to Q7 else we proceed to SError From Q7 we must receive a “]” to put us in Q8 Q8 Correct parsing of the code “mov ax,[addr]”. This outputs R = 1. A Similar chain of events leads us from SQ to S=Q12 which have parses the code “mov bx,[addr]” And further chains could be used to parse the other possible lines of code of the form “mov [addr],ax”. D10. Counting Brackets We’ve already seen one “counting” example, people entering and leaving a room, so why are we looking at another “counting” example? Well, this is fundamental to computing, especially programming. It’s also fundamental to mathematics, which is closely allied to theoretical computing. So what are brackets? They are convenient symbols which enclose something. There is a left “bra-“, the symbol “(“ and a right “- ket” , the symbol “)”. Together the make a “bra-ket”, the symbol “ ( )”. I.e., they should only come in pairs. What can we place within this bra-ket? Well, we can write “(3 + 1)” and we all know that this means “4”! What about this expression, “5 x ( 3+1)”. What does this equals ? It’s faily obvious that we must first do the “3+1 = 4”, and then do the 5 x (4) = 20. Yep that’s right! The bra-kets tell us what to do first. So bra-kets are a way of ordering our processing in sequential stages. Let’s take another example. What does “((6+7) x (5+3))” mean? Well the “(6+7)” are bra-keted which means that we must first do this sum, (6+7) = 13. Then the “(5+3)” are bra-keted which means we must also do this sum, (5 + 3) = 8. So we replace these bra-kets with their arithmetical results and get 13 x 8 Which gives us the result 101. Here’s another example for you to ponder upon. What is the value of ( (4 +1) x (5 x 2)) ? Yep, it’s 50! Great, well done! But look at the structure of the above expression. We have ( (b) x (c) ) where “(b)” is the intermediate calculation “4+1” and “(c)” is the intermediate calculation “5x2”. The outer bra-kets in “( … )” in “( ()() )” combine these intermediate results, in this case multiplying the 5 ( which comes from 4 +1) with the 10 (which comes from the 5x2) to give the result 50. In other words, bra-kets give us a symbolism to help us carry out the correct computations in the correct order. So what? Well, if you look at the examples provided above, you will see that the number of bras equals the number of kets. If we have two “(“s in an expression then we have two “)”s. So an expression ( (3 + 1) x ( 3 x 5) ) + 4 is fine, since we have 3 bras “(“ and three kets “)”. But this expression (3 + 1) x (3 x 5) + 4) Is incorrect since we have 2 bras and 3 kets. A computer program (a parser) fed with this input would give you a “syntax error” without hesitation. The parser expects matched bra-kets (if there’s three ((( then there must be three ))) )! Wow! How many bras and how many kets did you scan in the previous sentence? Bras and kets are important in high-level languages such as “C” and “Java” since they identify blocks of programming code which are written to achieve specific goals, such as adding numbers, finding the brightest point in an image, or reading user key-press input. Bra-kets give the programmer a tool to structure the written code. So let’s attempt to build a FSM to do this important task. Have a look at Fig.11. State Q1 is fundamental here. In this state, we have “matched” brackets, an equal number of bras and kets. Let’s say we have the string “(a(bc)d)”. Then the first input to the FSM is the first “(“. This moves us from Q1 to Q2. Then we get the “a”. This is neither a “(“ nor a “)” so we stay in Q2 thanks to the “~( OR ~)” loop. Then we get another “(“ so we move to Q3. Then we get the “b”, which is neither a “(“ nor a “)” so we return to Q3. The same happens when we get the “c”. So we remain in Q3. The next input is S = “)” so we go back to Q2 and then we get a “d” which keeps us in Q2. Finally we get the input S = “)” which puts us into Q1 which outputs a “1” indicating that the brackets are matched. ~( or ~) ~( or ~) ( ( Q1 Q2 Q3 [1] [0] [0] ~( ) ) Figure 11. Bracket checker FSM. This accepts characters “(“, “)” and “a-z”. We exit Q1 only on input S = “(“ . Once in Q2 we only move to Q3 if we receive a “(“ or else return to Q1 if we find a matching “)”, e.g if the input was “(ansbd)”. We advance to Q3 if we have received two “(“’s , e.g. if the input was “(aab(dhf”. It is clear to see that we find ourselves in Q1 only if the brackets match, such as “(a)” or “(a(bcd))”. But this FSM is incapable of matching any more than two pairs of brackets. The FSM works well, perfectly. But only if up to two bras and two kets are expected. Any more, then the FSM cannot cope. And here’s a fundamental limitation of the FSM approach. While we can extend the FSM to recognise three, four or a hundred matching bra-kets, we cannot extend it to recognize an unspecified number of bra- kets. The FSM formalism does not have sufficient expressive power to generalise. As we shall see in Chapter??, the Turing Machine formalism suggests a solution. D11. Designing a Soft-Drink Dispenser Let’s tackle a classic problem in electronic engineering, designing a controller to work a soft-drink dispenser. Let’s take a relatively easy scenario: You will be issued with a can if you have deposited 30p (or more, but no change is given). The machine only accepts 10p and 20p coins. Of course these may be deposited in any order. After each coin you put in the machine, it moves to a new state which of course reflects the total money entered. The end states are simply when sufficient money has been deposited, if at least 30p is deposited, then the final state will output R=1 and release the can of drink. State Q1 is the entry state with nothing entered. At each state, until the end, there are two possible events, the deposit of 10p or 20p. So the FSM has the structure of a binary tree. There are five possible end states, shown in Fig.12(a). It’s easy to understand this tree. When you deposit a coin, there are two possibilities, either a 10p or a 20p. The state diagram summarises all possible combinations. Only when you have paid enough (or too much!) does the FSM output R=1 to dispense you drink. Q1 Q1 [0] [0] 10 20 10 Q2 Q4 [0] [0] 20 Q 20 2 10 20 Q9 [0] 10 [1] 10 Q3 Q7 Q8 [0] 40 [1] [1] Q 20 20 3 10 [0] 20 30 30 10 Q5 Q6 [1] [1] Q5/7/8 Q6/9 [1] [1] 30 40 (a) (b) Figure 12. Soft drink dispenser FSM. (a) Binary tree state diagram: Transitions indicate a deposit of either 10p or 20p to purchase a drink worth 30p. Terminal (double-circled)\states indicates the money deposited to release a drink. This state diagram is a “binary tree” – on each coin deposit there are two possibilities, 10p or 20p. Each transition represents one of these. (b) Reduced state diagram, The question arises, can we simplify this state diagram, and the answer is yes! Consider the terminal states in Fig.12(a). There are two classes of states. In one we have entered 30p and in the other we have entered 40p. So we should coalesce these two “classes” of states into two states, one where we have entered 30p and one where we have entered 40p. So we take Q5, Q7 and Q8 as identical and also Q6 and Q9 as identical. This produces the simplified state diagram is shown in Fig.12(b). D12 Table-Based FSM Representation – Parity Checker The diagrammatic representation of an FSM as a State Diagram is appealing to our human way of working and perhaps thinking, and while it captures an FSM completely may not be the best way to prepare for a software or digital electronic implementation. To prepare for understanding how this is done, we now introduce a table-based methodology for constructing FSMs. It is important that this new methodology maintains the essential structure of the FSM: States, the output or response of that state and transitions between the states caused by external or internal stimuli. Finally we must have closure, which means that each state will lead to an existing state within the machine. 1 Even Odd (a) [0] [1] 0 0 1 Present Input Next Output State (PS) (S) State (R) Even 0 Even 0 (b) Even 1 Odd 0 Odd 0 Odd 1 Odd 1 Even 1 Figure 13 Parity Detector FSM represented both as (a) the original State Diagram and (b) as a Symbolic State Transition Table. The first two columns contain the present state PS and the input S causing the transition. The last two columns show the next state, but the ouput R is from the present state PS. Let’s take a few of the example seen above and convert them to Tables, first the parity detector reproduced in Figure 13 together with the Symbolic State Transition Table. To construct the table we inspect the State Diagram. Starting with the present state (PS) as “Even” we create a line in the Table for each possible input S to this state. This gives the lines starting with “Even” “0” and “Even” “1”. We then follow the State Diagram arcs to each of these inputs to discover the next state (NS). The first two lines become “Even” “0” “Even” and “Even” “1” “Odd”. We finally add the output (R) from the present state. Note carefully that we use the present state and not the next state to get the output. This is because it’s the present state that generates the output. Repeating this for the Odd state and its inputs generates the whole table shown in Fig.13(b) This table is easy to convert to a computer program, and also into a digital electronic circuit. We’ll discuss such a program in section?? Below and you’ll have opportunity to play with the program in the Activities at the end of this chapter. D13 Table-Based FSM Representation – Door Lock Here we produce a Symbolic State Transition Table for a cut-down version of the door lock we met in Section D3. The simplified door lock opens when the string of two bits “01” is entered at the keypad. The state diagram is shown in Fig. 14(a) where the terminal state Q3 outputs R=1 to trigger the opening mechanism, the starting and intermediate states Q1 and Q2 both output R=0. The table shown in Fig.14(b) is easily constructed, one only has to remember that the output R is derived from the present state PS and not from the next state NS. 0 1 Q1 Q2 Q3 [0] [0] [1] 1 0 Present State Input (S) Next State Output (R) (PS) (NS) Q1 0 Q2 0 Q1 1 Q1 0 Q2 0 Q2 0 Q2 1 Q3 0 Q3 0 Q3 1 Q3 1 Q3 1 Figure 14. Simplified door lock FSM (based on the example shown in Fig.5). This accepts the string “0 1” to unlock the door, the output signal “r=1” being generated in Q3. (a) shows the State Diagram and (b) the Symbolic State Transition Table. The next state (NS) is generated from the present state (PS) by the input stimulus S, and each PS generates its output response R. D14 Setting a FSM into Digital Electronic Hardware. Parity Checker The Symbolic State Transition Tables contain symbols as well as numbers. We know that at its digital electronic level circuits work with numbers, and more specifically binary numbers. So to prepare for digital electronics, we must get rid of the symbols and replace or “encode” them with numbers. Let’s take the parity checker once more. As shown in Fig.15 the encoding is straightforward (and natural). We encode each occurrence of the symbol “Even” as “0” and each occurrence of the symbol “Odd” as “1”. So we obtain the Encoded State Transition table in Fig.15(b). This is now ready to be cast into digital electronics. Present Input Next Output State (PS) (S) State (R) Even 0 Even 0 Even 1 Odd 0 Odd 0 Odd 1 Odd 1 Even 1 (a) Present Input Next Output State (PS) (S) State (R) 0 0 0 0 0 1 1 0 1 0 1 1 1 1 0 1 (b) Figure 15 The Parity Checker: Conversion of the Symbolic State Transition Table (a) to the Encoded State Transition Table (b) which can be set into a digital electronic circuit. The encoding is simple; Even -> 0 and Odd -> 1. The state table has been effectively translated into binary numbers. But before we get down to details, let’s have a look at the block-diagram structure of a general digital FSM. This is shown in Fig.16 and consists of three functional blocks: 1. The “CI” block represents Combinatorial Logic Input (where “combinatorial logic” means “gates”). 2. The “CO” block represents Combinatorial Logic Output 3. The “L” block is a “latch”, a small amount of memory which stores the present state PS. Let’s attack each of these blocks. First the CI block. Remember that each line in the State Transition Table used the value of the present state (PS) and the value of the input (S) to work out the value of the next state (NS)? Well that’s exactly what the CI block does. Also the output R is worked out from the value of the present state PS. That’s the job of the CO block which is fed by PS at its inputs. Think of both CI and CO blocks as bunches of logic gates. Now what about the “latch” L? Well, the FSM must be in a stable state until it requested to make a transition, in other words, the state, the PS mut be stored somewhere, and that’ what the latch does. The outpout of the latch is equal to what it is storing, which is the present state PS. So PS comes out of the latch, and flows back into CI where it is combined with input S to generate the next state NS which appears at the output of CI. But it does not enter L. The present state only becomes the next state on a transition. That happens when a clock pulse is applied to the “clk” (clock) input of L. At this moment there is a transition and NS becomes PS so the FSM moves into the next state. Input S / CI CO NS PS L / / / Output R clk / Figure 16 Block diagram of a Digital Electronics FSM. Inputs S and the present state PS enter a clock of “combinatorial logic” labelled CI. This is a collection of logic gates which generates the next state NS signals. The centre block L is a “latch” which stores the current value of the present state PS. This state is passed to CO which is the output logic gates. Finally PS is fed-back to the input of CI. The “clk” clock signal load the next state NS into the present state PS when a state transition occurs. The diagonal bars on the wires indicate that they may consist of several parallel wires. This discussion may have left you a little perplexed. If you think like I do, then you may want a couple of concrete examples worked out. So let’s move on to attack the parity detector details. First we must consider CI. Look at the encoded state transition table in Fig.17(a). This shows how the present state PS and the input S are combined to produce the next state NS. If we simply read the four lines in the table as a truth-table then we see at once that the output, NS is simply the output of a logical XOR-gate. So that’s C1 cracked! Now on to CO. Again, inspection of the encoded state transition table shows that the output R is equal to the present state PS. So CO involves nothing else than outputting PS, we don’t need any logic here. Finally we must think about L. Here the only decision we must make is as to what we must remember, i.e., how many bits of data. We know that the input to L is NS and the output is PS. Again, the encoded state transition table shows that there are only two possible values of the FSM’s state, 0 or 1. So we need one bit of memory. As you know, this is a one-bit data latch. Putting these three components together, as outlined in the general block-diagram of Fig.16 gives us our final circuit, sketched in Fig.17(b). You will have the opportunity to examine this circuit using a digital-logic simulator in the Activities at the end of this chapter. Present Input Next Output State (PS) (S) State (R) 0 0 0 0 0 1 1 0 1 0 1 1 1 1 0 1 (a) P S NS Output R Input S CI M clk (b) Figure 17 Parity detector FSM. (a) shows the encoded state transition table and (b) the equivalent digital logic implementation. Input S is provided by a switch and the output R by a LED. Note the present state PS at the output of the D-latch and NS generated from PS and S by the XOR-gate. The clock signal “clk” loads NS into the latch where it is output as the value of PS. So NS becomes PS, a transition has occurred. D.15 Electronic Door Lock As a second example of the procedure discussed above, let’s look at the electronic door-lock problem we introduced in Section D3 And see how we can set this into digital hardware. To keep things manageable, we’ll work with a cut-down version of the door lock comprising the first two stages, the lock will open when the digits “0” and “1” are input in that sequence. This simpler door lock is shown in Fig.18(a) as the State Diagram and the Symbolic State Transition Table. You should feel happy by now of the equivalence of these two representations, and how to produce the Table from the Diagram. The next state is to compose the Encoded State Transition table. This is shown in Fig.18(b) The encoding of the states is easy, we’ve just used the number following the “Q” as a two-bit binary number. So we have Q1 -> 01, Q2 -> 10, Q3 -> 11. So both the represent state (PS) and the next state (NS) are encoded as two-bit numbers. We’ve laid out the table in a slightly unusual way. In fact there’s two tables, one which shows the two next state bit and a second which shows the Output bit (which when “1” will open the door). This is to help us identify the “products”! of logic states which we need to “sum” to generate the composite logic function. The miniterms needed are labelled “a” to “d” for the higher order NS bit (bit-2) and as “e” to “I” for the lower order NS bit (bit-1). For example term “a” is a = Not (PS2) AND (PS1) AND (S) which electronic implementation is shown in Fig.19(a). All the products forming this term are generated in the same way, and they are combined in an OR-gate to produce the entire term “a”. This is shown in Fig.19(b). A similar construction is made for the NS bit-2 terms and the Output R terms producing the combinatorial circuit shown In Fig.19(c). Finally the combinatorial next state and output state are combined with the memory element to produce the final circuit diagram shown in Figure 20. Present State Input (S) Next State NS2 NS1 (PS2 PS1) (NS2 NS1) Products Products 01 0 10 e 01 1 01 a (a) 10 0 10 f 10 1 11 b g 11 0 11 c h 11 1 11 d i (b) Product a = Not (PS2) AND (PS1) AND (S) Present State Input (S) Next State Output (PS2 PS1) (NS2 NS1) Products 01 0 10 0 01 1 01 0 (c) 10 0 10 0 10 1 11 0 11 0 11 k 11 1 11 l Figure 18. Encoded State Transition Tables for the Simplified door-lock from Figure?? Here a separate table is provided for the next state (NS) output (a) and for the output response (R) from the FSM. Each of the logic product terms is indicated with a letter; in (a) the NS bit-2 terms (NS2) are labelled “a” to “d” and the NS bit-w terms (NS1) are labelled “e” to “i”. This corresponds to the labelling of the digital circuits in Figs?? And ??. One product, “a” is explicitly written out in (b). This corresponds to the second line of the table in (a). PS2 PS1 S PS2 PS1 S a a b NS2 c (a) (b) PS2 PS1 S e PS2 PS1 f NS1 g h R i (c) (d) Figure 19 Circuits derived from the Encoded State Transition Tables for the Simplified door-lock. (a) shows the generation of the single product term “a” contributing to the bit-2 next state output NS2 and (b) shows the complete “sum of products” for the next state bit-2 (NS2) output. The NS1 bit-1 output is shown in (c) and the FSM output R in (d). Keypad / input S 1 CI CO NS2 NS1 PS2 L Output PS1 / / / response R 2 2 1 clk (a) / 2 a b NS 2 c d PS2 L PS1 e f clk g NS 1 h i R (b) Figure 20 Digital logic door lock example. (a) is a block-diagram of combinatorial logic elements and latch L, (b) shows the gate-level implementation of the door-lock. D.16 A ROM-Based Digital FSM Approach to the Door Lock In a previous chapter we took a hard-nosed look at digital electronic circuits. One principle we saw was that it is possible to use a programmable memory to simulate any combination of logic gates. Also, that there exist chips containing arrays of programmable logic elements which can effect these logic functions. Here we shall see how to implement the door-lock in Read-Only-Memory. The basic circuit is shown in Fig.21(a) which contains four elements, a ROM, and three D-latches. These latches provide the latching function “L” for the three bits required to encode the states Qn, input S and output R of the FSM. The ROM provides the combinatorial logic functionality (“CI” and “CO”). At each clock pulse instigating a transition, the present state PS exits the latch as two bits, PS2 and PS1. These are fed to the ROM as part of a 3-bit address. The third bit of the address is the input S. So the address into the ROM has this form Bit 4 2 1 Address = PS2 PS1 S The data which is selected by this input address represents the next state NS and flows into the latch. The data has this form Bit 4 2 1 Data = NS2 NS1 R To see how we must construct these address-data bits, let’s consider the first line of the encoded state transition table shown in Fig.15(b). This is PS2 PS1 S NS2 NS1 R 0 1 0 1 0 0 The address (PS2 PS1 S) is 010. Since we must have a 4-bit address, we add a leading 0 to give us 0010. The data (NS2 NS1 R) is 100. Again we add a leading 0 to give the data 0100. So we have generated the ROM line Address = 0010 Data = 0100 This is the fifth line in the memory shown in Fig.21(b). The entire ROM contents were generated in this way. Clearly, once the encoded state transition table has been built for a particular problem, then the ROM-based implementation is simple to generate, much easier than an implementation using discrete logic gates. A final comment concerning the first two lines of the ROM address and data. The addresses 000 and 001 have no correspondence in the symbolic table (they would have encoded state “Q0”). But we started our symbolic labelling with “Q1” which was encoded as addresses 010 and 011. This was not a wise choice, in fact it is a mistake, since the ROM has two locations without any meaning, and the electronic circuit will reference these locations. To recover from this mistake, we put data into addresses 000 and 001 to get us into our starting state 010. This explains the data values for these two addresses. Conclusion? Well, it’s best to start our enumeration of states at zero, ie “Q0”. (a) S 0000 0010 0001 0010 0010 0100 0011 0010 0100 0100 0101 0111 0110 0111 addr 0111 0111 ROM R L (b) clk Figure 21 ROM-based electronic door lock. The digital FSM is outlined in (a). The combinatorial logic is provided by the ROM which feeds into the latch made up of three D-latch elements. Note that the input S and output R are connected to the lowest bit. In (b) the details of the ROM are shown. The data at each address has been obtained by inspection of the enecoded state transition table (Fig.15(b)). Note that S and R are connecterd to the lowest bit. While the door-lock needs only 3 bits of data, four bits are shown here since that is the smallest unit offered by the digital simulator. D.17 A FSM Robot Controller As part of the Activities at the end of this chapter, you will be invited to program a robot controller using a symbolic state transition table. A screen-shot of the simulator you will use is shown in Fig.22. The robot has two sensors, a left bumper and a right bumper which input into the table FSM. Each state has four possible outputs, move forwards a bit, move backwards a bit, turn left a bit and turn right a bit. You can load various “robot worlds” into the simulator which contain a number of obstacles. Figure 22. Robot FSM simulator. The right panel shows the robot with its left and right input sensors approaching an obstacle. The FSM Table on the left panel combines input from the present state “This” with the input sensors “ipL” and “ipR”. The output is the next state “Next” and the response motor drive signals “Left”, “Right”, “Front”, “Back”. Note these all outputs for a particular “This” state are the same. Our model of a FSM has the output determined by the present state. Let’s look at an example FSM table which you will be invited to construct, see Fig.23. First note we have labelled the first state “Q0”, with a view on a future encoding as “00”. We do not make the encoding mistake we made with the door lock again! Before we dissect this table, let’s have a look at its basic structure. Each of the two states has 4 lines in the table. This is because there are two binary inputs, so therefore four possible combinations of inputs. We must deal with each of these. Second, an event may cause a transition out of a state back into the same robot state (e.g. line 1) or into a different state (line 3) but may not go to an unknown state. This table has been slightly contrived to make the robot move until it hits the wall, turn right (clockwise) and then move forwards again: Line This IpL ipR Next L R F B 1 Q0 0 0 Q0 0 0 1 0 2 Q0 0 1 Q0 0 0 1 0 3 Q0 1 0 Q1 0 0 1 0 4 Q0 1 1 Q0 0 0 1 0 5 Q1 0 0 Q0 0 1 0 0 6 Q1 0 1 Q0 0 1 0 0 7 Q1 1 0 Q1 0 1 0 0 8 Q1 1 1 Q0 0 1 0 0 Figure 23. Symbolic State Transition Table for the simulated robot controller . The present state “This” input to the FSM is combined with the left and right bumber inputs “IpL” and “IpR”. The table produces the next state “Next” output and the robot movement left “L”, right “R”, forwards “F” or back “B”. Lines1-4: The Robot is in State Q0, the output is F=1 so the robot moves forwards. Lines 5-8: The robot is in State Q1, the output is R=1, so the robot turns right (clockwise) Line1: Neither left or right inputs are true. The next state is again Q0. Line2: The right input is true, there has been a collision with the right bumper. The state machine ignores this and will plough on forward, and keep on going, back into Q0. Line3: This is more interesting, there is a collision on the left. While the robot still moves forwards for a time (F=1) it’s next state is Q1 Now we jump to Line 7 since we are in Q1 and there is still input from the left bumper. The output now become R=1 “turn right – clockwise” and the next state is Q1=1, so that we may continue to keep turning. So we arrive back in Q1=1 and if IpL is still 1 then we shall keep on turning and once more return to Q1=1. Only when we return to Q1 and both IpL=0 and IpR = 0 do we arrive at line 5, where the next state becomes Q0, where we shall move forwards, although we still turn a little more right here. Now let’s see how to encode the symbolic table in such a way as to be able to produce a ROM-based FSM implementation. Glance once more at the table presented in Fig.23 and you will see that already the inputs IpL, IpR, and the outputs F B R L are already encoded as bits. It’s only the state names “This” and “Next” which are written as text, and it’s these which must be encoded, or represented at a set of bits. This is quite easy, if we label the states as numbers “0”, “1”, “2”, … “N”, since we may then use the binary representation of these numbers as out bits. Let’s choose to represent our states as 4-bit binary numbers. As we know this will give us a maximum of 2 x 2 x 2 x 2 = 16 possible states, which may well be enough for a small application. Converting the numerical values of the states in the above table to bits, we obtain the isomorphic table, shown in Fig.24(a). A ROM-based implementation is shown in Fig.24(b). Line This IpL ipR Next L R F B 1 00 0 0 00 0 0 1 0 2 00 0 1 00 0 0 1 0 3 00 1 0 01 0 0 1 0 4 00 1 1 00 0 0 1 0 5 01 0 0 00 0 1 0 0 6 01 0 1 00 0 1 0 0 7 01 1 0 01 0 1 0 0 8 01 1 1 00 0 1 0 0 (a) S 000010 0000 000010 0001 010010 0010 000010 0011 000100 0100 000100 0101 010100 0110 000100 addr 0111 ROM R L clk (b) Figure 24. Robot Controller shows as (a) the Encoded State Transition Table for the robot controller ROM contents generated by encoding state “Q0” as 00 and state “Q1” as 01. (b) with the ROM contents used to implement this controller D.18 Moore and Mealy Machines You may have noticed that a FSM involves a number operations. First the present state is combined with the stimulus input. Second an output is produced. Third, the state is updated, i.e., there is a transition. It turns out that there are two different architectures for combining these operations. These are known as “Moore” and “Mealy” architectures. Our discussion has been centered around the “Moore” machine where the output is generated by the present state. In other words the output is associated with the state. The transition serves to move between states depending on the input stimulus. The transition was always associated with a clock signal. But we can do this another way. We can associate the output with the transition between states. So, as soon as a stimulus is received, it produces a new output, without having to wait for the clock signal. This is the “Mealy” architecture, where the clock signal is used to move between states, but not generate the output. So in the Moore architecture, the output as well as generation of the new state happens on the clock signal, even though the stimulus may have arrived some time before the clock signal is issued. In the Mealy architecture, as soon as the stimulus is received, the output response obtains, the stimulus “flows through” to the output. Input S / CI CO PS NS L / / / Output R clk / (a) Input S / / / Output R CI CO PS L / / clk / (b) Figure 25. Two architectures of FSMs. (a) the “Moore” machine we have been discussing in this chapter. Here the output is only a function on the present state PS, while in (b) the “Mealy” machine, the output R depends on the PS and also the input state S. The output of the Mealy machine changes during the transition from the PS to the NS and not when the PS is established. This difference is made clear in Fig.25 where the direct path from input stimulus to output response is evident. We shall not develop these ideas further here, it is advanced material. Yet it is useful to know of the distinction, which you may encounter in your researches. D.19 A Biological FSM. There is some evidence that FSMs are used by biological systems to effect controllers and that they are implemented using biological neural nets. A well-known example are the simple neural circuits used to generate patterns of behaviour, such as locomotion or breathing. These neural circuits which maintain some rhythmic or oscillatory activity are know as “Central Pattern Generators” (CPGs) and have been widely studied in the case of invertebrate creatures where they have been found to consist of small numbers of interconnected neurons. One example studied by Getting in 1983 is the Tritonia swim CPG. (Tritonia is a “sea-slug” and is found a tasty snack by star-fish).This consists of a group of four interconnected neurons with excitory and inhibitory synapses, see Fig.26 The effect is to produce alternate activity in the dorsal and ventral swim motor neurons which enable it to escape a marauding star-fish. A cycle of states begins with b firing, where a does not fire due to the inhibitory connection nor does c fire due to its inhibitory connection with b. But eventually a fires and, after a delay, so does c. When c fires it inhibits both b and a. After a while b fires again, and the cycle repeats. a c b d Figure 26. Neural network providing the CPG FSM for Tritonia. Solid circles are excitory synapses, hollow circles are inhibitory. Since there is clearly a finite number of states in this cycle, this neural net can be cast as a FSM. Marvin Minsky has made this point, and has provided a mathematical equivalence between the MsCulloch-Pitts neurons we are using here and the FSM approach we have been studying. The interesting point is, that the FSM formalism may be applied to various underlying technologies, whether software, digital electronic or biological neural. Another suggestion has been made by Kohonen, who notes that the coupling of a neural associative memory with a delay (providing the equivalent of our “latch” circuit element) may be able to recall learned and remembered sequences of actions. A cat sees a mouse, recognises the mouse, prepares to run and runs! While there is at the moment little neuro-anatomical evidence for the suggested circuits, the digital- biological correspondence is enchanting, and demands further research. The structure of Kohonen’s circuitry is shown in Fig?? and clearly resembles the digital electronic FSM discussed in this chapter. stimulus response / / M / / delay Figure 27. Kohonen’s suggestion for a biological sequence generator. A stimulus input into an associative memory “M” elicits a response “R”, but the output from “M” is fed back, together with the input “S” to form an “address” into M. The “delay” is the equivalent of our digital “latch”, providing temporary storage of the FSM’s state. Compare this figure with Fig.?? D.20 Software FSMs and Games Programming If you look at a modern object-oriented games programming engine such as “Unreal Tournament”, you’ll discover the behaviour of the actors situated in these games is programmed using the FSM formalism. Indeed may modern texts on “game-AI” will include a detailed discussion of FSMs. There are also examples of contemporary AI development environments, such as Agent-based technologies (such as “Jade”). These software agents, which are programmed to have autonomous decision-making capabilities and behaviour often incorporate a FSM within each agent. Within the software development and engineering communities, various “patterns” of programming FSMs have been developed. Again this is beyond the level of this text. D.21 Roundup We hope that you have experienced the power and usefulness of the FSM approach in designing complex control and analysis engines which are of great use in real-world situations. The mapping from a human-centric “symbolic” description to a hardware (or software) implementation is important. Sure, we have skirted around some issues, the formal mathematics of FSMs. The limitations of FSMs. But we have also hinted that FSMs have a fundamental place in the understanding of the “nature” of computation. It is this aspect which we shall revisit in chapter ?? where we explore an extension of the FSM into the “Universal Turing Machine” which provides us with a theoretical understanding of the computers which pervade our lives. D.22 Activities These activities will give you some hands-on experience of working with Finite State Machines (FSMs). First some paper exercises, using the directed graph formalism, then some work using a Table-based FSM to control the behaviour of a simple robot. We shall also use a Digital Electronics simulator to explore some digital FSM implementations. ACTIVITIES 1 Question 1. Consider the FSM shown below. This receives letters of the alphabet as input. Which sequences of letters "strings" will it accept? Question 2. This question is a classic in Computer Science. A real doozer. It's used to check your pgorams or even your programs. Like in C or Java, whenever you begin a block of code with a '{' bra then you have to end it with a '}' ket to make up a paired '{ }' bra-ket. (Thanks to Dirac for the terminology). So the FSM receives a stream of characters like this ahds{ oieocvis{oxvvc}nnn} and it has to decide if the bra-kets are 'balanced', ie if the number of left bras { is the same as the number of right kets } . The example I just gave you wan perfectly balanced. The next example isn't main() { int i; intj j = i+1; ....so that program would not compile. Make a FSM that will indicate when the bra-kets are balanced. Here's a starting suggestion. Note that the states "S0", "S1", etc. are labelled with the number of unmatched bras. Question.3 Design a FSM which will accept a binary string not containing 000. Here's a starting point for you. Remember, the FSM has to signal when any string is inout which does not contain 000. If a string with 000 is presented then no further strings are accepted since the 'death string' has been processed. Ouch. Question 4. States Waking Up It's morning again. Your world consists of your bed, your alarm clock and your mobile phone. Possible states are sleeping, alarm buzzing, turning off alarm, pressing snooze button, getting up. 1. Draw out a state diagram graph for these states 2. Label transitions between the states that have meaning for you 3. Look at your state diagram. Is it possible for you to leave the house with the alarm switched on? 4. Compare and contrast your state diagram with a friend. 5. Now add in the answering phone state. Can you now leave the house with the alarm on? Question 5. UCW is full of FSM's 1. Make a comprehensive list of all machines (eg vending machines (eg drink dispenser)) at UCW which may be modelled using the FSM approach 2. Choose one machine and produce a comprehensive FSM state diagram. Produce it directly if you like or by the 'reducing the tree' method used with the coke machine in class. Question 6. Here the problem is to design an FSM which will recognize the occurrence of "0110" in any series of input bits, sunce as 0100100010110010101010110. Below you can see a student's attempt to solve the problem. Does it work? How well does it work? Can you improve on it? Or is it a load of balls with some weird links? OK Solve the problem yourself. Question 7. Design an FSM controller for a safe lock. The lock should only open if the sequence RLLRR is received. Any other sequence should sound the alarm. ACTIVITIES 2 Question 8. Load up the FSM Robot Simulator from HERE. Unzip the folder and drop on your desktop. Now double click on the executable jar file *.jar" Note this is experimental software currently under development for you. The version we are using today is still a little rough. Fingers crossed. 1.1 Make a FSM Table so that the robot will move forwards until its left bumper hits. Then it should move backwards for ever. Load RWorld1. 1.2 Make a FSM Table so that the robot moves forwards until it hits the obstacle when it should turn right (clockwise) until its bumper is clear, when it should go straight on. 1.3 Single step the machine (brown man). Confirm your expectations. What happens when the robot hits the wall? Why does it not respond to the wall? Question 9. Load up "Controller 1" and "World4". The FSM was designed to allow the robot to move in and then out of the channel. But there's a mistake and it doesn't work well. 9.1 Observe the behavior of the robot. 9.2 Look at the FSM table and work out what is going on 9.3 There is an error in the table. Find it and correct it. Demonstrate the correct code to your tutor or friend. Question 10. Let's say we want to get the robot to go around the edge of a square block. We could use its left feeler to probe for the edge of the block, and use this left feeler as the robot moves around the block. Consider the left feeler touching the block. How should we instruct the robot to move? Consider the left feeler not touching the block - the robot is moving away from the block. How should we instruct the robot to move? Draw a state diagram for this problem. Fill out a FSM table and try out your solution using "World2" One correct solution is found in "Controller2.txt" ACTIVITIES 3 Digital Electronic Finite State Machine The following activities lead you through the procedure to construct a FSM in digital electronic hardware. Question 1 First let’s attack a paper-based question to review the principles of a FSM constructed from a memory chip and a latch chip. Then we shall implement this design using MultiMedia Logic simulator. The sketch below shows a memory chip with 16 cells (0 to F), each cell contains 4 bits of data. Two of these bits are used as outputs, the other two bits are recycled to provide the address information of the next state. The four bit emerge from the memory chip at its bottom and pass into the 4-bit data register shown there. The two address bits emerging from this data register are complemented by a further two input bits a and b which together form a 4-bit address which is shown on the left. [modify diagram to make order of these address bits explicit] 1.1 Complete the contents of the memory so that when input b=0, then the output data will repetitively cycle between the values 0 -> 1 ->2 ->3 ->0 and so on. Take input a=0; 1.2 Modify your table so that in addition to the above output, the FSM generates the reverse sequence 3 -> 2 -> 1 -> 0 -> 3, etc when input b=1. Take input a=0; 1.3 Explain how you would need to modify the above circuit to be able to drive a system of traffic lights through the states “red”, “red and amber”, “green”, “amber” and back to “red”. 1. Configure the above ROM with latch so that when input b is 0 then the outputs cycle through the sequence 0 -> 1 -> 2 -> 3 -> 0 -> …, and when input b I 1, the outputs cycle through 3 -> 2 -> 1 -> 0 -> 3 -> … Input a is set always to 0. 2. Explain how you would need to modify the above system to be able to drive a system of traffic lights through the states “red”, “red and amber”, “green”, “green”, “amber”, “red”. 3. Explain how you would modify your design so that if a pedestrian pressed a button (say “a”) then the lights would go to “amber” then “red”. Question 2. Here is a Multimedia Logic Circuit which implements the Finite State Machine presented above. The memory cell, top centre is the ROM, and the two rectangular “flipflops” make up the latch. The top two LEDs are the data output from the system. The additional OR-Gates have been included simply to reset the machine to a distinct starting state. N.B. When you start each simulation, set the “Reset” switch to “1”, then press the “Clock” switch, and the reset the Reset switch (!) to “0”. This will reset the circuit. Note also that the two lowest bits of the data output are fed back to the address lines, all other address lines are held at 0. So if the memory data is 02, then the next memory location is 2. If the memory data is 31 then the next memory location is 1. The data output to the LEDs comes from the high nibble. So if you have data 12 or 10 or 11 in memory, then the output in all cases will be “1”. Then the left “1” is output. Similarly all data 32, 31, 30, 33 will output a “3” to the two data LEDs, while the next address will be “2”, “1”, “0”, and “3” respectively. 1. Work out suitable memory contents to cycle around four output values n0,1,2,3,0, etc. The top two LEDs should display these numbers (in binary) of course. 2. Now modify the circuit by disconnecting the third memory line from “0” and connecting it to a toggle switch. Now work out suitable memory contents so when the switch is “1” the cycle is 1,4,1,4 and when the switch is “0” the output cycle is 2,3,2,3,… 3. Modify the circuit so you can simulate a simple traffic-light controller without any pedestrian input (to cycle “red”, “red and amber”, “green”, “amber”, “red” and so on. 4. Now modify the circuit so that when a pedestrian flips a switch, the lights go “amber” then “red” then stay “red” until the switch is flipped back. ACTIVITIES 3 Advanced Work Question 1. (a) Engineer a ROM-based implementation of a Robot-controller (with behaviour of your choice) (b) Engineer a hardware implementation of this controller using digital logic gates (and a latch) and simulate its behaviour. Chapter D Finite State Machines ...................................................................................1 D1 The Notion of a State .......................................................................................1 D2. The Definition of a State Machine..................................................................3 D3. A Door Combination Lock .............................................................................4 D4. A Parity Checker.............................................................................................7 D5. Traffic Lights ..................................................................................................8 D6. Counting People Entering a Room..................................................................9 D7. The usefulness of Finite State Machines.......................................................10 D8. Acceptors and Transducers - Recognising Laughter ....................................10 D9. Recognising Text – A Computer Program Parser.........................................11 D10. Counting Brackets.......................................................................................13 D11. Designing a Soft-Drink Dispenser ..............................................................15 D12 Table-Based FSM Representation – Parity Checker....................................16 D13 Table-Based FSM Representation – Door Lock ..........................................17 D14 Setting a FSM into Digital Electronic Hardware. Parity Checker ...............17 D.15 Electronic Door Lock..................................................................................20 D.16 A ROM-Based Digital FSM Approach to the Door Lock ..........................21 D.17 A FSM Robot Controller.............................................................................26 D.10 Moore and Mealy Machines .......................................................................29 D.10 A Biological FSM in your Brain and Body ................................................30 D.11 Games Programming...................................................................................31 D.12 Roundup ......................................................................................................31 D.13 Activities .....................................................................................................32 D.10 A Discrete Logic Robot Controller............. Error! Bookmark not defined. D.10 A Car Security System................................ Error! Bookmark not defined.

DOCUMENT INFO

Shared By:

Categories:

Tags:

Stats:

views: | 5 |

posted: | 9/2/2011 |

language: | English |

pages: | 38 |

OTHER DOCS BY suchenfz

How are you planning on using Docstoc?
BUSINESS
PERSONAL

Feel free to Contact Us with any questions you might have.