Since I have SRAM chips lying around, I thought I’d use one of them to store the program. I would need to load a program into it somehow, and since it’s volatile memory I would need to  repeat this process every single time after I cut off power from the board.

Luckily I also happen to have a couple of Microchip PIC microcontrollers lying around. One of them is the PIC16F877A, a 40-pin 8-bit microcontroller that has a lot of I/O pins and also a USART port. So I used a MAX232 chip and hooked it up to the serial port of my computer. In the end I built this (don’t mind my horrible schematic drawing skills):

Schematic to upload data to SRAM

Address and data busses are connected as follows:

• A0 is connected to RE2.
• A1-A7 is connected to PORTB<1:7>.
• A8-A13 is connected to PORTA<0:5>.
• A14-A15 is connected to PORTE<0:1>.
• D0-D7 is connected to PORTD<0:7>.

The reason why I didn’t connect A0 to PORTB<0> is that it can also be used as an external interrupt (which I plan on using later).

I used the HI-TECH PIC C compiler to write code that reads 32768 bytes from the serial port and writes it to the RAM chip. Here is the code for those who would like to do something similar:

#include 

// Unsigned char typedef
typedef unsigned char  uchar;
typedef unsigned short ushort;

// Define crystal oscillator frequency
#define _XTAL_FREQ 20000000

// Define baud rate
#define BAUD_RATE 57600

// Define memory size
#define MEM_SIZE 4 * 1024

// Define some useful functions
#define HIBYTE( x ) ( ( uchar )( x >> 8 ) )
#define LOBYTE( x ) ( ( uchar )( x & 0xFF ) )

// Sets up the serial port in asynchronous mode
void SetupSerialPort( void )
{
	// Setup TXSTA register
	TX9	  = 0;	// 8-bit transmission
	TXEN  = 0;	// Transmit disabled
	TXEN  = 1;	// Transmit enabled (effectively resetting it)
	SYNC  = 0;	// Asynchronous mode
	BRGH  = 1;	// Select High Baud Rate

	// Setup RCSTA register
	SPEN  = 1;	// Enable Serial Port
	RX9	  = 0;	// 8-bit transmission
	CREN  = 1;	// Enable continous receive
	ADDEN = 0;	// Disable address detection

	// Setup SPBRG register
	// Divider is calculated as:
	// BAUD_RATE = Fosc / ( 16 * ( DIVIDER + 1 ) )
	// which gives:
	// DIVIDER = ( Fosc / ( 16 * BAUD_RATE ) ) - 1
	// which in the case of a 20MHz Fosc and baud
	// rate of DIVIDER is 20;
	#define DIVIDER ( _XTAL_FREQ / ( 16 * BAUD_RATE ) ) - 1
	#assert DIVIDER == 20
	SPBRG = DIVIDER;

	// Disable RX/TX interrupts
	TXIE = 0;
	RCIE = 0;
}

// Resets the Usart in case of errors
void ClearUsartErrors( void )
{
	// Overrun error
	if( OERR )
	{
		TXEN = 0;
		TXEN = 1;
		CREN = 0;
		CREN = 1;
	}
	// Framing error
	if( FERR )
	{
		uchar dummy = RCREG;
		TXEN = 0;
		TXEN = 1;
	}
}

// Writes a character to the serial port
void PutChar( uchar c )
{
	while( !TXIF )
	{
		ClearUsartErrors();
		CLRWDT();
	}

	TXREG = c;
	__delay_us( 60 );
}

// Reads character from the serial port without timeout
uchar GetChar( void )
{
	while( !RCIF )
	{
		CLRWDT();
		ClearUsartErrors();
	}

	return RCREG;
}

// Configures the ports
void SetupIO( void )
{
	// Set Port A and E to digitil I/O pins
	ADON   = 0;
	ADCON1 = 0b00000110;

	// Set Ports as output
	TRISA = 0x00;
	TRISB = 0x00;
	TRISC = TRISC & 0b11110001;
	TRISD = 0x00;
	TRISE = 0x00;

	// Disable !CS
	RC1 = 1;

	// Disable !WE
	RC2 = 1;

	// Disable !OE
	RC3 = 1;
}

