Design Problem 4 Solutions

Size: px

Start display at page:

Download "Design Problem 4 Solutions"

Barry Sanders
6 years ago
Views:

1 CSE 260 Digital Computers: Organization and Logical Design Design Problem 4 Solutions Jon Turner The block diagram appears below. The controller includes a state machine with three states (normal, movecursor, regenmaze). The random and vgadisplay blocks at the right are sub-circuits. The random block produces a sequence of pseudo-random bits, one bit of which is stored in pixeltype from time-totime. The vgadisplay block has an internal display memory, which is used by the controller to display the maze. At the bottom left are registers for storing new and old position values. When the cursor moves, the new value is stored in news, newy. After an update is complete, the new position is stored in oldx, oldy. The tick register is used for timing by the controller. The leftpix register stores the color value of the leftmost pixel of the middle row of a 5x5 block. This is read from the vgadisplay s internal memory so that when a cursor is written to the memory, we get the color of the leftmost pixel correct (we need to write all five pixels in a row of a 5x5 block, only two of which are used for the cursor). The linecolor and bgcolor are used to form the data that goes to the display. There are several cases here, but the details are not shown in the diagram

The state diagram appears below. It has three states, normal, regenmaze and movecursor. The circuit enters the regenmaze state after reset, in order to create an initial maze.

2 The state diagram appears below. It has three states, normal, regenmaze and movecursor. The circuit enters the regenmaze state after reset, in order to create an initial maze. In the regenmaze state, it writes each of the 5x5 blocks that make up the maze, using a random bit value to decide the type of each block (line on left side, or line on top). When it is done generating the maze, it write the cursor in the maze at the position specified by the xpos, ypos inputs. The timing of these operations is controlled by the tick register, which is incremented on every clock tick. The circuit stays in the regenmaze state until after all the steps have been done. This happens when tick reaches some value represented here by xx. When tick reaches this value, the circuit goes to the normal state. In the normal state, the circuit does nothing but wait for an input change. If the numaze input goes high, it transitions to the regenmaze state. If xpos or ypos changes, it goes to the movecursor state. In the movecursor state, the circuit writes the cursor at the appropriate location, using the xpos and ypos values. It first erases the cursor from its old position, then writes the cursor at its new position. When it is finished, the new position becomes the old position

3 Here is the source code for the mazerunner circuit MazeRunner - circuit for displaying a maze and with a cursor around maze -- Jon Turner - 9/ The maze consists of 5x5 pixel blocks organized as an array of 24 rows -- and 32 columns. Each block has a line across the top or along the left -- side A 1 on the numaze signal causes the circuit to generate and display a -- new random maze. The background color of the maze is specified by bgcolor -- and the lines that define the walls of the maze are drawn using linecolor. -- The xpos, ypos inputs specify the x and y position of the cursor in the -- maze; ypos is required to be in the range library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; use work.commondefs.all; entity mazerunner is port( clk, reset: in std_logic; numaze: in std_logic; linecolor, bgcolor: in std_logic_vector(2 downto 0); xpos, ypos: in std_logic_vector(4 downto 0); -- output signals to drive VGA display hsync, vsync: out std_logic; dispval: out std_logic_vector(2 downto 0)); end mazerunner; architecture a1 of mazerunner is component vgadisplay port ( clk, reset: in std_logic; en, rw: in std_logic; addr: in address; data: inout word; hsync, vsync: out std_logic; dispval: out std_logic_vector(2 downto 0)); end component; component random port( clk, reset: in std_logic; randbits: out std_logic_vector(0 to 15)); end component; -- signals used to read/write display buffer signal en, rw: std_logic; signal addr: address; signal data, memword: word; -- state and timer register type statetype is (normal, movecursor, regenmaze); signal state: statetype; - 3 -

