Matt s Stoplight Simulation Machine Architecture and Assembly Language Training Matt Born June 2001

Transcription

1 Matt s Stoplight Simulation Machine Architecture and Assembly Language Training Matt Born mattborn@imsa.edu June 2001 Introduction During June, 2001, I attended the course " Machine Architecture and Assembly Language Training". During the four weeks of the course we used the Rigel R-31JP single board computer with an 8052 CPU to do experiments designed to teach us about how computers work at the lowest levels. During the last week of the course we were required to design and build a project using what we had learned during the course. This report describes my final project for that course, a stoplight simulation. There are two elements to the stoplight simulation the thinking element and the visual element (see figure 1). The thinking element is the more difficult element, though the visual element was not without it s difficulties. Interfacing the two elements also had complications, but the most important processes lie in the thinking element. A stoplight can be thought of as a state machine, which must make many yes-no decisions. These include such things as, Are there people waiting to turn left?, Has someone requested a walk signal?, Has traffic in this direction gone long enough?, and Is anyone still crossing in this direction?. These questions determine the state of the stoplight, i.e. which lights are on. This decision-making is part of the thinking element. The thinking element, which makes all of these important decisions, was an R31-JP based system. The 8052 of my R31-JP was programmed in assembly to respond to many different signals, make decisions based on those signals, and also to relay the decisions to the visual element. There are basically three sets of input signals (see table 1). Two are symmetric, and represent North-South and East-West. The third is walk signals. Rigel R31-JP SBC PC "Thinking Element" "Visual Element" Input Name Walk Left Turn Lane (N) Left Turn Lane (S) Straight Lane (N) Straight Lane (S) Left Turn Lane (E) Figure 1 - Input Description Universal walk request. Interrupt driven. Sets a flag that triggers walk signal at next red light. North left turn lane. When North-South traffic is polled, will allow left turn signal for North if pin is high. Also used to reset timeout clock for left turns. South left turn lane. When North-South traffic is polled, will allow left turn signal for South if pin is high. If both North and South are high, both North and South receive left turn signals. Also used to reset timeout clock for left turns. North straight and right turn lane. Used to reset timeout clock for North-South green lights. South straight and right turn lane. Used to reset timeout clock for North-South green lights. East left turn lane. When East-West traffic is polled, will allow left turn signal for East if pin is high. Also used to reset timeout clock for left turns.

2 Left Turn Lane (W) Straight Lane (E) Straight Lane (W) West left turn lane. When East-West traffic is polled, will allow left turn signal for West if pin is high. If both East and West are high, both East and West receive left turn signals. Also used to reset timeout clock for left turns. East straight and right turn lane. Used to reset timeout clock for East-West green lights. West straight and right turn lane. Used to reset timeout clock for East-West green lights. Table 1 - List of Inputs There are three sets of output signals as well (see table 2). These are merely on-off signals for each light. I will illustrate these output signals for North-South and the walk signals, but it should be understood that there are equivalent signals for East-West. Output Name North Red On North Red Off North Yellow On North Yellow Off North Green On North Green Off North Yellow Arrow On North Yellow Arrow Off North Green Arrow On North Green Arrow Off South Red On South Red Off South Yellow On South Yellow Off South Green On South Green Off South Yellow Arrow On South Yellow Arrow Off South Green Arrow On South Green Arrow Off Walk On Walk OffWalk On Don t Walk On Don t Walk Off Output Description Turns North red light on Turns North red light off Turns North yellow light on Turns North yellow light off Turns North green light on Turns North green light off Turns North yellow arrow on Turns North yellow arrow off Turns North green arrow on Turns North green arrow off Turns South red light on Turns South red light off Turns South yellow light on Turns South yellow light off Turns South green light on Turns South green light off Turns South yellow arrow on Turns South yellow arrow off Turns South green arrow on Turns South green arrow off Turns walk signal on Turns walk signal off Turns don t walk signal on Turns don t walk signal off Table 2 - List of Outputs With these output signals, we can control any of the output lights on the stoplight. Now we have input signals and output signals. We need to connect them in some way so that the inputs have a reasonable effect on the outputs. First, we should examine the inputs to see what transitions they might trigger. Secondly, we should examine the states and see what outputs they should turn on or off. Handling Cross Walk Requests Our first input can be the universal walk request. This stoplight uses a campus-style walk signal, whereby all traffic stops and all directions receive the walk signal at the same time. This enables pedestrians to quickly and safely get to their destination at a pedestrian-heavy and traffic-heavy intersection. It also saves pins on the 8052 micro controller, because under this system only one pin has to be used for all four walk request buttons. The walk request button cannot be successfully polled, because a pedestrian will not hold the walk button down. Therefore, the walk request button should be interruptdriven. It is also impractical to trigger a walk signal immediately upon request, because that would immensely slow traffic flow through the intersection. Instead, we should set a flag that can be tested when it is practical to trigger a walk signal. So, when the walk request button triggers an interrupt, the interrupt service routine sets a flag. And when an appropriate state is reached at the intersection, such as when no traffic is passing through the intersection, we can test the flag and decide if we want to e to another

