FPGA Connect Four

Introduction

One of the things which is great about FPGA is their flexibility. You can also have fun creating simple games if you have an hour or two and a small development board.

With a few hours to spare, a Basys 3 dev board, a 8x8 NeoPixel array and a Pmod Con1 I was able to quickly and easily create a representation of a "connect four" type game.

This will be interesting to develop as we need real time control for the neo pixels which is something FPGA are good at along with sequential control for the game play element. This is something that perhaps could be implemented within a state machine but actually a little processor would be better.

Neo Pixel Timing

Before we rush off and create the Vivado design and the NeoPixel driver lets recap how NeoPixels work.

NeoPixels are digitally controlled red, green and blue pixels. As each color is represented by 8 bits giving a 24-bit total, this enables each pixel to display one of 16, 777, 216 colors.

NeoPixel Color Format

Each NeoPixel is actually a WS2812 LED. These LEDs contain five inputs and operate from a voltage range of 3.3V to 5.0V (VDD & VCC) with respect to ground (VSS).

Inputs and outputs from the WS2812 LEDs occurs on the DI and DO pins which are the data input and data output lines.

As each pixel requires a 24-bit word to set the RGB pixel value, both the input and the outputs use a serial self clocking format. This saves on the requirement for a clock input as well.

To transfer data, the WS2812 pixel use a non-return to zero (NRTZ) waveform.

This waveform’s bit period and duty cycle both change depending on whether the bit value represented is a 1 or 0. The timings are: T0H = 0.35μsec, T0L = 0.8μsec, T1H = 0.7μsec, and T1L = 0.6μsec. All timing values have a tolerance of ± 150nsec. These times give slightly different duration for a Low bit (1.15μsec) compared to a High bit (1.3μsec)

The observant will have noticed the 24-bit word that is applied to the NeoPixel does not contain and address field. Therefore, how does a NeoPixel know if the 24-bit value is used for itself or if it should pass on the word on its output?

How this is achieved is actually very simple, if after receiving a the 24-bit word, the NeoPixel does not receive another 24-bit word within 50 uS the value is latched in and displayed. If the NeoPixel does receive another word inside 50 uS the NeoPixel will output the previously received word.

NeoPixel output demonstrating three NeoPixels

This means we can drive potentially a infinite length of NeoPixels we are just limited by the power supply needed and the time an update takes.

Neo Pixel IP Core

To drive the NeoPixels we can use the previously developed IP core we have used before and is available here from my GitHub.

This IP block is designed to interface with a BlockRAM which has a 32 bit data width. The first address in the BlockRAM tells the block how many NeoPixels there are in the string. The IP block will then read out each memory address which contains a NeoPixel setting and output it. This enables the IP block to work with a very variable NeoPixel length. Once the number of NeoPixels have been updated and output. The IP core will then start again updating the NeoPixels from the first one with their new colours.

The state diagram for the operation is below.

Vivado Design

The design for Vivado is going to be pretty straight forward. First we need to create a new project targeting the Basys3 development board.

Once the project is created the next steps are

Create a new block diagram once the project opens

From the board tab drag across the System Clock onto to the block diagram. This will create a clocking wizard.

From the board tab drag across the reset onto the clocking wizard

Add in a MicroBlaze

Run the block automation

Set the Local Memory to 32KB

From the boards tab drag across the 4 Push Buttons

Also drag over the UART from the boards tab

Run the connection automation

The resultant block design should look like the below

Add in a AXI Bram Controller

Configure the BRAM controller to have only 1 BRAM interface

Run the connection automation, this will create the BRAM also

The resultant diagram will look like

Reconfigure the BRAM to be standalone, true dual port, no primitive registers, 32 bit interfaces.

Create a new source code file and copy the NeoPixel IP into it and add it to the block diagram. Connect this to the BRAM port B

Make the Dout of the NeoPixel external this will be connected to pin J1 on the PmodJA.

With this hardware design complete we are able to build the design and package the XSA for export to Vitis

Vitis Design

Within Vitis we need to be able to write the MicroBlaze code which will perform the game play.

We can update the Neo Pixels by writing to the BRAM and from there it will be output on the Panel by the driver we wrote above.

The one thing to remember is we have a panel of NeoPixels and the memory is addressed as a linear strip therefore we need to do a little math in our code to make the panel display how we want it it.

Our software application is pretty simple we are going to have some pretty simple rules