4 signal tick: std_logic_vector(15 downto 0); -- old and new positions signal ypos, oldx, oldy, newx, newy: std_logic_vector(4 downto 0); signal randbits: std_logic_vector(0 to 15); signal pixeltype: std_logic; signal leftpix: std_logic_vector(2 downto 0); begin vga: vgadisplay port map(clk, reset, en, rw, addr, data, hsync, vsync, dispval); rand: random port map(clk, reset, randbits); process (clk) begin if rising_edge(clk) then -- default values of several signals en <= '0'; rw <= '1'; addr <= (others => '0'); data <= (others => 'Z'); tick <= (others => '0'); if reset = '1' then state <= regenmaze; oldx <= "00000"; oldy <= "00000"; newx <= "00000"; newy <= "00000"; elsif state = regenmaze then -- redraw maze and place cursor at specified position tick <= tick + 1; if tick(15 downto 12) < "0011" then -- Block to be written is selected using upper bits of tick; -- row number is tick(13..9), col number is tick(8..4) if tick(3 downto 0) = x"0" then pixeltype <= randbits(0); elsif tick(3 downto 0) = x"1" then en <= '1'; rw <= '0'; addr <= ("00" & tick(13 downto 9) & "00000") + (tick(13 downto 9) & " ") + (" " & tick(8 downto 4)); if pixeltype = '0' then data <= "0" & linecolor & linecolor & linecolor & linecolor & linecolor; else data <= "0" & linecolor & bgcolor & bgcolor & bgcolor & bgcolor; elsif tick(3 downto 0) <= x"5" then en <= '1'; rw <= '0'; addr <= addr + x"020"; if pixeltype = '0' then data <= "0" & bgcolor & bgcolor & bgcolor & bgcolor & bgcolor; else data <= "0" & linecolor & bgcolor & bgcolor & bgcolor & bgcolor; else -- finish up by displaying cursor and going to normal state if tick(3 downto 0) = x"0" then - 4 -

5 newx <= xpos; newy <= ypos; oldx <= xpos; oldy <= ypos; elsif tick(3 downto 0) = x"1" then -- first must read color of leftmost pixel in cursor rows en <= '1'; addr <= ("00" & newy & "00000") + (newy & " ") + x"040" + (" " & newx); elsif tick(3 downto 0) = x"3" then leftpix <= data(14 downto 12); elsif tick(3 downto 0) = x"4" then -- now write the first cursor row en <= '1'; rw <= '0'; addr <= ("00" & newy & "00000") + (newy & " ") + x"040" + (" " & newx); data <= "0" & leftpix & bgcolor & linecolor & linecolor & bgcolor; elsif tick(3 downto 0) = x"5" then -- now write the second row en <= '1'; rw <= '0'; addr <= ("00" & newy & "00000") + (newy & " ") + x"060" + (" " & newx); data <= "0" & leftpix & bgcolor & linecolor & linecolor & bgcolor; elsif tick(3 downto 0) = x"6" then state <= normal; elsif state = movecursor then tick <= tick + 1; -- erase the old cursor if tick(3 downto 0) = x"1" then -- first read the color of the left pixel in the cursor rows en <= '1'; addr <= ("00" & oldy & "00000") + (oldy & " ") + x"040" + (" " & oldx); elsif tick(3 downto 0) = x"3" then leftpix <= data(14 downto 12); elsif tick(3 downto 0) = x"4" then -- then write the first cursor row en <= '1'; rw <= '0'; addr <= ("00" & oldy & "00000") + (oldy & " ") + x"040" + (" " & oldx); data <= "0" & leftpix & bgcolor & bgcolor & bgcolor & bgcolor; elsif tick(3 downto 0) = x"5" then -- and the second cursor row en <= '1'; rw <= '0'; addr <= ("00" & oldy & "00000") + (oldy & " ") + x"060" + (" " & oldx); data <= "0" & leftpix & bgcolor & bgcolor & bgcolor & bgcolor; -- now draw the cursor in the new position elsif tick(3 downto 0) = x"6" then en <= '1'; addr <= ("00" & newy & "00000") + (newy & " ") + x"040" + (" " & newx); - 5 -