3 state in which pedestrians can walk. After the pedestrians have crossed, we can simply pass into the state which normally would have followed the no-traffic state. Handling Left Turn Requests Next, let s deal with the left turn lane buttons. The left turn lane buttons represent an induction coil or pressure plate at the front of the left turn lane. These will serve to let us know when someone needs a left turn arrow. Since a car at the front of the lane during a red light should be stationary, we can safely poll the left turn lane buttons instead of using an interrupt for each of the four buttons, because the cars would not e and therefore the induction coils or pressure plates would not turn off. So when we begin a state where we decide if we want to give left turn signals, we should poll these signals. For example, when we start checking the East-West left turn signals to decide if we should give an arrow, there might be a car waiting on both the East left turn lane signal and on the West left turn lane signal. Then, we would want to change the output signals so that East and West would get green arrows, and keep their red lights. However, if there was a car at East but not West, we would want a different state one in which East received a green light and green arrow, but West kept it s red light. And than again, there could be no cars waiting or one waiting at West but not at East. So there are really several states that could happen after the left turn button polling state. Handling Normal Automobile Traffic Finally, we have our straight-lane inputs. The straight and right turn lanes do not really request states there are no arrows for them, and each side should get a green light periodically, regardless of if anyone is waiting to go. (This helps deal with vehicles too small to trigger pressure plates or without enough metal to trigger induction coils). They serve a secondary purpose to decide when to end a state. The left turn buttons serve a double purpose, because they also allow you to end a state. When nobody has triggered the sensors for a certain amount of time, it implies that people have stopped crossing the intersection. We can save time and be more efficient by ing on to the next state when people have ceased using the current state. Event\CuStraight Straight Left N Left S Left E Left W Left NS Left EW Walk Walk All Stop All Stop rrent State NS EW from NS from EW From NS From EW Walk Walk Walk Flag Set from NS from EW Timer All Stop All Stop Straight Straight Straight Straight Straight Straight All Stop All Stop Straight Straight Expired From NS From EW NS NS EW EW NS EW from NS from EW EW NS South Left Turn - - Left NS Left S - - Left NS Left S North Left Turn - - Left N Left NS Left N West Left Turn Left EW Left W - Left EW - - Left W - East Left Left E - - Left EW - - Left E - Turn North- South Straight NS East- West - Straight EW Table 3 Finite State Machine We now know that we need some specific states: All Way Stop State opedestrian Crossing State Left Turn Polling State otwo Way Left Turn State