1. The game starts with the red player and red token is in the top left pixel

2. The player can move the token left or right using the push buttons

3, when in the desired position they can press the down key and the token will drop to the lowest unfilled place on the NeoPixel board

4. The game will then change to Green Player and thier token will be placed in the top left read for movement again.

5. The players in this version will check if there are 4 tokens of thier colour in a line

6. Pressing the up arrow resets the game.

Being able to move the token across the top row of the NeoPixels means we need to limit the movement if the player tried to move past the end NeoPixel on line one.

To keep track of which players turn it is I use an enumerated variable which defines player one or player two.

All of this is repeated in a infinite loop which checks for key presses and then takes the appropriate action.

The source code is

#include <stdio.h>
#include "platform.h"
#include "xil_printf.h"
#include "xgpio.h"
#include "xparameters.h"
#include "xbram.h"


XGpio buttons;
XBram Bram;
u32 direction;

enum player {
  RED,
  GREEN,
  BLUE
};

enum turn {
	p1,
	p2
};

enum player grid[8][8]= {};
enum turn go = p1;

int main()
{
XBram_Config *ConfigPtr;
u32 EffectiveAddr = 0x4;
u32 PrevAddr = EffectiveAddr - 0x04;
u32 x;
u32 y;
char x_max = 8;
u32 next_bit;
u32 marker;



init_platform();

print("Adiuvo Connect Four\n\r");

ConfigPtr = XBram_LookupConfig(XPAR_BRAM_0_DEVICE_ID);
XBram_CfgInitialize(&Bram, ConfigPtr, ConfigPtr->CtrlBaseAddress);

XGpio_Initialize(&buttons, XPAR_GPIO_0_DEVICE_ID);
XGpio_SetDataDirection(&buttons, 1, 0xf);

for (int i = 0; i < 64; i++ ){
	XBram_WriteReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr, 0x00000055);
	EffectiveAddr = EffectiveAddr + 4;
}
marker = 0x00005500;
XBram_WriteReg(XPAR_BRAM_0_BASEADDR,0, 0x40);
XBram_WriteReg(XPAR_BRAM_0_BASEADDR,4, marker);
EffectiveAddr = 0x04;

x = 0;
while (1){
	usleep(150000);
	direction = XGpio_DiscreteRead(&buttons,1);
	if (direction & 0x0004) {
		if (x < x_max-1){
			x = x + 1;
			EffectiveAddr = EffectiveAddr + 0x4;
			PrevAddr = EffectiveAddr - 0x04;
			XBram_WriteReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr, marker);
			XBram_WriteReg(XPAR_BRAM_0_BASEADDR,PrevAddr, 0x00000055);
			print("right\n\r");
			}
		}

	else if(direction & 0x0002) {
		if (x > 0){
			x = x - 1;
			EffectiveAddr = EffectiveAddr - 0x4;
			PrevAddr = EffectiveAddr + 0x04;
			XBram_WriteReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr, marker);
			XBram_WriteReg(XPAR_BRAM_0_BASEADDR,PrevAddr, 0x00000055);
			print("left\n\r");
			}
		}

	else if(direction & 0x0008) {
		print("down\n\r");
		for (int i = 0; i<8; i++){
			next_bit = XBram_ReadReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr + (8 * 4));
			if (next_bit == 0x00000055){
				XBram_WriteReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr, 0x00000055);

				EffectiveAddr = EffectiveAddr + (8*4);
				XBram_WriteReg(XPAR_BRAM_0_BASEADDR,EffectiveAddr, marker);
			}
			usleep(500000);
		}

		if (go == p1){
			go = p2;
			marker = 0x00550000;
		} else {
			go = p1;
			marker = 0x00005500;
		}

		if (go == p1){
				XBram_WriteReg(XPAR_BRAM_0_BASEADDR,4, marker);
			} else {
				XBram_WriteReg(XPAR_BRAM_0_BASEADDR,4, marker);
			}
		EffectiveAddr = 0x04;
		x = 0;
		}

	else if(direction & 0x0001) {
		print("up\n\r");
		}
}


cleanup_platform();
return 0;
}

Once this is compiled we can download it to the Basys3 board and play the game.

Here is a little video of me playing it

Wrap Up

This was a fun little project to create, there are some extensions which could be added to the game play such as scoring on the 7 Segment Display or auto checking for the winners.