6 elsif tick(3 downto 0) = x"8" then leftpix <= data(14 downto 12); elsif tick(3 downto 0) = x"9" then en <= '1'; rw <= '0'; addr <= ("00" & newy & "00000") + (newy & " ") + x"040" + (" " & newx); data <= "0" & leftpix & bgcolor & linecolor & linecolor & bgcolor; elsif tick(3 downto 0) = x"a" then en <= '1'; rw <= '0'; addr <= ("00" & newy & "00000") + (newy & " ") + x"060" + (" " & newx); data <= "0" & leftpix & bgcolor & linecolor & linecolor & bgcolor; elsif tick(3 downto 0) = x"b" then -- update old position and go back to normal state oldx <= newx; oldy <= newy; state <= normal; else -- normal state - nothing to do, but switch to other states if numaze = '1' then state <= regenmaze; elsif xpos /= oldx or ypos /= oldy then newx <= xpos; newy <= ypos; state <= movecursor; end process; end a1; - 6 -

7 Here is the source code for displaymod Display Module for mazerunner -- Jon Turner, 10/ This circuit displays the color values used by the mazerunner circuit -- to draw the maze, and the current x and y positions of the cursor. -- The first line of the display provides labels (lc, bc, xp and yp), -- while the second gives the actual values library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; use work.commondefs.all; entity displaymod is port( clk, reset : in std_logic; -- internal interface for controlling display linecolor, bgcolor: std_logic_vector(2 downto 0); xpos, ypos: std_logic_vector(4 downto 0); -- connections to external pins lcd: out lcdsigs); end displaymod; architecture a1 of displaymod is component lcddisplay port( clk, reset : in std_logic; -- internal interface for controlling display update: in std_logic; -- update a stored value selekt: in std_logic_vector(4 downto 0); -- character to replace nuchar: in std_logic_vector(7 downto 0); -- new character value -- connections to external pins lcd: out lcdsigs); end component; -- signals for controlling lcddisplay signal update: std_logic; signal selekt: std_logic_vector(4 downto 0); signal nuchar: std_logic_vector(7 downto 0); -- timing signal constant tickwidth : integer := 6+10*operationMode; signal tick: std_logic_vector(tickwidth-1 downto 0); type hex2asciimap is array(0 to 15) of std_logic_vector(7 downto 0); signal hex2ascii: hex2asciimap := ( x"30",x"31",x"32",x"33",x"34",x"35",x"36",x"37",x"38",x"39", x"61",x"62",x"63",x"64",x"65",x"66" -- a-f ); begin ldc: lcddisplay port map(clk,reset,update,selekt,nuchar,lcd); process(clk) begin - 7 -

8 if rising_edge(clk) then if reset = '1' then tick <= (others => '0'); else tick <= tick + 1; selekt <= tick(4 downto 0); update <= '0'; if tick(tick high downto 5) = (tick high downto 5=>'0') then update <= '1'; case tick(4 downto 0) is when "00001" => nuchar <= x"6c"; -- l when "00010" => nuchar <= x"63"; -- c end process; end a1; when "00101" => nuchar <= x"62"; -- b when "00110" => nuchar <= x"63"; -- c when "01001" => nuchar <= x"78"; -- x when "01010" => nuchar <= x"70"; -- p when "01101" => nuchar <= x"79"; -- y when "01110" => nuchar <= x"70"; -- p when "10010" => nuchar <= hex2ascii(int("0" & linecolor)); when "10110" => nuchar <= hex2ascii(int("0" & bgcolor)); when "11001" => nuchar <= hex2ascii(int("000" & xpos(4))); when "11010" => nuchar <= hex2ascii(int(xpos(3 downto 0))); when "11101" => nuchar <= hex2ascii(int("000" & ypos(4))); when "11110" => nuchar <= hex2ascii(int(ypos(3 downto 0))); when others => nuchar <= x"20"; end case; - 8 -