4 Green Arrow / Green Arrow State Yellow Arrow / Yellow Arrow State odirection #1 Left Turn State Green Arrow and Green Light / Red Light State Yellow Arrow and Green Light / Red Light State odirection #2 Left Turn State Red Light / Green Arrow and Green Light State Red Light / Yellow Arrow and Green Light State ono Left Turns State Green Light and No Arrow / Green Light and No Arrow State Yellow Light and No Arrow / Yellow Light and No Arrow State The sub states represent possible conditions for the stoplight, based on decisions made in the greater state. Some greater states contain no sub states. The above list is a simple linear representation of half of the stoplight cycle this half deals with two opposite directions such as East and West. The other half would take care of North and South. Design of the Visual Element and Communications Protocol Since we now know what visuals need to be displayed in each state, we can start work on the visual element. For this element, I decided to use my desktop computer. Using a quick Visual Basic program that swapped bitmaps to represent changes in the lights, I constructed my visual element. The visual element was quick and easy, but another hard part came when I needed to communicate the decisions made by the R31-JP to my desktop computer. Since the R31-JP has a serial port that I can use to communicate to my computer, I needed to know how to utilize the serial port on both ends. The R31-JP came with nice examples of utilizing the serial port, and I was also able to find examples in Visual Basic and C. Since my visual display program was in Visual Basic, I chose to incorporate my visual display with the PC side of my communications element. On the R31-JP, I merged the R31-JP side of the communications element with the thinking element. Since I could now communicate between my thinking and visual elements, I was much closer to a working stoplight model. The next step was to develop a system of communication. I established a system of six-letter codes which the thinking element would send through the serial port to the visual element, to communicate the decisions. Each code indicates a different light configuration (North Go), instead of just indicating an output code (South Green On, South Green Off). Each light configuration has some lights on, and some off. By using logic to determine what light configurations could exist, we became more efficient in our communication because instead of having forty-four output codes, we can cut it down to nineteen light configurations. Configuration Name North Green Arrow North Yellow Arrow South Green Arrow South Yellow Arrow North Green South Green North-South Yellow North-South Red East Green Arrow East Yellow Arrow West Green Arrow West Yellow Arrow East Green West Green East-West Yellow East-West Red Walk Don t Walk All Off Configuration Code nglnnn nylnnn nglsnn nylsnn ngnnnn ngsnnn nynsnn nrnsnn egleee eyleee eglwee eylwee egeeee egweee eyewee erewee wwawww wnwaww xaoxxx Configuration codes in use Some of these codes are not configuration codes, and were used for debugging purposes

5 Table 4 Configuration Codes The reason this system is more efficient than simply sending output signals is because each light configuration represents some lights on, and others off, because some lights must be off while others are on. For example, when the North light becomes red, the South light also becomes red, and any greens, yellows, and arrows on those two lights turn off. When the North light becomes yellow, the South light also becomes yellow, and any greens, reds, and arrows on those two light turn off. But when the North light becomes green, and there is also a green arrow for North, there will not be a green light for South. Because under this system, there are less configuration codes to send, receive, and interp, the communication between thinking elements and visual elements becomes faster and more concise. The screenshots throughout this document are taken from the working visual element. The thinking element flawlessly made decisions based on the input signals sent to it, and decided on the necessary configuration codes to send to the visual element. The visual element interped these signals, and turned on the lights it was instructed to turn on by the thinking element through the configuration codes. This two part system worked perfectly, and though a stoplight may not look as if it represents any learning of machine architecture and assembly language, this project has shown me a lot about the inside workings of machines through working with the R31-JP.

6 Attachment 1 - Source Code Listing ;Registers used: ; ; Accumulator: used for various things, mostly as swap space ; ; B register: used for swap space ; ; r0: used as storage space for port A ; r1: used as storage space for port B ; r2: used as storage space for port C ; r3: used as a flag by the walkbutton interrupt ; r4: equivalent to noldtime -\ ; r5: equivalent to ntick variable --{See Project T0ISR) ; r6: equivalent to low byte of ntime ; r7: equivalent to high btye of ntime -/ #include <Sfr51.inc> extern code extern code extern code extern code init sdelay print crlf #define TICKS_PER_SEC 112 testdriver_seg segment code cseg at 0x00 ljmp main end cseg at 0x0B ljmp timer0 end cseg at 0x13 ljmp walkbutton end rseg testdriver_seg main: db init print 0x0A, 0x0D, "xmainx", 0x00 r3, #0x00 x00 r5, #0x00

