In diesem Tutorial will ich euch zeigen wie man eine einfache Text Ausgabe auf der PSP hinbekommt.
Aber zuerst etwas Allgemeines =P
Man kann selbst geschriebene HomeBrews ( so nennt man Programme, Marke EIgenbau, auf der PSP )
nicht einfach so ausführen. Man muss die PSP flashen. Das heißt sie auf Version 1.5 Downgraden und
dann eine CFW ( CostumFrimeWare ) aufspielen. Die Offizielle FrimeWare unterstüzt kein HomeBrews
und Cracked Spiele ( welcher Hersteller will das schon ).
Nun fragt man sich wie man seine PSP den flashen kann? Das kommt auf die Version und Hardware an.
Neue Versionen sind schwierigen downzugraden als ältere. Auf dieser Seite findet ihr alles was ihr dazu
braucht.
Wenn das aufspielen der CFW geklappt hat und nun anfangen will seine HomeBrews zu coden ( man kann
auch Cracked PSP-Games spielen aber darum gehts jetzt nicht ) fragt man sich wie mach ich das den nu?
Ihr müsst erstmal wissen welche Programmier Sprache "benötogt wird". Für die PSP wird LUA, C++ und
Web Sprachen (JS,HTML,CSS,Flash ) benutzt. Wir interessieren uns aber nur für LUA und C++.
LUA hat nicht viele Vorteile, eigentlich nur das es sehr schnell zu lernen ist. Im Gegensatz zu C++ ist es
unflexible und hat nicht viele Möglichkeiten; es ist zu vergleichen mit batch. C++ bietet viel mehr
Möglichkeiten ist aber schwierigen zu lernen. Wenn man aber mit dem Syntax ( Struktur ) "klar kommt"
ist es relativ leicht ( aber was ist relativ ? ).
Da wir uns jetzt für C++ Entschieden haben ( ja haben wir ), brauchen wir erstmal eine Entwicklungs-
Umgebung ( IDE ). Man kann jeden Editor nehmen, Visual C++ Studios hebt den Syntax hervor und
rückt automatisch ein, aber der einfach MicroSoft Editor reicht auch. Nachdem ihr euren SRC-Code
( Source Code = Quelltext ) geschrieben habt müsst ihr in "Computer Sprache" umwandeln, aber wie
macht man das? Dank dem Team von PS2DEV ist dies auch möglich. Man muss nun aber cygWIN,
PSPTOOLCHAIN installieren, da dies aber fast einen Tag dauert, beite ich hier das vorkompilierte
Paket von PSPDev an. Wie das jetzt alles funktioniert werde ich euch jetzt erklären.
Schritt 1
Zuerst müsst ihr euch das vorkompilierte Paket von PSPDev downloaden. Ich hab es hier nochmal
hochgeladen. Die Installation sollter ihr eigentlich selber hinbekommen ( einfach immer auf weiter ).
Nun müssen wir erstmal ein SRC-Code schreiben den wir compilieren kann.
Erstellt eine "main.c" und öffnet diese mit dem Editor oder eurer IDE. Als erstes müssen wir
die Header-Datein inkludieren mit denen die PSP arbeitet.
#include <pspkernel.h>
#include <pspdebug.h>
Mit dem Befehlt #include sagen wir dem Compiler er soll die Header-Datei in den <> - Klammern
in den SRC-Code einbinden. In Header-Datein sind Funktionen definiert, ohne Header gibts auch keine
Funktionen. Aber was machen überhaupt pspkernel.h und pspdebug.h?
pspkernel.h ist notwendig für jedes Programm auf der PSP weil es für die PSP spezifische Befehle
enthällt. pspdebug.h ist wichtig für die Fehler Behebung da es Erorrs an den Bildschirm weitergibt.
Nun sagen wir der PSP etwas über unser Programm, es läuft zwar auch ohne aber das ist trotzdem
nicht verkehrt Eigenschaften über das Programm der PSP mit zugeben.
PSP_MODULE_INFO("Hello World", 0, 1, 1);
Es ist nicht der Name der angezeigt wird ( das kommt später ) sondern die Versions Nummer und
System-Name, der für die PSP und dem Programmierer der Übersicht dient.
Nun kommen wir zu einem SRC-Code Block der für uns nicht relevant ist sonder nur dazu dient, das
unser Programm beim Start nicht nur 1 Milisekunde geöffnet bleibt sondern solange bist wir es mit
der HOME-Taste schließen. Es wäre jetzt zu kompliziert zu erklären, deswegen belassen wir es einfach
dabei das es wie die Header-Datein notwendig zum laufen des Programms ist.
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;
}
Da wir das nun haben kommen wir zur Text-Ausgabe. Der eigentlich Befehl bei der PSP ist
pspDebugScreenPrintf aber da wir Faul sind und kein Bock haben immer diesen langen
Befehl einzutippen benennen wir in einfach um.
#define pspDebugScreenPrintf printf
Immer wenn wir jetzt printf schreiben ersetzt der Compiler es einfach mit pspDebugScreenPrintf
Das mach den SRC-Code übersichtlicher uns man muss nicht so viel schreiben.
Jedes C++ - Programm braucht einen Einsprungs Punkt und das ist immer die main() - Funktion.
Hier fängt das "Sichtbare" - Code erst an. Jetzt schreiben wir in die main()-Funktion unseren
Text mit Hilfe des printf ( pspDebugScreenPrintf ) - Befehl, aber zuerst braucht die PSP
noch etwas damit es weiß das jetzt was auf dem Bildschirm soll.
int main(){
pspDebugScreenInit();
SetupCallbacks();
Wenn ihr aufgepasst habt sehrt ihr das dies auch Funktionen sind die wir bereits deklariert und
definiert haben.
Nun kommt endlich die Ausgabe mit printf, undzwar geben wir einfach "Hello World" aus. Das
hat sich so eingebürgert das das erste Programm mit Hello World beginnt.
printf("Hello World");
sceKernelSleepThread();
return 0;
}
sceKernelSleepThread(); sagt der PSP das das Programm jetzt "einschläft" und nicht einfach
ausgeht. return 0; ist der Rückgabe-Wert der main() - Funktion. Jede Funktion muss einen Rückgabe
Wert liefern in diesen Fall einfach 0 weil die main()-Funktion mit dem Integer Datentyp ( int ) deklariert
wurde. In den Integer passen nur ganze Zahlen. Es gibt auch noch andere Datentyp wie char ( Buchstaben )
aber das ist jetzt nicht wichtig.
So das war der ganze SRC-Code. Der Übersicht halber hier noch einmal alles:
#include <pspkernel.h>
#include <pspdebug.h>
PSP_MODULE_INFO("Hello World", 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;
}
#define pspDebugScreenPrintf printf
int main(){
pspDebugScreenInit();
SetupCallbacks();
printf("Hello World");
sceKernelSleepThread();
return 0;
}
Und was jetzt? So kann die PSP damit noch nichts anfangen, jetzt müssen wir den Code in eine für
die PSP verständlich Sprache umwandeln ( compilieren ). Aber davor müssen wir noch eine "makefile"
Datei machen ( ohne Endung ).
TARGET = hello
OBJS = main.o
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = Hello World
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak
Diese müsst ihr für jedes Programm einzelnd machen. Wichtig für euch ust nur PSP_EBOOT_TITLE
denn das ist der Name der Angezeigt wird. Den Rest müsst ihr so lassen.
Schritt 2
Nun können wir es endlich compilieren ( =D ).
Dazu macht ihr auf den Datenträger einen Ordner Namens "Test" oder "First Programm" oder so etwas
ähnliches ( es ist nicht wichtig ) und packt dort die "main.c" und die "makefile" Datein rein.
Nun geht ihr in den CygWIN Ordner und startet die "bash.bat". Diese navigiert automatisch auf "C:\"
Nun tippt ihr folgendes ein:
cd "Ordner Name indem ihr die Datein habt"
Bestätigt das mit ENTER und gebt dann das ein:
make
Mit dem Befehl "make" wird der SRC-Code compiliert. Nun ist euer erstes Programm fertig. Ihr müsst nur
die "EBOOT.PBP" auf euren Speicher Stick der PSP kompieren in "PSP/GAME/Ornder Name" und könnt es
ausführen. Herzlichen Glückwunsch ihr seid jetzt PSP-Programmier =D
Falls ihr Fragen habt scheut euch nicht diese zu stellen.