9 Here is the source code for the testbench Testbench for mazerunner (top level test) -- Jon Turner - 10/ library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; use ieee.numeric_std.all; use work.commondefs.all; use work.txt_util.all; entity testall is end testall; architecture a1 of testall is component top port( clk: in std_logic; -- buttons and knob, switches and LEDs btn: in buttons; knob: knobsigs; swt: in switches; led: out leds; -- external signals to display lcd: out lcdsigs; -- signals to vga display hsync, vsync: out std_logic; dispval: out std_logic_vector(2 downto 0)); end component; signal clk: std_logic := '0'; signal rot: std_logic_vector(1 downto 0); signal btn: buttons := (others => '0'); signal knob: knobsigs := (others => '0'); signal swt: switches; signal led: leds; signal lcd: lcdsigs; signal hsync, vsync: std_logic; signal dispval: std_logic_vector(2 downto 0); constant clkp : time := 20 ns; constant pause : time := 8*clkP; type testvector is record reset, numaze, load, xysel, colorsel: std_logic; color: std_logic_vector(2 downto 0); turns: integer; -- number of times to turn knob pause: time; end record; type testdata is array(natural range <>) of testvector; constant td: testdata(0 to 20) := ( -- row 1,2 just reset the ciruit -- row 3 turns the knob clockwise 3 times (incrementing xpos) -- row 5 turns the knob clockwise twice while selecting y -- row 7 turns the knob counter-clockwise (decrementing xpos) -- row 9 changes the background color - 9 -

10 ); -- row 11 changes the line color -- row 13 generates a new maze -- row 15 turns the knob clockwise once in the new maze -- reset numaze load xysel colorsel color turns pause 1 => ('1', '0', '0', '0', '0', "000", 0, pause), 2 => ('0', '0', '0', '0', '0', "000", 0, 350 us), 3 => ('0', '0', '0', '0', '0', "000", 3, 2 us), 5 => ('0', '0', '0', '1', '0', "000", 2, 2 us), 7 => ('0', '0', '0', '0', '0', "000", -2, 2 us), 9 => ('0', '0', '1', '0', '0', "110", 0, pause), 11 => ('0', '0', '1', '0', '1', "010", 0, pause), 13 => ('0', '1', '0', '0', '0', "000", 0, 350 us), 15 => ('0', '0', '0', '0', '0', "000", 1, 2 us), others => ('0', '0', '0', '0', '0', "000", 0, pause) begin uut: top port map (clk, btn, knob, swt, led, lcd, hsync, vsync, dispval); process begin -- clock process clk <= '0'; wait for clkp/2; clk <= '1'; wait for clkp/2; end process; knob(2 downto 1) <= rot; knob(0) <= '0'; process begin -- stimulus process rot <= "00"; wait for pause; for i in td'low to td'high loop -- set buttons and switches from test data vector btn <= (0 => td(i).reset, 1 => td(i).numaze, 2 => td(i).load, 3 => td(i).xysel); -- swt <= (3 => td(i).colorsel, (2 downto 0) => td(i).color); swt(3) <= td(i).colorsel; swt(2) <= td(i).color(2); swt(1) <= td(i).color(1); swt(0) <= td(i).color(0); if td(i).turns > 0 then -- turn knob right turns times for i in 1 to td(i).turns loop rot <= "01"; wait for pause; rot <= "11"; wait for pause; rot <= "10"; wait for pause; rot <= "00"; wait for pause; end loop; elsif td(i).turns < 0 then -- turn knob left turns times for i in 1 to -td(i).turns loop rot <= "10"; wait for pause; rot <= "11"; wait for pause; rot <= "01"; wait for pause; rot <= "00"; wait for pause; end loop; wait for td(i).pause; end loop; assert (false) report "Simulation ended normally." severity failure; end process; end;

