Angepinnt skoe erzählt C in 14 Tagen


    • skoe
    • 35335 Aufrufe 97 Antworten

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

    • deine postings hier im forum beweisen aber das gegenteil ; )

      hä...häää.hää..
      Vielleicht hat das nichts mit dem cc65 zu tun, sondern weil die Zutaten wie Zucker, Zimt und Kakao nicht richtig zusammengestellt worden sind.


      mfg
    • und wie der zufall will bastel ich grad an einem derartigen wrapper....

      Geile sache Sauhund, wenn diese genutzt werden können.
      Toll... :bia

      Viel Speicher habe ich nicht mehr auf dem c64 , weil ich 2x 8kb Screens brauche für meine Grafik während des Programmablaufes.

      Daumen drück... :juhu:

      mfg
    • Dadurch, dass Du nur einen Schalter umsetzen brauchst, um ein Programm für den Plus4, C64, NES etc. zu erzeugen, ist der Code ja portabel.

      Da jeder 8Bitter auch von Pokes/Peek lebt, die hier da mal was mit dem System zu tun haben ist das nur im begrenzten Maße sinnvoll.

      Bei "Hallo Welt", habe ich keine Zweifel.


      mfg
    • Da jeder 8Bitter auch von Pokes/Peek lebt, die hier da mal was mit dem System zu tun haben ist das nur im begrenzten Maße sinnvoll.


      jein. der trick ist, grade wenn man in C entwickelt, derartige systemspezifische sachen einfach jeweils in unterroutinen zu kapseln. dann bleibt der hauptteil des codes immer portabel und du musst für eine neue zielplatform nur die systemspezifischen teile neu schreiben. genau auf dem prinzip arbeiten ja auch sämtliche bibliotheken die bei einem jeden c-compiler dabei sind. auch auf einem pc kriegst du ohne "peeks und pokes" nichts auf den bildschirm :)
    • Und gerade der cc65 bringt ja jede Menge leckere Blibliotheks-Funktionen mit, die z.B. die Joystickabfrage zwischen den verschiedenen Systemen so kapselt, dass sie im Quelltext des Hauptprogramms nicht unterschieden werden brauchen. (Das ist im Prinzip die gleiche Aussage, die sauhund gerade geschrieben hat, nur jetzt konkret auf diesen Compiler gemünzt.)
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      Bau Dir ein eigenes Modul! EasyFlash
    • Leider funktioniert der serielle Teil nicht vom cc65. Habe mir dann einen selber geschrieben in ASM bzw habe den altbewährten Open-Befehl genommen für die serielle Schnittstelle, die jetzt damit funktioniert. Auch der Joystickteil funktioniert nicht beim cc65. Sogar ein Autor, der eine Demo im cc65 mit reingesetzt hat, hat eine eigene geschrieben, natürlich waren das Pokebefehle.
      Also man kommt nicht drum rum. Das meine ich damit, das der 8Bitter seine eigenheiten hat, die man nicht unter einem Hut packen kann.

      mfg
    • Hallo Leute,

      habe bei dem ersten Teil des Kurses die Installation unter Linux beschrieben. Am Beispiel von Ubuntu, sollte aber ähnlich bei anderen Distributionen funktioneren.

      Vielleicht ist hier jemand, der Linux benutzt, schon immer mal den cc65 installieren wollte und das mal Testen könnte?

      skoe.de/wiki/doku.php?id=ckurs:01-abend1
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      Bau Dir ein eigenes Modul! EasyFlash
    • doch die sachen funktionieren alle, hab ich selber schon benutzt.

      Glaube ich dir erst, wenn du mir den Programmcode gibst und ich die seriellen Daten mit 300baud auf meinem AVr nach draussen übertragen kann und mein Joystick das Sprite von links nach rechts schieben kann. :bia los her damit. :bia


      eventuell machst du einfach was falsch, mal daran gedacht? =P

      neiiiiiiiiiiiiiiiiiiiiiiiiiiiiii........................ :bia

      Mit dir möchte ich mal einen Saufen bis zum umfallen.

      mfg
    • So sieht die Demo für den Joy aus, ohne interne cc65 Routinen, nur die sogenannten Systemadressen:

      C-Quellcode

      1. #include <stdio.h>
      2. #include <stdlib.h>
      3. #include <string.h>
      4. #include <conio.h>
      5. #include <ctype.h>
      6. #include <peekpoke.h>
      7. #include <c64.h>
      8. #include <6502.h>
      9. #include <cbm.h>
      10. #define JOY2 0xDC00
      11. #define JOYUP 0x01
      12. #define JOYDOWN 0x02
      13. #define JOYLEFT 0x04
      14. #define JOYRIGHT 0x08
      15. #define JOYFIRE 0x10
      16. #define WAIT_WHILE_RASTERLINE_LOW while (!(VIC.ctrl1 & 0x80)) {};
      17. #define WAIT_WHILE_RASTERLINE_HIGH while (VIC.ctrl1 & 0x80) {};
      18. unsigned char SPRITE0_DATA=0x0340;
      19. unsigned char *SPRITE0_PTR=0x07F8;
      20. static const unsigned char Sprite0[64] = {
      21. 0x00, 0x00, 0x00,
      22. 0x00, 0x00, 0x00,
      23. 0x00, 0x00, 0x00,
      24. 0x0F, 0xE0, 0x00,
      25. 0x0F, 0xC0, 0x00,
      26. 0x0F, 0x80, 0x00,
      27. 0x0F, 0xC0, 0x00,
      28. 0x0D, 0xE0, 0x00,
      29. 0x08, 0xF0, 0x00,
      30. 0x00, 0x78, 0x00,
      31. 0x00, 0x3C, 0x00,
      32. 0x00, 0x1E, 0x00,
      33. 0x00, 0x0F, 0x00,
      34. 0x00, 0x07, 0x80,
      35. 0x00, 0x03, 0x80,
      36. 0x00, 0x00, 0x00,
      37. 0x00, 0x00, 0x00,
      38. 0x00, 0x00, 0x00,
      39. 0x00, 0x00, 0x00,
      40. 0x00, 0x00, 0x00,
      41. 0x00, 0x00, 0x00,
      42. 0x00
      43. };
      44. int main (void)
      45. {
      46. signed char richtung_x = 0;
      47. signed char richtung_y = 0;
      48. char fire=0;
      49. char x=100;
      50. char y=100;
      51. char joy;
      52. bordercolor (4);
      53. bgcolor (7);
      54. textcolor (5);
      55. cursor (0);
      56. clrscr ();
      57. memcpy (SPRITE0_DATA, Sprite0, 64);
      58. *SPRITE0_PTR = SPRITE0_DATA / 64;
      59. VIC.spr_ena = 1;
      60. VIC.spr0_color = 6;
      61. fire=0;
      62. WAIT_WHILE_RASTERLINE_LOW;
      63. SEI();
      64. while (!fire) {
      65. joy=PEEK(JOY2) & 0x1f;
      66. richtung_x=0;
      67. richtung_y=0;
      68. if (!(joy & JOYFIRE)) fire = 1;
      69. if (!(joy & JOYLEFT)) richtung_x = -1;
      70. if (!(joy & JOYRIGHT)) richtung_x = 1;
      71. if (!(joy & JOYUP)) richtung_y = -1;
      72. if (!(joy & JOYDOWN)) richtung_y = 1;
      73. x += richtung_x;
      74. y += richtung_y;
      75. WAIT_WHILE_RASTERLINE_LOW;
      76. WAIT_WHILE_RASTERLINE_HIGH;
      77. VIC.spr0_x = x;
      78. VIC.spr0_y = y;
      79. }
      80. return EXIT_SUCCESS;
      81. }
      Alles anzeigen



      Und so sieht meine selbstgestrickte Rs232-Routine aus, wo ich als Test 4 Byte mit 300baud nach draussen zum AVR-Board sende, aber es funktioniert.

      C-Quellcode

      1. #include <stdio.h>
      2. #include <stdlib.h>
      3. #include <string.h>
      4. #include <conio.h>
      5. #include <ctype.h>
      6. #include <cbm.h>
      7. #define BUFFERSIZE 128
      8. int main(void)
      9. {
      10. unsigned char *buffer;
      11. unsigned char name[6];
      12. name[0]=6;
      13. name[1]=0;
      14. name[2]=0;
      15. cbm_open (2,2,0,name);
      16. buffer = (unsigned char *) malloc(BUFFERSIZE);
      17. cgetc ();
      18. *buffer=65;
      19. cbm_write(2, buffer,1);
      20. cgetc ();
      21. *buffer=66;
      22. cbm_write(2, buffer,1);
      23. cgetc ();
      24. *buffer=67;
      25. cbm_write(2, buffer,1);
      26. cgetc ();
      27. *buffer=68;
      28. cbm_write(2, buffer,1);
      29. cgetc ();
      30. cbm_close (2);
      31. puts("Ok.");
      32. return 0;
      33. }
      Alles anzeigen



      Resultat, musste alles selber stricken.

      mfg

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von schnucke ()

    • haha :) mal guckn, wenn das hier demnächst mal passt kann ich da ja mal das ein oder andre kleine beispiel zusammenzimmern. ansonsten hab ich in der vergangenheit mal ein kleines tetris gezimmert, das benutzt auch die joysticks. allerdings war das noch bevor die ganzen treiber von cc65 in ladbare module konviertiert wurden, der source wird also mit dem aktuellen compiler bzw libraries nicht kompilieren - *sollte* sich allerdings relativ unaufwendig anpassen lassen.

      ein projekt was die seriellen routinen benutzt ist zb serial slave ... allerdings ist auch das vor den ladbaren modulen entstanden, sollte sich aber ebenso anpassen lassen.

      ach und für allesaufeinmalundsofortwissenwoller wie spider :) ... guckt mal das an (hier direkt als prg). das ist das ergebnis meiner versuche in punkto was man aus cc65 so an codequalität rauskriegen kann, wenn man auch vor dreckeligen tricks, inline assembler usw nicht zurückschreckt. da kann man ganz gut sehen das dinge wie ein eigener interupt zb kein thema sind, man zeitkritisches immer easy in assembler machen sofern man es will etc.
    • Lieber Moderator,

      danke für das Sticky-sieren der C-Kurs-Threads. Ich fühle mich geehrt :) Aber *dieser* Thread muss nicht unbedingt sein: Ganz viel OT, und was zum Topic gehört, findet sich in einem späteren "Abend" wieder.

      Aber ansonsten: Der nächste Abend ist in Arbeit, habe bis jetzt viel mit MultiColor zu tun gehabt und bin deshalb nicht viel dazu gekommen.
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      Bau Dir ein eigenes Modul! EasyFlash