Watch the interactive presentation.
Watch the interactive presentation.
During my christmas break I finally found some time to release a project that I started during Hackweek earlier this year:
Give it a try:
As you can see, I could need some help with improving the graphics 🙂 So if you would like to help, please contact me or send a pull request on github!
Features of the game:
So now we are searching for students that would like to hack on one of our proposed projects from May 23rd – August 22nd (fulltime, 40h/week) being payed by Google (5000$ on success). Sounds like a fair deal, doesn’t it? 😉
There are even some days left to propose a new project to hack on! In that case we would try to find a suitable mentor from our community to get you started.
There are quite some interesting project proposals on our gsoc2011 wiki page, reaching from build service projects to SUSE Studio tools and distribution specific tools, as well as cross-distribution efforts.
I would like to mentor a student in the OBS Mobile project which will create a nice interface to use the buildservice from your handheld. So if you are skilled in web technologies (jquery-mobile, rails) please apply and get the chance to hack this summer of code on this exciting project!
To get in contact with the openSUSE community please join channel #opensuse-project on freenode, or our project mailinglist at email@example.com and we will help you to get started.
|This article explains how to setup all parts of the openSUSE buildservice.
It will describe the needed steps to get it running with the latest sourcecode from svn, ready to use it and develop it.
The buildservice consists of various parts, mainly the backend, the frontend (API), and different clients that connect to the API, we will set it up with the webclient.
At first we need to check out the buildservice code:
svn co https://forgesvn1.novell.com/svn/opensuse/trunk/buildservice
We need to initialize the config file, add a buildservice user, and create the working directories:
cd src/backend cp BSConfig.pm.template BSConfig.pm sudo useradd obsrun -s /bin/false sudo /usr/sbin/groupadd obsrun sudo mkdir -p /srv/obs/run /srv/obs/projects sudo chown -R obsrun /srv/obs/
This needs to be done as root or with sudo rights. To change the default directory or the user edit the BSConfig.pm file.
Now we are ready to start the servers. You should start each one in it’s own terminal to see the logfiles.
sudo ./bs_srcserver sudo ./bs_repserver sudo ./bs_dispatch sudo mkdir /tmp/state sudo ./bs_worker --root /tmp/build --statedir /tmp/state
We can create a config file for the development machine, so we don’t have to change the original one:
cd frontend; pushd config/environments; cp development_base.rb development.`hostname`.rb; popd;
Now we need to set up a database for the frontend, simply configure a database user in config/database.yml, crete the database and run:
now the database should be correctly initialized. Starting the API server with:
makes it available at: http://127.0.0.1:3001. Using a browser on this address you can change some administrative stuff. The pre-configured admin user has the credentials: Admin:opensuse
The API documentation is now available here: http://127.0.0.1:3001/apidocs/
This API can now be used by different clients, or standard tools like curl (howto).
Setting up the weblient for usage with the openSUSE.org API is very easy, and explained in the wiki.
To use it with our local frontend, we just need to change some config values:
cd webclient; pushd config/environments/; cp development_base.rb development.`hostname`.rb; popd;
FRONTEND_HOST = "localhost" FRONTEND_PORT = 3001 FRONTEND_PROTOCOL = 'http'
|Let’s start it on default port 3000 with:
As our backend does not yet have any repositories we could build packages against, the easiest way to get started is to link it against the openSUSE buildservice, so we are able to build against all repositories from there. This is unfortunately not yet possible from the admin interface, so we have to use the API directly with curl:
curl -u Admin:opensuse -T opensuse_link http://localhost:3001/source/openSUSE.org/_meta with opensuse_link being a file with this content: <project name="openSUSE.org" > <title>openSUSE.org build link</title> <description>Build against projects from build.opensuse.org</description> <remoteurl>https://api.opensuse.org/public</remoteurl> </project>
|The linked project shown in the webclient|
|Now I want to create a project that builds against this repository, and build a package inside of it to show that everything is really working. For that, we create a home project for the admin user by clicking on „Home Project“.|
We need to use curl again to add a repository from the linked buildservice as a build target:
curl -u Admin:opensuse -T _meta http://localhost:3001/source/home:Admin/_meta with _meta being a file with this content: <project name="home:Admin"> <title>Admin's Home Project</title> <description></description> <repository name="openSUSE_11.1"> <path project="openSUSE.org:openSUSE:11.1" repository="standard"/> <arch>i586 </repository> <person role="maintainer" userid="Admin"/> <person role="bugowner" userid="Admin"/> </project>
|The project is now ready to build packages against the openSUSE 11.1 repository from the linked buildservice. We could now create new packages and upload the sources and .spec files, but I will just link a package from the openSUSE buildservice to build it unchanged.|
|YAY! After some time we can see that the first package was build by our local buildservice and the RPMs are ready!|
Did you get interested in buildservice development, or did you run into some limitations that you want to fix? There also is a wiki page at:
http://en.opensuse.org/Build_Service/Junior_Projects that lists some tasks that can be done.
The buildservice community can be found on irc at #opensuse-buildservice at freenode, and on firstname.lastname@example.org (subscribe).
Toms BlinkenLED installation:
BlinkenLED is a miniature rebuild of CCC’s blinkenlights installation in Berlin.
It is a 144 (18*8) pixel matrix of LEDs. Connected to a PC via the parallel port and powered by a 5V power supply.
I build it with help of the excellent manual from the BlinkenLED Project.
As there was only Windows software available for controlling the display, I had to write my own for a solid operating system such as openSUSE.
The software includes scripts for displaying texts and Blinkenlights (*.blm) movies on the display. This way I am able to play all the movies that were originally displayed on the Blinkenlights building.
The software package includes the following tools:
bin/blinkenmovie (plays a movie in *.blm format)
bin/blinkentext (scrolls a text)
bin/blinkentest (makes tests, useful for debugging your blinken hardware)
examples/heat.sh (grepping the current temperature from the karamba weather applet and display it)
examples/loop_movie.sh (endless loop of a *.blm movie)
examples/loop_text.sh (endless scrolling of a text)
examples/now_playing.sh (read output of mp3blaster and display the current and next song)
examples/play_movies.sh (play all movies of a directory in a loop)
BlinkenLED – Downloads:
The blinkenled sourcecode has been released on sourceforge.net.
Download tarball: [blinkenled.tar.gz]
or checkout from subversion:
svn co https://svn.sourceforge.net/svnroot/blinkenled blinkenled
BlinkenLED – Photos:
BlinkenLED – related Links:
Zentrales Element ist der GameBoy Classic. Dieser soll durch eine Einsteckkarte in ein Speicheroszilloskop verwandelt werden. Das Display des Gameboys dient als Anzeige des Kurvenverlaufs, der Frequenz und des Spitzenwertes. Die Tasten steuern alle Einstellungen des Signallaufs, sowie über Menüs diverse Einstellungen der Anzeige.
Der ProgrammCode wir auf einem externen EEPROM gespeichert, von dem der GameBoy beim booten automatisch startet. Das Programm stelle eine graphische Oberfläche mit Skala und Menu zur Bedienung zur Verfügung. Die Verstärkung der Eingangssignale wird über Tastensignal gesteuert, um eine optimale Darstellung zu erreichen. Ferner ist eine Einstellung der Zeitbasis (Time/DIV) möglich.
Soft- und Hardware
Der interne Prozessor des Gameboy ist ein Z80. Er hat intern 8K Speicher, einen 8-bit Daten-BUS, 16-bit Adressen-BUS zum Zugriff auf das externe ROM. Die Programmierung soll in C und Assembler erfolgen, mit Hilfe des für Windows erhältlichen GameBoy Compilers GBDK, der bereits einige Bibliotheken bereitstellt.
GBDSO – Downloads:
Package Schaltung: (by henrike.papenfuss[at]gmx.de)
Schaltpläne, Dokumentation Schaltung.
Package Mikrocontroller: (by mike.bock[at]gmx.de)
Software, Dokumentation Mikrocontroller.
Package Gameboy-Software: (by tom[at]digitalflow.de)
Sourcecode, EPROM-Image File, GBDK Compiler, No$GMB Emulator, Dokumentation GB-Software.
GBDSO – Photos:
GBDSO – related Links:
GameBoy Mailing List
GameBoy Programming For Beginners
Gameboy Projects Page
GBDK – home
gb games download
GB Programming Info
Harry Mulder’s Gameboy Development: Main
mix asm + c
NO$FUN GB Emulator
programmierer-board.de / Quellcodes.de :: Forum anzeigen – Gameboy
Programming the Game Boy Color with the GBDK
:: Quellcodes.de :: Community und Informationsportal für Programmierer :: seit 1999
Steve’s Gameboy Page