7 r6, #0x00 r7, #0x00 b, #0x00 INITIALSTATE mainloop: ljmp WALK NS WALK EW mainloop INITIALSTATE: init db 0x0A, 0x0D, "xinitx", 0x00 clr p3.3 p1, #0x00 setb EX1 ; enable EXT INT 1 setb IT1 ; falling edge sensitive ; --- initialize Timer anl TMOD, #0F0h ; TMOD low nibble is 0 (Mode=0, 13-bit timer) setb ET0 ; enable Timer 0 interrupt (IE bit) for Timer 0. setb TCON.4 ; TR0 ; start Timer 0 (TCON bit) clr TCON.5 ; TF0 ; Timer 0 overflow flag (TCON bit) setb EA ; master interrupt enable alloff nowalkall redeastwest rednorthsouth nolefteastwest noleftnorthsouth WALK: checkwalkers: cjne r3, # b, skipwalkers db 0x0A, 0x0D, "wwalkw", 0x00 walkall a, #0x0A wait nowalkall a, #0x03 wait r3, #0x00

8 skipwalkers: NS: jb p1.0, lfnsjmp jb p1.1, lfsjmp normns: db 0x0A, 0x0D, "nnormn", 0x00 grnnorth grnsouth r6, #0 push ljmp lfnsjmp: ljmp lfsjmp: ljmp acc skipjmpnormns lfns lfs skipjmpnormns: a, r6 r7, a timeloopnormns: cjne r6, _maxtime, skiptimeoutnormns ljmp donetimechangenormns skiptimeoutnormns: cjne r4, _timeout, skiptimeoutsnormns ljmp donetimechangenormns skiptimeoutsnormns: jb p1.2, resettempctrnormns jb p1.3, resettempctrnormns a, r7 b, r6 cjne a, b, timechangenormns ljmp notimechangenormns resettempctrnormns: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonnormns: jb p1.3, waitoutbuttonnormns waitoutbuttonnormns2: jb p1.2, waitoutbuttonnormns2 ljmp notimechangenormns timechangenormns: db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangenormns

9 notimechangenormns: ljmp timeloopnormns donetimechangenormns: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yelnorthsouth a, #5 wait rednorthsouth a, #2 wait ljmp donens lfns: jnb p1.1, lfnjmp ljmp skiplfnjmp lfnjmp: ljmp lfn skiplfnjmp: db 0x0A, 0x0D, "nnsltn", 0x00 grnleftsouth grnleftnorth r6, #0 push acc a, r6 r7, a timelooplfns: cjne r6, _leftmaxtime, skiptimeoutlfns ljmp donetimechangelfns skiptimeoutlfns: cjne r4, _lefttimeout, skiptimeoutslfns ljmp donetimechangelfns skiptimeoutslfns: jb p1.0, resettempctrlfns jb p1.1, resettempctrlfns a, r7 b, r6 cjne a, b, timechangelfns ljmp notimechangelfns resettempctrlfns: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfns: jb p1.0, waitoutbuttonlfns waitoutbuttonlfns2: jb p1.1, waitoutbuttonlfns2 ljmp notimechangelfns timechangelfns:

10 db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfns notimechangelfns: ljmp timelooplfns donetimechangelfns: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yelleftsouth yelleftnorth a, #3 wait noleftnorthsouth ljmp normns lfs: db 0x0A, 0x0D, "nsltnn", 0x00 grnleftsouth grnsouth r6, #0 push acc a, r6 r7, a timelooplfs: cjne r6, _leftmaxtime, skiptimeoutlfs ljmp donetimechangelfs skiptimeoutlfs: cjne r4, _lefttimeout, skiptimeoutslfs ljmp donetimechangelfs skiptimeoutslfs: jb p1.1, resettempctrlfs a, r7 b, r6 cjne a, b, timechangelfs ljmp notimechangelfs resettempctrlfs: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfs: jb p1.1, waitoutbuttonlfs ljmp notimechangelfs timechangelfs: db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfs notimechangelfs: ljmp timelooplfs

