[PSP] Tutorial 2 :: Variable, Schleifen und Eingaben

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • [PSP] Tutorial 2 :: Variable, Schleifen und Eingaben

      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.

      C-Quellcode

      1. #include <pspkernel.h>
      2. #include <pspdebug.h>
      3. #include <pspdisplay.h>
      4. #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.

      Quellcode

      1. #define printf pspDebugScreenPrintf

      Hier sagen wir dem Präprozessor das er alle SRC-Code stellen wo printf steht mit pspDebugScreenPrintf
      ersertzen soll.

      Quellcode

      1. PSP_MODULE_INFO("counter", 0, 1, 1);

      Hier teilen wir der PSP ein paar Eigenschaften unseres HomeBrews mit.

      Quellcode

      1. int exit_callback(int arg1, int arg2, void *common) {
      2. sceKernelExitGame();
      3. return 0;
      4. }
      5. int CallbackThread(SceSize args, void *argp) {
      6. int cbid;
      7. cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
      8. sceKernelRegisterExitCallback(cbid);
      9. sceKernelSleepThreadCB();
      10. return 0;
      11. }
      12. int SetupCallbacks(void) {
      13. int thid = 0;
      14. thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
      15. if(thid >= 0) {
      16. sceKernelStartThread(thid, 0, 0);
      17. }
      18. return thid;
      19. }
      Alles anzeigen

      Hier ist wieder unser Standart-Code Block ohne den unser kleines HomeBrews nicht funktionieren
      wird.

      Quellcode

      1. int main(){
      2. pspDebugScreenInit();
      3. SetupCallbacks();

      Hier rufen wir unsere main()-Funktion auf, und initialisieren den Display.

      Quellcode

      1. int counter = 0;
      2. int i = 0;
      3. 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.

      Quellcode

      1. printf("Druecke [X] um den Counter zu starten");

      Hier machen wir wieder mit printf eine einfache Text-Ausgabe auf unseren PSP-Display.

      Quellcode

      1. 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.

      Quellcode

      1. 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.

      Quellcode

      1. if(pad.Buttons & PSP_CTRL_CROSS) {
      2. break;
      3. }
      4. }

      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.

      Quellcode

      1. while(1) {
      2. sceCtrlReadBufferPositive(&pad, 1);
      3. if(pad.Buttons & PSP_CTRL_CIRCLE) {
      4. break;
      5. }


      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.

      Quellcode

      1. pspDebugScreenClear();

      Diese Funktion löscht den ganzen Text von Bildschirm sodass man wieder Platz hat =P

      Quellcode

      1. printf("Druecke [O] um den Counter zu stoppen\n");
      2. 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<-".

      Quellcode

      1. 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.

      Quellcode

      1. for(i=0; i<5; i++) {
      2. sceDisplayWaitVblankStart();
      3. }
      4. }

      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.

      Quellcode

      1. pspDebugScreenClear();
      2. printf("Counter Beendet.\n");
      3. printf("Endwert des Counters: %i", counter);
      4. sceKernelSleepThread();
      5. 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:

      C-Quellcode

      1. #include <pspkernel.h>
      2. #include <pspdebug.h>
      3. #include <pspdisplay.h>
      4. #include <pspctrl.h>
      5. #define printf pspDebugScreenPrintf
      6. PSP_MODULE_INFO("counter", 0, 1, 1);
      7. int exit_callback(int arg1, int arg2, void *common) {
      8. sceKernelExitGame();
      9. return 0;
      10. }
      11. int CallbackThread(SceSize args, void *argp) {
      12. int cbid;
      13. cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
      14. sceKernelRegisterExitCallback(cbid);
      15. sceKernelSleepThreadCB();
      16. return 0;
      17. }
      18. int SetupCallbacks(void) {
      19. int thid = 0;
      20. thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
      21. if(thid >= 0) {
      22. sceKernelStartThread(thid, 0, 0);
      23. }
      24. return thid;
      25. }
      26. int main(){
      27. pspDebugScreenInit();
      28. SetupCallbacks();
      29. int counter = 0;
      30. int i = 0;
      31. SceCtrlData pad;
      32. printf("Druecke [X] um den Counter zu starten");
      33. while(1) {
      34. sceCtrlReadBufferPositive(&pad, 1);
      35. if(pad.Buttons & PSP_CTRL_CROSS) {
      36. break;
      37. }
      38. }
      39. while(1) {
      40. sceCtrlReadBufferPositive(&pad, 1);
      41. if(pad.Buttons & PSP_CTRL_CIRCLE) {
      42. break;
      43. }
      44. pspDebugScreenClear();
      45. printf("Druecke [O] um den Counter zu stoppen\n");
      46. printf("Counter: %i", counter);
      47. counter++
      48. for(i=0; i<5; i++) {
      49. sceDisplayWaitVblankStart();
      50. }
      51. }
      52. pspDebugScreenClear();
      53. printf("Counter Beendet.\n");
      54. printf("Endwert des Counters: %i", counter);
      55. sceKernelSleepThread();
      56. return 0;
      Alles anzeigen



      Und jetzt noch die makefile Datei:

      Quellcode

      1. TARGET = counter
      2. OBJS = main.o
      3. CFLAGS = -O2 -G0 -Wall
      4. CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
      5. ASFLAGS = $(CFLAGS)
      6. EXTRA_TARGETS = EBOOT.PBP
      7. PSP_EBOOT_TITLE = Our little Counter =P
      8. PSPSDK=$(shell psp-config --pspsdk-path)
      9. include $(PSPSDK)/lib/build.mak
      Alles anzeigen


      Bei 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
    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )

    • [FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Auch wieder nettes Tut.
      Sagte dir in ICQ mal was dazu, wollte dir halt mal Hinweise geben.
      das mit dem ersetzen von Printf mit dem richtigen Funktionsname is so 50.50 gut, da es ja eig die Funktion printf gibt, aber da du die entsprechende Datei nicht brauchst klappts ja wunderbar^^[/SIZE][/COLOR][/FONT]
    • [FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Ich weiß dass es die Funktion nicht gibt auf der PSP (eig ja nicht aber egal, wieso sollte es die da geben)
      Ich sagte ja nur dass es halt nicht so optimal ist (man könnte ja in Versuchung kommen dies auch ausserhalb der PSP zu nutzen und schon hat man sich evtl. was wichtiges überschrieben.[/SIZE][/COLOR][/FONT]