The figure below shows an overview of the simulation. More detailed views are on later pages. Note the mazerunner states changing in response to the inputs from the testbench.

11 The figure below shows an overview of the simulation. More detailed views are on later pages. Note the mazerunner states changing in response to the inputs from the testbench. In this view, you can also see some of the changes to the xpos and ypos values and the changes to the colors. You can also observe the final color values in both the leds and the character buffer of the lcd display. And you can see the final values of xpos and ypos in the lcd character buffer. These observations allow us to conclude that the inputs are properly controlling these internal values and that the lcd display is getting the values it is supposed to display. Of course, the ultimate proof for the lcd can only come with viewing the running circuit on the S3 board

This next section shows the very beginning of the simulation, at the start of the maze regeneration following reset. At left, we see the circuit writing data to addresses 0, x020, x040, x060 and x080.

12 This next section shows the very beginning of the simulation, at the start of the maze regeneration following reset. At left, we see the circuit writing data to addresses 0, x020, x040, x060 and x080. At right, we see it writing to data to addresses 001, 021, 041, 061 and 081. These are the addresses for the first two 5x5 blocks in the top row. We can also see that the first word is getting a different value from the other words. This indicates that in both blocks, the line appears on the top. Although we can t see the data values for the first words of each block, we can infer they must be zero and we can see that the other words get the value o77777, which means that all the pixels are white

13 The next section shows the writing of a block for which the line is along the left side of the block, rather than the top. Notice that all lines of the block have 0 in the first pixel (black) and 7 in the remaining four pixels (white)

The simulation continues below, with the writing of the cursor at the end of the maze regeneration process. At left, we see the circuit reading from the display buffer (en=1 and rw=1).

14 The simulation continues below, with the writing of the cursor at the end of the maze regeneration process. At left, we see the circuit reading from the display buffer (en=1 and rw=1). The address of 040 indicates that we re reading the third line of the first 5x5 block. The returned value is o At right, we see the cursor being written to addresses 040 and 060 (the third and fourth lines of the first 5x5 block). The new data value is o77007, giving us a white square, 2 pixels wide by 2 pixels high

15 This next figure shows a section near the middle of the simulation run (just before the maze is generated a second time). At the left, we can see some changes happening to xpos, as a result of the knob turning. In the middle, we see changes to ypos as the knob turns while xyselect is high. And at right, we see xpos getting smaller as the knob is turned in the other direction. We can see the memory signals in mazerunner changing in response to the changes in xpos and ypos, although we can t see the details at this resolution. Those details can be seen on the next page

16 Here is a view showing the details of the memory signals, as a result of ypos changing from 0 to 1 (near left of figure). Near the middle of the figure, we can see the circuit read the third line from the block containing the cursor. This line has the value o To the right of this, we can see the circuit writing o77777 to the third and fourth lines of that block, effectively erasing the cursor. Continuing to the right, we can see the circuit read the third line from the block where the cursor is to go. This line has the value o07777, indicating that the line is on the left side of the block. At the far right, we see the circuit writing o07007 in the third and fourth lines of the block, effectively drawing a black cursor within the white background

This final detail of the simulation shows the writing of the first block of a new maze with new colors. Notice that the line color is now 2 (green) and the background color is 6 (yellow).

17 This final detail of the simulation shows the writing of the first block of a new maze with new colors. Notice that the line color is now 2 (green) and the background color is 6 (yellow). We see data being written to addresses x00, x20, x40, x60 and x80 (the five words that make up the first block). The value o22222 is written in the first word, giving us a green line across the top of the block, and o66666 is written to the four other words, giving us the yellow background

CSE 260 Digital Computers: Organization and Logical Design. Exam 2. Jon Turner 3/28/2012

CSE 260 Digital Computers: Organization and Logical Design Exam 2 Jon Turner 3/28/2012 1. (15 points). Draw a diagram for a circuit that implements the VHDL module shown below. Your diagram may include