Guitar Hero III tournament!

I’ve signed up for a GH3 tournament 21st to 24th of August, with a prize of 200€.
Not that I think I’m gonna win, but at least I’ll try. >:D

For the record, some info about my current GH3-status (70 songs, PS2 version):

Hard:

• Songs I didn’t beat: 0
• Songs I beat but didn’t get 5 stars at: 7
• Songs I got a 5 stars at but didn’t do a 100%: 44
• Songs I got a 100% at: 19

Expert:

• Songs I didn’t beat: 6
• Songs I beat but didn’t get 5 stars at: 11
• Songs I got a 5 stars at but didn’t do a 100%: 48
• Songs I got a 100% at: 5

Some more Prolog

%% Levenshtein distance

distance(Xs,[],N) :- size(Xs,N), !.
distance([],Ys,N) :- size(Ys,N), !.

distance([X|Xs],[Y|Ys],N) :- X = Y, !, distance(Xs,Ys,N).
distance([X|Xs],[Y|Ys],N) :- X \= Y, !, distance(Xs,Ys,D1), distance([X|Xs],Ys,D2), distance(Xs,[Y|Ys],D3), min(D1,D2,D3,N1), N is N1+1.

size([],0) :- !.
size([X|Xs],N) :- size(Xs,N1), N is N1+1, !.

min(X,Y,Z,X) :- X =< Y, X =< Z, !.
min(X,Y,Z,Y) :- Y =< Z, !.
min(X,Y,Z,Z) :- !.

Backgammon

“Backgammon is a board game for two players in which the playing pieces are moved according to the roll of dice… Although luck plays an important role, there is a large scope for strategy”

If you don’t know this game, they I strongly suggest you try it out. It’s awesome! I’ve been playing it quite a lot lately, it’s really entertaining.

I had the intention to make a Backgammon playing bot, but it looks like such a thing is harder than I may have thought at first. =/

My first Prolog program. =P

%% Tests whether a number is prime or not.

prime(X) :- integer(X), prime(2,X).
prime(N,X) :- N < X, N1 is N+1, M is X mod N, M =\= 0, prime(N1,X).
prime(X,X).

^_^

It was time for an update!

So I updated my personal website today. I had not worked on it for a while, and since now I have some free time… =)

However, I must say I’m not too happy with it… so I may change it again soon.

Solving the sudoku

I know you were eager to taste some source code, so here you have a first version of the solver.
To try it, just follow the steps described in the post below (PIC Simulator, Assembler, Assemble & Load, Run).

To verify it works, you take a look at the status of the GPRs, and if you remember what was said here, you’ll know if it has properly solved the sudoku or not.

The sudoku it solves is defined by the few hundred lines of code enclosed in the region ’sudoku input’.
If you want to try another sudoku, just do what needs to be done.

This is a first version of the solver, and managed to solve ‘very easy’, ‘easy’, ‘medium’ and some ‘hard’ sudokus of those at this site. It did solve an ‘expert’ one , too. We are currently working on an improved version.

The following flowchart shows the strategy the program uses in order to solve the sudokus:

Hello, programmer

You’ve seen that we have already used some PICs (that colour sensor video some posts ago?), so we have programmed them. You’ve seen, too, that we have made a program (in Perl) that generates some assembly code to load the information of a sudoku into memory.

But, we haven’t really got into programming yet, have we?

Since we have already coded a first version of our sudoku solving program (and a second version too, actually), the time for a ’source code’-post is not far. But before that, let’s get ready to code!
In this post, we’ll explain how to set some tools up to ease the coding process.

Firstly, we will need PIC Simulator to test our programs. Let’s explain a bit how it works.

That’s what it looks like when you start PIC Simulator. You can select there which microcontroller you are going to be working with, and at which clock speed. Also, note the section dedicated to General Purpose Registers (GPRs).

If you go to Tools -> Assembler, a text editor will open. Here’s where you are supposed to write the code. Or you can File -> Open another .asm file. Then, Tools -> Assemble & Load and the program gets loaded and ready to be run.

At this point, one basically uses Simulation and Rate tabs at the main window of the program.
The breakpoints manager (Tools -> Breakpoints Manager) is also very helpful (particularly, if you are bug-hunting). This is how it looks:

So far, so good. But the editor that comes with PIC Simulator kind of sucks, and you do realize that when you are writing a program with many lines of code.

We didn’t like it’s poor color-coding, or the fact that it didn’t have code regions. So we decided to move on to an editor that had it all: Notepad++.

It’s a great text editor and, best of all, allows you to define your own languages (user defined languages, yay!).
So we defined a PIC16F language, and that way we had colour coding that we liked, and regions! (They start with the keyword ‘;region’ and end with ‘;endregion’)

If you want to use yourself this language with Notepad++, you just have to download the userDefineLange.xml file and paste it into the folder that opens when you type ‘%APPDATA%\Notepad++’ and press OK at Start->Run.

Well, I think that’s all. You learnt how to use the basic functionality on PIC Simulator and you have a powerful editor to program in. Next, we’ll give you some source code to play around. Later dudes and dudettes!

Back

Exams are over!

I know it’s been long since my last post, I’ve been pretty busy with exams and stuff. However, the fact that I didn’t find time to post doesn’t imply that I didn’t find time to work on some stuff. So expect some news soon.

I’m currently basically working at the following (among some other things you do not care about):
-A demo with TimeScratchers. We’ll hopefully have it ready before the summer ends.
-The sudoku solving robot with the trigeekz. I’ll write some posts about it soon!

I should also mention that I (as a part of nivel21) will most surely enter the DBP challenge.

What else… I want to learn some prolog, and make a backgammon bot. Still hooked to Guitar Hero III, and watching Lost (3rd Season).

Hooray for free time!