// Writes contents of memory to serial port
void MemoryToSerial( void )
{
	uchar  data;
	ushort address;

	// Set port D as input
	TRISD = 0xFF;

	// Enable !CS
	RC1 = 0;

	// Enable !OE
	RC3 = 0;

	for( address = 0; address < MEM_SIZE; address++ )
	{
		// Set address
		uchar lowAddr  = LOBYTE( address );
 		uchar highAddr = HIBYTE( address );

 		PORTB = lowAddr;
 		RE2	  = lowAddr & 0x01;
 		PORTA = highAddr;
 		RE0	  = ( highAddr & 0x40 ) >> 6;
		RE1   = ( highAddr & 0x80 ) >> 7;

		// Read data
		data = PORTD;

		PutChar( data );
	}
}

// Writes data from serial port to memory
void SerialToMemory( void )
{
	uchar  data;
	ushort address;

	for( address = 0; address < MEM_SIZE; address++ )
 	{
 		// Read data byte
 		data = GetChar();

 		// Set address
 		uchar lowAddr  = LOBYTE( address );
 		uchar highAddr = HIBYTE( address );

 		PORTB = lowAddr;
 		RE2	  = lowAddr & 0x01;
 		PORTA = highAddr;
 		RE0	  = ( highAddr & 0x40 ) >> 6;
		RE1   = ( highAddr & 0x80 ) >> 7;

		// Enable !CS
		RC1 = 0;

		// Enable !WE
		RC2 = 0;

		__delay_us( 1 );

		// Set data
		PORTD = data;

		// Disable !WE
		RC2 = 1;

		// Disable !CS
		RC1 = 1;
	}
}

void main( void )
{
	OPTION_REG = 0xFF;
	CLRWDT();

	SetupSerialPort();
	SetupIO();

	SerialToMemory();
	MemoryToSerial();	

	while( 1 )
	{
		if( GetChar() == 'd' )
		{
			MemoryToSerial();
		}
	}

	return;
}

Here’s a short video to see it in action:

1. make an OpenGL pixel buffer
2. bind it to CUDA
3. run the raytracer kernel which fills the buffer
4. give it back to OpenGL
5. generate a texture from the buffer
6. set up orthogonal view
7. render a quad with the texture on it

The results:

and to show that the camera works (somewhat):

For those who want to combine CUDA and OpenGL is highly recommend watching this video.

I’ve been trying to setup a git server on my server which runs Ubuntu Server 9.10, but I had a lot of problems partly due to the fact that I couldn’t find a lot of information when something went wrong. But I’m a stubborn person so I persevered and succeeded in the end. This post is for those who want to setup a git server on Ubuntu and want to use git on Windows, especially with Git Extensions. This tutorial consists of two parts: setting up the server and setting up gitextensions on Windows, but there will be some switching between the server and the local Windows machine so please pay attention.

There are a lot of tutorials that cover setting up a git server but this one is a full guide to setting up a git server and the tools necessary to work with git on Windows. It also has some information I found on some mailing lists and forum posts that I found after a lot of searching. Still I take no credit for this tutorial for it is merely a collection of information I found. All credit goes to the people who actually tested these steps and bothered putting it on the internet for other people struggling with this. I try to explain everything as thorough as possible so it is a lot of text, but it’s not hard. Just read carefully and you will have git running in no time!

Setting up the git server

The server will use the git repository manager Gitosis. It’s easy to setup and it just works

1. Install Ubuntu Server (or any other flavor of Ubuntu) on your server and select the OpenSSH Server option when asked which packages you want to install. If you don’t do this or you forget it, don’t worry, we can add it with a simple command later.

2. Update your server:

sudo apt-get update
sudo apt-get dist-upgrade

You can also do sudo apt-get upgrade if you want, but if you’ve installed a fresh copy of Ubuntu you might as well fully update it. If you haven’t installed the OpenSSH Server option install it with:

sudo apt-get install ssh

3. Install the git-core package so we can use git.

sudo apt-get install git-core

4. Install the python-setuptools package which is needed by Gitosis.

sudo apt-get install python-setuptools

5. Now we can get Gitosis and set it up.

mkdir ~/src
cd ~/src
git clone git://eagain.net/gitosis.git

If everything went fine you should see something like this:

Initialized empty Git repository in /home/oguz286/src/gitosis/.git/
remote: Counting objects: 614, done.
remote: Compressing objects: 100% (183/183), done.
remote: Total 614 (delta 434), reused 594 (delta 422)
Receiving objects: 100% (614/614), 93.82 KiB | 134 KiB/s, done.
Resolving deltas: 100% (434/434), done.

6. Time to install Gitosis.

cd gitosis
sudo python setup.py install

7. Setup the ‘git’ user.