11 donetimechangelfs: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yelleftsouth a, #3 wait noleftnorthsouth ljmp normns lfn: db 0x0A, 0x0D, "nnltnn", 0x00 grnleftnorth grnnorth r6, #0 push acc a, r6 r7, a timelooplfn: cjne r6, _leftmaxtime, skiptimeoutlfn ljmp donetimechangelfn skiptimeoutlfn: cjne r4, _lefttimeout, skiptimeoutslfn ljmp donetimechangelfn skiptimeoutslfn: jb p1.0, resettempctrlfn a, r7 b, r6 cjne a, b, timechangelfn ljmp notimechangelfn resettempctrlfn: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfn: jb p1.0, waitoutbuttonlfn ljmp notimechangelfn timechangelfn: db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfn notimechangelfn: ljmp timelooplfn donetimechangelfn: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yelleftnorth a, #3

12 wait noleftnorthsouth ljmp normns donens: EW: jb p1.4, lfewjmp jb p1.5, lfwjmp normew: db 0x0A, 0x0D, "enorme", 0x00 grneast grnwest r6, #0 push ljmp lfewjmp: ljmp lfwjmp: ljmp acc skipjmpnormew lfew lfw skipjmpnormew: a, r6 r7, a timeloopnormew: cjne r6, _maxtime, skiptimeoutnormew ljmp donetimechangenormew skiptimeoutnormew: cjne r4, _timeout, skiptimeoutsnormew ljmp donetimechangenormew skiptimeoutsnormew: jb p1.7, resettempctrnormew jb p1.6, resettempctrnormew a, r7 b, r6 cjne a, b, timechangenormew ljmp notimechangenormew resettempctrnormew: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonnormew: jb p1.7, waitoutbuttonnormew waitoutbuttonnormew2: jb p1.6, waitoutbuttonnormew2 ljmp notimechangenormew timechangenormew:

13 db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangenormew notimechangenormew: ljmp timeloopnormew donetimechangenormew: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yeleastwest a, #5 wait redeastwest a, #2 wait ljmp doneew lfew: jnb p1.5, lfejmp ljmp skiplfejmp lfejmp: ljmp lfe skiplfejmp: db 0x0A, 0x0D, "eewlte", 0x00 grnleftwest grnlefteast r6, #0 push acc a, r6 r7, a timelooplfew: cjne r6, _leftmaxtime, skiptimeoutlfew ljmp donetimechangelfew skiptimeoutlfew: cjne r4, _lefttimeout, skiptimeoutslfew ljmp donetimechangelfew skiptimeoutslfew: jb p1.4, resettempctrlfew jb p1.5, resettempctrlfew a, r7 b, r6 cjne a, b, timechangelfew ljmp notimechangelfew resettempctrlfew: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfew: jb p1.4, waitoutbuttonlfew

14 waitoutbuttonlfew2: jb p1.5, waitoutbuttonlfew2 ljmp notimechangelfew timechangelfew: db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfew notimechangelfew: ljmp timelooplfew donetimechangelfew: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yellefteast yelleftwest a, #3 wait nolefteastwest ljmp normew lfw: db 0x0A, 0x0D, "ewltee", 0x00 grnleftwest grnwest r6, #0 push acc a, r6 r7, a timelooplfw: cjne r6, _leftmaxtime, skiptimeoutlfw ljmp donetimechangelfw skiptimeoutlfw: cjne r4, _lefttimeout, skiptimeoutslfw ljmp donetimechangelfw skiptimeoutslfw: jb p1.5, resettempctrlfw a, r7 b, r6 cjne a, b, timechangelfw ljmp notimechangelfw resettempctrlfw: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfw: jb p1.5, waitoutbuttonlfw ljmp notimechangelfw timechangelfw:

15 db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfw notimechangelfw: ljmp timelooplfw donetimechangelfw: db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yelleftwest a, #3 wait nolefteastwest ljmp normew lfe: db 0x0A, 0x0D, "eeltee", 0x00 grnlefteast grneast r6, #0 push acc a, r6 r7, a timelooplfe: cjne r6, _leftmaxtime, skiptimeoutlfe ljmp donetimechangelfe skiptimeoutlfe: cjne r4, _lefttimeout, skiptimeoutslfe ljmp donetimechangelfe skiptimeoutslfe: jb p1.4, resettempctrlfe a, r7 b, r6 cjne a, b, timechangelfe ljmp notimechangelfe resettempctrlfe: db 0x0A, 0x0D, "sc - r", 0x00 waitoutbuttonlfe: jb p1.4, waitoutbuttonlfe ljmp notimechangelfe timechangelfe: db 0x0A, 0x0D, "oshgby", 0x00 inc r4 inc r7 ljmp notimechangelfe notimechangelfe: ljmp timelooplfe donetimechangelfe:

16 db 0x0A, 0x0D, "wdwlgo", 0x00 pop acc yellefteast a, #3 wait nolefteastwest ljmp normew doneew: rednorthsouth: db 0x0A, 0x0D, "nrnsnn", 0x00 a, r1 orl a, # b anl a, # b dph, #feh dpl, #01h a r1, a a, r0 orl a, # b anl a, # b dph, #feh dpl, #00h a r0, a yelnorthsouth: db 0x0A, 0x0D, "nynsnn", 0x00 grnnorth: db print 0x0A, 0x0D, "ngnnnn", 0x00 grnleftnorth: db 0x0A, 0x0D, "nglnnn", 0x00 yelleftnorth: db 0x0A, 0x0D, "nylnnn", 0x00 noleftnorthsouth: db 0x0A, 0x0D, "nnlnsn", 0x00

17 grnsouth: db print 0x0A, 0x0D, "ngsnnn", 0x00 grnleftsouth: db 0x0A, 0x0D, "nglsnn", 0x00 yelleftsouth: db 0x0A, 0x0D, "nylsnn", 0x00 redeastwest: db 0x0A, 0x0D, "erewee", 0x00 yeleastwest: db 0x0A, 0x0D, "eyewee", 0x00 grneast: db print 0x0A, 0x0D, "egeeee", 0x00 grnlefteast: db 0x0A, 0x0D, "egleee", 0x00 yellefteast: db 0x0A, 0x0D, "eyleee", 0x00 nolefteastwest: db 0x0A, 0x0D, "enlewe", 0x00 grnwest: db print 0x0A, 0x0D, "egweee", 0x00 grnleftwest: db 0x0A, 0x0D, "eglwee", 0x00

18 yelleftwest: db 0x0A, 0x0D, "eylwee", 0x00 walkall: db nowalkall: db print 0x0A, 0x0D, "wwawww", 0x00 print 0x0A, 0x0D, "wnwaww", 0x00 wait: r7, acc db 0x0A, 0x0D, "xwaitx", 0x00 push b acc, r7 waitchecker: r7, acc djnz pop sdelay b, r7 acc, b acc, waitchecker b alloff: db print 0x0A, 0x0D, "xaoxxx", 0x00 walkbutton: db 0x0A, 0x0D, "xint1x", 0x00 r3, #0x01 i timer0: push acc inc a, r5 a r5, a

19 cjne a, #TICKS_PER_SEC, t0isr01 clr a r5, a a, r6 inc a jnz r6, a t0isr01 inc a a, r7 r7, a t0isr01: pop acc i end

20 Attachment 2 Example of Finite State Machine for Stoplight Simulation Example: N E W S N E W S N E W S

21 N E W S N E W S N E W S

22 N E W S N E W S N E W S

23 State Machine: Event\CuStraight Straight Left N Left S Left E Left W Left NS Left EW Walk Walk All Stop All Stop rrent State NS EW from NS from EW From NS From EW Walk Walk Walk Flag Set from NS from EW Timer All Stop All Stop Straight Straight Straight Straight Straight Straight All Stop All Stop Straight Straight Expired From NS From EW NS NS EW EW NS EW from NS from EW EW NS South Left Turn - - Left NS Left S - - Left NS Left S North Left Turn - - Left N Left NS Left N West Left Turn Left EW Left W - Left EW - - Left W - East Left Left E - - Left EW - - Left E - Turn North- South Straight NS East- West - Straight EW Table 3 Finite State Machine