In diesem Tutorial will ich euch zeigen wie man einen einfach Counter codet. Wir werden uns mit
Variable, Schleifen und Eingaben auf der PSP beschäftigen. Vorraussetzung ist das ihr Tutorial 1
gelesen habt.
#include <pspkernel.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <pspctrl.h>
Die ersten beiden Header-Datein sollten uns bekannt vorkommen. pspdisplay.h brauchen wir für
eine neue Funktion und ermöglicht uns mehr Kontrolle über das Display. pspctrl.h ermöglicht uns
die Tasten der PSP zu benutzten und Eingaben zu machen.
#define printf pspDebugScreenPrintf
Hier sagen wir dem Präprozessor das er alle SRC-Code stellen wo printf steht mit pspDebugScreenPrintf
ersertzen soll.
PSP_MODULE_INFO("counter", 0, 1, 1);
Hier teilen wir der PSP ein paar Eigenschaften unseres HomeBrews mit.
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
Hier ist wieder unser Standart-Code Block ohne den unser kleines HomeBrews nicht funktionieren
wird.
int main(){
pspDebugScreenInit();
SetupCallbacks();
Hier rufen wir unsere main()-Funktion auf, und initialisieren den Display.
int counter = 0;
int i = 0;
SceCtrlData pad;
Hier ist nun das erste wirklich neue für uns. Wir haben Variablen deklariert und definiert. Aber
was sind Variable? Variable Schlüsselbegriffe deren Werte zugewiesen werden und die immer
verändert werden können. Variable sollten immer Aussagekräftige Namen sein, damit man sofort
weiß was sie machen oder welchen Zweck sie haben. Aber erstmal zu Aufbau:
int ist der Datentyp der vor jeder Variable steht. Er sagt dem Compiler ( in diesem Fall Integer )
das die Variable counter nur ganze Zahlen aufnehmen kann. Nach dem Datentyp kommt der
Variablen Name bei uns counter. Dann wird der Variable durch den Zuweisungs-Operator = , bei uns
0 ( Null ). Jetzt sollte das Prinzip von Variaben klar sein.
Aber wenn wir uns den Code-Block genauer ansehen entdecken wir die Variable i und merken das
dass aber gar kein Aussagekräftige Name ist. In diesen Fall steht i für Inditator, es hat sich so
eingebürgert das für Zähler-Variablen immer i genommen. Also nehmen wir es einfach so hin.
Was uns als nächstes auf fällt ist das wir der Variable pad gar keinen Wert zugewiesen haben.
Man kann Variable auch einfach nur deklarieren ohne ihn ein Wert zuzuweisen wir haben das jetzt
so gemacht weil dieser Wert noch nicht fest steht, aber dazu kommen wir später noch.
printf("Druecke [X] um den Counter zu starten");
Hier machen wir wieder mit printf eine einfache Text-Ausgabe auf unseren PSP-Display.
while(1) {
Hier haben wir wieder etwas neues; eine while-Schleife. Die while-Schleife ist ganz einfach zu
verstehen ( wie eigentlich alles =P ), Der Code-Block der in ihr ist wird solange wiederholt wie die
Aussage in den Klammern () zutrifft. In den Klammern steht aber 1. In der Programmierung ist der
Wert 1 = true ( wahr ) und 0 = false ( falsch ). Also wird die while-Schleife solange wiederholt wie
ihr Inhalt zutrifft. Nun kommen wir zum Code-Block in den geschweiften Klammern.
sceCtrlReadBufferPositive(&pad, 1);
Die sceCtrlReadBufferPositive-Funktion ist in der pspctrl.h definiert, die wie am Anfang includiert
haben. Dieser Funktion übergeben wir jetzt die Variable pad. Kein Ding, wir schrieben sie einfach
in die Klammern. Jetzt übergeben wir noch den Wert 1. Die 1 setzt die Anzahl der Puffer zum lesen.
Aber wenn wir uns das alles angucken sehen wir das vor der Variable pad ein & steht. Das & steht
für 'Adress of'. Wir haben pad noch nicht definiert weil durch den &-Operators der Speicherbedarf
der Variable zugewiesen wird. Sprich, wenn wir jetzt pad auslesen würden, würden wir den Speich-
erbedarf für die Tasteneingabe sehen.
if(pad.Buttons & PSP_CTRL_CROSS) {
break;
}
}
Hier sehen wir eine if-Abfrage. Sie funktioniert ganz einfach. In den Klammern steht eine Aussage,
falls sie zutrifft wird der Code-Block in den geschweiften Klammern ausgeführt. Falls nicht, wird der
Block einfach ignoriert. In den Klammern unserer if-Abfrage steht ( Übersetzt ), falls die [X]-Taste
gedrückt wird, wird durch den Befehl break abgebrochen und somit die while-Schleife beendet.
Durch die geschweifte Klammer am Ende wird der Code-Block in der while-Schleife geschlossen.
while(1) {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CIRCLE) {
break;
}Hier wieder das gleiche wie eben nur mit der [O]-Taste. Brauch ich glaub nicht mehr erklären. Der
einzigste Unterschied ist das die while-Schleife noch nicht geschlossen ist.
pspDebugScreenClear();
Diese Funktion löscht den ganzen Text von Bildschirm sodass man wieder Platz hat =P
printf("Druecke [O] um den Counter zu stoppen\n");
printf("Counter: %i", counter);
Die erste Zeile sollte dir bekannt vorkommen, es ist eine einfache Text-Ausgabe. In der zweiten
Zeile wollen wir die Variable counter Ausgeben. Das machen wir indem wir den Compiler mit Hilfe
des %-Operators sagen das die Folgende Variable von Datentyp ein Integer ist ( %i = int, %ch = char).
Der zweite Parameter ist der Variablen Name in diesem Fall counter. Also wird unsere Ausgabe wie
folgt sein: "Counter: ->Wert der Variable counter<-".
counter++
Hier müssen wir die Variable counter um 1 erhöhen damit er beim nächsten Durchlauf um 1 höher ist
( macht ja sonst keinen Sinn =P ). Das machen wir indem wir ein ++ dranhängen. Dadurch immer + 1
grechnet. Wir könnten auch 'counter=counter+1' schreiben, aber counter++ ist wesentlich eleganter
und kürzer.
for(i=0; i<5; i++) {
sceDisplayWaitVblankStart();
}
}
Nun haben wir eine andere Schleife - die for-Schleife. Das Prinzip ist ähnlich wie das der while-Schleife.
In den Klammern stehen aber diesmal 3 Teile. Initialisierungsteil ; Bedinungsteil ; Aktionsteil.
Im Initialisierungsteil wird eine Variable ( i ) definiert, meisten wird sie dort auch deklariert aber das
haben wir ja schon.
Im Bedinungsteil steht wie lange die Schleife wiederholt werden soll. Bei uns solange wie der Wert 0
kleiner ist als 5.
Im Aktionsteil steht was mit der Variable 0 in jeder Schleife passiert. In unserem Fall wird sie immer
1 mehr.
Nun wird immer die sceDisplayWaitVblankStart() - Funktion aufgerunfen wenn die for-Schleife durchläuft.
Aber was macht diese Funktion? Sie macht eine "Pause" damit wir die HOME-Taste der PSP nutzen können
um das HomeBrew zu schließen.
Und mit der letzten geschweiften Klammer schließen wir den Code-Block unserer 2. while-Schleife.
pspDebugScreenClear();
printf("Counter Beendet.\n");
printf("Endwert des Counters: %i", counter);
sceKernelSleepThread();
return 0;
Die erste Funktion löscht wieder den Bildschirm, mit dem ersten printf geben wir unseren Text aus und mit
dem zweiten den Endwert unserer counter Variable. Die letzte Funtkion sollte uns wieder aus dem letzten
Tutorial bkannt vorkommen und mit return geben wir den Wert 0 für die main()-Funktion zurück.
Hier nochmal der ganze Code:
#include <pspkernel.h>
#include <pspdebug.h>
#include <pspdisplay.h>
#include <pspctrl.h>
#define printf pspDebugScreenPrintf
PSP_MODULE_INFO("counter", 0, 1, 1);
int exit_callback(int arg1, int arg2, void *common) {
sceKernelExitGame();
return 0;
}
int CallbackThread(SceSize args, void *argp) {
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}
int SetupCallbacks(void) {
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0) {
sceKernelStartThread(thid, 0, 0);
}
return thid;
}
int main(){
pspDebugScreenInit();
SetupCallbacks();
int counter = 0;
int i = 0;
SceCtrlData pad;
printf("Druecke [X] um den Counter zu starten");
while(1) {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CROSS) {
break;
}
}
while(1) {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CIRCLE) {
break;
}
pspDebugScreenClear();
printf("Druecke [O] um den Counter zu stoppen\n");
printf("Counter: %i", counter);
counter++
for(i=0; i<5; i++) {
sceDisplayWaitVblankStart();
}
}
pspDebugScreenClear();
printf("Counter Beendet.\n");
printf("Endwert des Counters: %i", counter);
sceKernelSleepThread();
return 0;Und jetzt noch die makefile Datei:
TARGET = counter
OBJS = main.o
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Our little Counter =P
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.makBei PSP_EBOOT_TITLE kommt wieder unser Name hin der auf der PSP angezeigt wird.
Das wars auch mit meinen zweiten Tutorial, hoffentlich hab ich alles gut erklärt, falls
noch Fragen sind: Stellt sie!
Mit freundlichen Grüßen Nydn