sudo adduser \
–system \
–shell /bin/sh \
–gecos ‘git version control’ \
–group \
–disabled-password \
–home /home/git \
git

The –home option need not be /home/git (I placed it on the RAID5 array in my server, instead of the system disk where the /home folder resides). Notice that the git user doesn’t have a password. This is because we will be using ssh keys to access our repositories.

Attention: we will switch to the local machine because we need to generate the ssh keys needed by Gitosis but we are not with the server just yet.

Setting up gitextensions on Windows

8. Get Git Extensions and install it on your local Windows machine.  I opted for the option to only add git to my path, so I recommend you do the same since I’m not sure if it’s necessary. The other default options are just fine so don’t change them.
9. Start Git Extensions and follow the instructions (you probably need to fill in your name and email address that is shown when you commit something). Now click ‘Remotes->PuTTY->Generate or import key‘.

This will open PuTTYgen, which we will use to generate our ssh keys. Click on ‘Generate‘ and follow what’s on the screen. After some the keys will be generated. Change the ‘Key comment‘ section to your username but make sure it has no spaces! This is important because Gitosis will use it as your username and ‘rsa-key-2010xxxx’ is a horrible representation of a user. I chose ‘OguzMeteer’ because that is my full name.

Make a new file on your desktop called ‘id_rsa.pub‘ and put the long string under the ‘Public key for pasting…’ section in that file and put that file on your server (in this example in the /tmp folder).

Click on ‘Save private key‘ and put the file somewhere safe. You will need it shortly.

Attention: the next step is performed on the server!

8. Add your public key to Gitosis.

sudo -H -u git gitosis-init < /tmp/id_rsa.pub

You can do this for each person you want to grant access to your repositories.

If everything went allright you should see something like this (depending on where your git user home is):

Initialized empty Git repository in /home/git/repositories/gitosis-admin.git/
Reinitialized empty Git repository in /home/git/repositories/gitosis-admin.git/

Yes it initializes and re-initializes, so don’t worry. And with that you are done with the server!
9. Connect to your server.
Use PuTTY to connect to your server once. This is needed because the first time you connect a server who’s public key is not known on your system it asks you if you want to accept its public key. Select ‘yes’ after connecting to your server and then close PuTTY.
10. Configure Gitosis.
This is the cool part because we will configure Gitosis by using git! In Git Extensions click on ‘Clone repository‘. You will see this:

For ‘Repository to clone‘ fill in:

git@yourserverip:gitosis-admin.git

Attention: do not add a ‘\’ after it, because then you will get error messages about the command looking dangerous and the server will close the connection! Git Extensions puts it there sometimes so look out.

‘Subdirectory to create‘ usually is the same name as the repository you want to clone so fill in ‘gitosis-admin’.

Click on ‘Load SSH key‘, select your private key and load it. You will notice that an icon will appear in your taskbar. It is ‘Pageant’ and it needs to run when you want to connect to your git repository. Most screw-ups are made here. If it isn’t running you cannot connect to you repository so make sure it is running. You can also access it through ‘Remotes->PuTTY->Start authentication agent‘. If you open it you will see that your private key is in the list and your username that you filled in the comment section is also there.

Finally click on ‘Clone‘ and you should get the result you wanted

Git Extensions asks you if you want to open the repository you just cloned. Do that and you will see the history of the repository (which consists of only 1 commit).

Now you are ready to make your own repositories!

Setting up repositories

Let’s say you have a new project called ‘myproject‘ and want to make a repository for it on your new server. Open up gitosis.conf in the directory you cloned it to. Mine contains this:

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = OguzMeteer

Let’s add ‘myproject‘ to it. Modify it like this:

[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = OguzMeteer

[group whatever]
writable = myproject
members = OguzMeteer

We’ve made a new group called ‘whatever‘. You can name it whatever you want. What’s important is the ‘writable‘ section where the name of your repository is filled in. ‘members‘ obviously is for who has access to the repository. Remember that the name of each member you want to grant access has to be exactly like what you (and they) filled in, in the comment section when generating an ssh key pair (no spaces!).

Now make a folder called myproject and create a new empty repository in it. To do this click ‘File->Close‘ and then click ‘Create new repository‘ in your already opened Git Extensions. Select your myproject folder and click ‘Initialize‘. Add some files in the folder and then click ‘Commit‘. Select the files and click ‘Stage selected files‘, write a message and then click ‘Commit‘.

There are only 2 steps left so hang in there! Click ‘Remotes->Manage remote repositories‘ and fill in like in this picture and click ‘Save‘:

Click ‘Yes‘. You will probably get an error, but don’t worry about it.

And the final step! Click ‘Commands->Push‘, select ‘origin‘ next to ‘Remote‘. If everything went fine (it should): Congratulations! You have just made a new repository on your server and committed some files

To be honest, I don’t really like Git Extensions because the Explorer integration isn’t the best there is. There is a program called TortoiseGit which is similar to TortoiseSVN for those of you who are familiar with it. It’s not as good yet, but I will install it as well and use both Git Extensions and TortoiseGit. Happy gitting!

1. First go to System->Administration->Users and Groups, type in your root password and you should get to a screen with all of your users. Now click on the ‘Manage Groups‘ button and then on the ‘Add Group‘ button. Type ‘psplink‘ in the Group name section and select your user in the Group Members section. Click on Ok and then twice on Close. Now you have to logoff and log back in for your user to be added to the new group. You can also do this with terminalcommands but quite frankly I forgot how the commands work (since I don’t add groups and users on a regular basis) and I was too lazy to find out how they work again, so that’s why I chose the GUI-approach.

2. Start psplink on your PSP and plug the usb cable in. Type this command in the terminal :

lsusb

Now you should see something like this:

Bus 005 Device 005: ID 054c:01c9 Sony Corp.
Bus 005 Device 003: ID 0c45:624f Microdia
Bus 005 Device 001: ID 0000:0000
Bus 001 Device 001: ID 0000:0000
Bus 004 Device 001: ID 0000:0000
Bus 002 Device 004: ID 046d:c019 Logitech, Inc.
Bus 002 Device 001: ID 0000:0000
Bus 003 Device 004: ID 08ff:2580 AuthenTec, Inc.
Bus 003 Device 001: ID 0000:0000

3. Find the line with Sony Corp. in it and write down the two hexidecimal numbers in front of it. In my case it’s 054c and 01c9. The first number is the vendor id and is the same for all PSP’s and the second number is the product id, which is hardcoded in usbhostfs_pc so it should be the same for everybody. There is a way to change the product id by either changing it in the sourcecode and recompiling it or by supplying the wanted product id in the psplink.ini file on your PSP. Here’s how mine looks like:

# Example psplink configuration file.

# pid=num Set the product ID for hostfs allows you to use multiple PSPs at one time
# Must specify the PID using the -p option of usbhostfs_pc
# pid=0x1C9

# pluser=[0 1] Enable the PSPLink user module
pluser=0

# resetonexit=[0 1] Specify wheher to reset psplink when sceKernelExitGame
# is called
resetonexit=1

So if you wanted to change the product id (because you have more than 1 PSP for example) you would remove the ‘#‘ in front of the pid=0x1C9 line and change the hexidecimal number.

4. Now you need to create a rules file in /etc/udev/rules.d/ so type:

cd /etc/udev/rules.d
gksudo gedit 96-psplink.rules

Now edit this file to look like this:

SUBSYSTEM!=”usb_device”, GOTO=”psp_rules_end”
SYSFS{idVendor}==”054c”, SYSFS{idProduct}==”01c9″, GROUP=”psplink”, MODE=”0664″
LABEL=”psp_rules_end”

Pay attention here, you see the idVendor and idProduct tags in the second line? Replace the hexidecimal codes you got form the lsusb command with your own. If you have more than 1 PSP you could create more files like “96-psplink2.rules” for your second PSP. Save the file(s) and disconnect your psp.

5. Now open up a terminal, connect your psp and type:

usbhostfs_pc

Or if you have changed your product id:

usbhostfs_pc -p <value>

And it should say “Connected to device”. If not, then type this:

sudo udevcontrol reload_rules

If it still doesn’t work then read the instructions carefully and check if you have made an error and if it still doesn’t work you can send me and email.

I know that there are some guides out there how to setup the psptoolchain but when I followed them I still had problems compiling SDL programs. So here is my guide to installing the psptoolchain and psplibraries on Linux. I figured these out by myself and with the help of J.F.’ post on the ps2dev forums, so my thanks to him. I assume that you have basic shell knowledge like how to make a folder and how to change folders and stuff like that.

1. The first step is to have a couple of programs and libraries setup before you can compile the toolchain. These programs are stated in the readme file included in the psptoolchain package, but it wasn’t complete at the time i downloaded it, so i’ll write them here just in case. Get these programs and/or libraries (ubuntu users can use Synaptic Package Manager to install these):

• autoconf
  
• automake v1.9
  
• bison
  
• flex
  
• gcc
  
• imagemagick
  
• libreadline-dev
  
• libusb-dev
  
• libtool
  
• make
  
• ncurses (I have ncurses-base, ncurses-bin, ncurses-hex and ncurses-term)
  
• patch
  
• readline (readline-common in Synaptic)
  
• subversion
  
• texinfo
  
• wget
  
• (ubuntu-users: build-essential)

2. Now you have to get the latest psptoolchain (pspsdk is included). Open up a terminal and make a folder somewhere you’d like to have your downloaded files to reside. I use ~/Downloads where the ~/ means that it’s in my Home folder, so as an absolute path, that would be: /home/username/Downloads (username is obviously your own username).

mkdir Downloads
cd Downloads
svn co svn://svn.ps2dev.org/psp/trunk/psptoolchain psptoolchain

You will see a message like “Checked out revision xxxx” where xxxx is the newest revision, which means you just have succesfully downloaded the last version of the psptoolchain. Read the Readme file located in your Downloads/psptoolchain folder.

3. Time to compile the toolchain, but first you have to set some paths. Type this in the (still open) terminal.

cd psptoolchain
export PSPDEV=/usr/local/pspdev
export PATH=$PATH:$PSPDEV/bin

You also need to make the /usr/local/pspdev folder and give it permission to be writable by your user.

sudo mkdir -p /usr/local/pspdev
sudo chmod a+rxw /usr/local/pspdev
sudo chown username:group /usr/local/pspdev

Pay attention to the last line. You should replace username with your username and group also with your username (that’s how i do it).
Now to compile this baby:

./toolchain.sh

Ok time to sit back and relax, because now it should start compiling without errors and it can take a long time. Most people talk about an average about 3 hours, but on my laptop (Core Duo 2Ghz) it takes about 20-30 minutes. Don’t close the terminal when it’s done, we still need it. If by some accident you closed the terminal don’t worry. Just type those export-lines above here in the terminal and you are good to go.

4. When you have no errors (you should have no errors), it’s time to download and install the psplibraries package. It contains a collections of libraries such as SDL, SDL_mixer, jpeg, png, zlib etc. I recommend that you download this as well. On the terminal type the following commands:

cd ..
svn co svn://svn.ps2dev.org/psp/trunk/psplibraries psplibraries

Now you will have downloaded the lastest psplibraries package. Again read the Readme file inside the psplibraries folder.

5. Time to compile the libraries. Type these commands in the terminal:

cd psplibraries
./libraries.sh

And it should compile, again with no errors. On my laptop it takes about 20 minutes to compile so go get something to drink and relax, we are almost done.

6. Last thing you need to do is add a couple of lines to your .bashrc file in your home folder.

gedit ~/.bashrc

Add the following lines at the end of the file (and save of course):

export PSPDEV=”/usr/local/pspdev”
export PSPSDK=”$PSPDEV/psp/sdk”
export PATH=”$PATH:$PSPDEV/bin:$PSPSDK/bin”

And now you should have everything setup to start developing applications for the psp!

7. (optional) If you also want to use the pspusblink package follow these steps. On the terminal:

cd ..
cd psptoolchain/build/psplinkusb
make release

Now go to the release_oe folder inside the pspusblink folder and copy the psplink folder to your psp. On my psp the directory is the PSP/GAME folder, but yours may differ. How to use psplink can be found in the manual found in the pspusblink folder.

Congratulations, everything should be setup and working correctly now! If you have any problems, found a mistake in my guide, just mail me by clicking on the about me link and filling in the form.

The raytracer loads a mesh from a 3DS Max  file, puts a ‘room’ around it and renders the scene using only primary rays. Here is an example:

Raytracer output

The scene above consists of 1034 triangles and renders in 0.693 seconds on my Geforce 8600GT. My CPU needs around 10 seconds to render the same scene with the same detail so using the GPU is much faster.

Right now I’m in the process of implementing a BHV acceleration structure to make rendering faster. What it basically does is, it puts a bounding box around the mesh and then divides the mesh into two smaller bounding boxes. This process is repeated until some conditions are met (i.e. maximum depth reached) or when each bounding box contains a single traingle. This speeds up rendering because now the rays are checked against the bounding boxes instead of the triangles, and the bounding boxes that do not intersect with the ray don’t have to be checked.

I will ‘port’ the posts on my old website to my blog in a short while.