Labs

In this lab, we are creating a video controller with an FPGA, controlled by an Arduino Uno. We will design and code a memory system for pixels, and also set up the communication between the FPGA and the Arduino.

Materials Used:
• 1 Arduino Uno
• 1 USB A/B cable
• 1 DE0-Nano Development Board
• 1 Pre-built DAC circuit board
• Various resistors
• 1 VGA cable

Part I: FPGA Video Controller

1. One of the difficult parts of this lab is to get a good understanding of how each part is related to each other and how they work as a whole. The picture shows at a high level how each sub-module is connected and how the signals flow.

2. In our Verilog code, there are one top module, the DE0_NANO, and three sub-modules, IMAGE_PROCESSOR, M9K_RAM, and VGA_DRIVER. Basically, the image processor will take in data (the x and y position of the robot in the maze and wall information from the sensors). It will then assign colors for each pixel and map it to the M9K RAM. Then the VGA driver will read the memory and then output the display on the monitor. The VGA driver output will be 8 bits, three bits for red, three bits for green, and two bits for blue. Since the VGA cable is an analog cable that only has one wire for red, one wire for blue, and one wire for blue. Therefore, we need to use the pre-made DAC to convert the digital signals to analog signals so that the pixel can be properly displayed on the monitor.

3. We started by downloading the template from Fall 2018 and following the instruction to create the PLL since we need a clock to run our device. The FPGA can generate a 50 MHz Clock called CLOCK_50. We can divide this in logic, however, this approach is susceptible to clock skew. Therefore, it is much more pragmatic to use a Phase-locked loop (PLL). This will ensure that the clocks are treated in the FPGA as actual clock lines and that they remain locked in phase, preventing skew.

4. After we set up the PLL, we uploaded the example Verilog code onto the FPGA. It is supposed to show a blue screen with a black square on the top left corner since blue is the default value and we are not writing anything to the M9K RAM yet. When we uploaded onto the board, we got what we expected.

5. After we made sure the base code worked, we tried to change the color of the square on the screen. To do that, we created an always block in the DE0_NANO module. In the always block, we iterate through every pixel in the 270*270 matrix and assign it to red. Here is the Verilog code for the always block.

	always @ (posedge CLK_50) begin
		pixel_data_RGB332 <= RED;
		x_addr <= x_addr +15'd1;
		W_EN <= 1'b1;
		if (x_addr > 'SCREEN_WIDTH) begin
			y_addr <= y_addr + 15'd1;
			x_addr <= 15'd0;
			W_EN <= 1'b1;
		end
	end
		

6. We then connected one of the Arduino output to GPIO_1_D[25] of the FPGA to control the square on the screen. When the output is HIGH, the square will be red; when the output is LOW, the square will be green. The video below shows the color of the screen changing based on the input from Arduino. In the video, the Arduino signal will be high for 5 seconds and then go low for 5 seconds.

7. All of our implementations were done in the image processor. In the image processor, using the data from the Arduino about the x,y coordinates of the location of the Arduino and the wall information, we assign colors to specific pixels and send the information to the M9K RAM. We have one always block that only starts when we get an input from the Arduino. This always block assigns different colors to each pixel based on the wall information. We do not care about the location coordinate of the Arduino at this point, as we are only assigning colors to the pixels in that one 30*30 pixel grid. This information is then used in the next always block which writes pixel color assignment information to the M9K RAM constantly as long as the clock is operational. This will keep updating the color assignment for each pixel to the ram. Here, the address where this information gets stored in the ram is calculated from the location coordinates of the Arduino and the coordinates within the tile, so when new location and wall data is being inputted from the Arduino, image processor should immediately start writing the data in the new addresses while the first always block updates color assignment for each pixel, so the data for tiles in other grids don’t get overwritten. Below is our logic written in Verilog.

	always @ (arduino_in) begin
		//assign color to pixels on the 30*30 tile for one coordinate on the map
		if (left wall is there) color in the left pixels
		if (front wall is there) color in the top pixels
		if (right wall is there) color in the right pixels
	end
	
	always @ (posedge clock) begin
	//write the color assignments to M9K ram making sure to account for the offset created by the Arduino location coordinates
	end
		

8. We encountered a problem where our code would display three squares on the screen even though we only made one. With the help from the TA, we realized that we needed to change the bit widths for some of our variables. First of all, we needed to change the pixel_data_RGB332 to 4 bits. The reason was that there is limited space in the memory and we need to truncate the data so that the data will get send without being messed up. We also changed the w_addr and r_addr to 18 bits in the M9K RAM module. The video below shows our code working by displaying a 30*5 red rectangle on the top left corner of the screen. The red rectangle is produced by the image processor and got mapped to the M9K RAM. We used a digital signal from the Arduino to control the on/off of the rectangle.

Part II: Communication between FPGA and Arduino

1. There are different kinds of communication protocols, SPI, parallel bus, etc. We decided to use parallel bus communication since it is easier to implement than SPI. Also, we don’t have pin restrictions since we are using the base station Arduino and the base station only needs to communicate with the other Arduino and FPGA. Parallel communication is a method of conveying multiple binary digits (bits) simultaneously. The picture illustrates how parallel communication works.

2. To set up the parallel bus communication, we set up 11 digitals pins as the output from the Arduino. There are 11 bits because we need four bits each for x and y locations of the robots, and we also need three additional bits to send the information of the three wall sensors. Then we set up the GPIO_1_D pins on the FPGA as the input. For testing purposes, we only wired up one data line. And we programmed the Arduino to output HIGH for 5 seconds and LOW for 5 seconds to control the FPGA. If HIGH, the screen will show a 30*5 rectangle on the top left screen; if LOW, then the whole visible screen will just become green. Please refer to the video above for a working parallel communication between the Arduino and FPGA.

3. One thing that needs attention is that the DE0_NANO operates at 3.3V, and the Arduino operates at 5V. Therefore, we need to make a voltage divider when we connect the digital output from the Arduino to the FPGA GPIO pins. We used 5.6KΩ and 10KΩ resistors to make the voltage divider. So, the output of the voltage divider is:

Vout = Vin*(R2/(R1+R2)) = 5V *( 10K/15.6K) = 3.205V

4. One last thing for connecting the Arduino and the FPGA is that we also need a common ground. The picture below shows the connection between the Arduino and the FPGA.