Teil 1: Einführung

TIGCC-Tutorial für Einsteiger.

Teil 1: Einführung

Beitragvon saubue am 27. Juli 2008 00:34

a) Hello World 1

C ist im Grunde eine recht einfache Sprache, mit der man (vor allem auf dem PC) viele Möglichkeiten hat. Spiele für die 68k-Rechner (TI-89, TI-89 Titanium, TI-92plus und Voyage 200) werden mit TIGCC kompiliert, dass heisst, dass der Quellcode (im Gegensatz zu TI-BASIC) direkt in eine nur für den Prozessor lesbare Abfolge von (im Grunde) Einsen und Nullen
gebracht wird. Deshalb sind die 'ASM'-Programm auch so schnell.
Nun gut, genug der trockenen Theorie. Schreiben wir also unser erstes Programm, welches das klassische "Hello World!"-Beispiel sein wird.

Startet also TIGCC IDE und erstellt ein neues Projekt. Speichert es unter 'Hello'. Erstellt ein neues 'C Source File', dem ihr den Namen 'Hello' gebt.
Das sollte dann in etwa so aussehen:

Code: Alles auswählen
// C Source File
// Created 21.04.04; 23:24:59

// Delete or comment out the items you do not need.
#define COMMENT_STRING         "Place your comment here."
#define COMMENT_PROGRAM_NAME   "Place your program name here."
#define COMMENT_VERSION_STRING "Place your version string here."
#define COMMENT_VERSION_NUMBER 0,0,0,0 /* major, minor, revision, subrevision */
#define COMMENT_BW_ICON \
   {0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000}
#define COMMENT_GRAY_ICON \
   {0b0000000000000000, \
    0b0000000000000000, \
    0b0000000000000000, \
   
   und so weiter....


Lasst euch nicht abschrecken! Hantiert damit rum, damit es am Ende so aussieht:

Code: Alles auswählen
// C Source File
// Created 21.04.04; 23:24:59

#include <tigcclib.h>        // Alle Standard-Header-Dateien benutzen

// Haupt-Funktion
void _main(void)
{
  // Lösche Bildschirminhalt
  clrscr();           
 
  // Schreibe "Hello World!" auf den Bildschirm
  printf("Hello world!");
 
  // Auf Tastendruck warten
  ngetchx();             
}



Erstellt dann die ausführbare Datei für den TI (Project->Build). Schickt diese an TiEmu und startet sie. Normalerweise sollte jetzt "Hello World!" auf dem Bildschirm stehen. Nachdem ihr eine Taste drückt, ist das Programm zu Ende.

Nun einige Erklärungen:
Für diejenigen, die eine ältere Version von TIGCC benutzen:
Falls bei euch eine 'Programmerstellungshilfe', der Template Wizard, aufgerufen wird, wenn ihr ein neues 'C Source File' erstellen wollt, dann fügt einfach das nachfolgende in eure C Datei ein (vor dem #include <tigcclib.h>)

Code: Alles auswählen
#define SAVE_SCREEN         // LCD-Inhalt speichern

#define USE_TI89            // für alle Modelle kompilieren
#define USE_TI92PLUS
#define USE_V200


In der neuen TIGCC Verion (ab 0.95) werden diese Befehle automatisch und nicht sichtbar hinzugefügt (unter Program->Options->Compilation->Program Options könnt ihr sie verändern).

Nun zum eigentlichen Programm.
Gehen wir es Schritt für Schritt (Zeile für Zeile) durch:

Code: Alles auswählen
#include <tigcclib.h>        // Alle Standard-Header-Dateien benutzen


Hier wird festgelegt, dass alle 'Header-Dateien' benutzt werden sollen, die uns TIGCC anbietet. Zu Header-Dateien und wie man selbst welche macht, werde ich später noch kommen. Vorerst genügt zu wissen, dass wir mit diesem Befehl alle Funktionen nutzen können, die in der TIGCC-Documentation aufgelistet sind (und das sind nicht wenige..). Wenn ihr jetzt denkt: Dann müsste ein Programm ja riesig werden!, dann liegt ihr falsch. Nur die Funktionen werden mitkompiliert, die man auch verwendet (gut, gell?).

Code: Alles auswählen
// Haupt-Funktion


Wenn man zwei Schrägstriche macht, wird die ganze Zeile dahinter zur Kommentarzeile (aus TI-BASIC vielleciht mir dem Copyright-Zeichen bekannt), die die Funktionen erklärt oder für sonstige Bemerkungen gebraucht wird. Sie wird nicht kompiliert und deshalb grün markiert. Andere Möglichkeit: mit '/*' anfangen, wobei hier alles bis zum abschließenden '*/' als Kommentar interpretiert wird. Vor allem beim Programmieren in C rate ich jedem, seine Programme ja verständlich zu kommentieren, da sie mit der Zeit doch sehr komplex werden und so kleine (oder große) Änderungen nur noch schwer möglich sind ("Was zum Teufel hab' ich denn da gemacht...?!").

Code: Alles auswählen
void _main(void)
{
...
}


So sieht eine Funktion in C aus. Die Funktion _main bezeichnet den Einstiesgpunkt des Programms, d.h. in dieser Funktion startet das Programm. void und (void) bedeutet hier, dass diese Funktion keine Variable zurückliefert und keine benötigt, doch auch hierzu werde ich später noch kommen. Funktionen (und auch bestimmte andere Sachen) werden generell mit geschweiften Klammern eingeschlossen.

Code: Alles auswählen
  // Lösche Bildschirminhalt
  clrscr();


clrscr() ist eine der Funktionen, die TIGCC uns anbietet. Wie in TI-BASIC werden sie alle mit Klammern gestartet (mit oder ohne Parameter). Der Unterschied ist jedoch, dass man in C nach jedem vollständigen Befehl ein Semikolon (";") setzen muss (also nicht nur auf [ENTER] drücken und eine neue Zeile anfangen). clrscr() hat zwei Funktionen. Zuerst wird der Inhalt des Bildschirms gelöscht, dann wird die Position des Cursors auf 0 gestellt, was wir für die nächste Zeile brauchen:

Code: Alles auswählen
  // Schreibe "Hello World!" auf den Bildschirm
  printf("Hello world!");


printf() ist eine sehr "starke" Funktion in C (braucht auch deshalb etwas mehr Speicher). Sie sendet einen formatierten String an den 'Screen-Buffer' (Hier sind alle Werte des LCD-Displays gespeichert). Da clrscr() den Cursor auf 0 gestellt hat, fängt printf() am oberen linken Rand des LCD-Displays an. Nichts besonderes? Probiert mal ein bisschen rum, gebt printf() längere Strings und noch längere, ruft es mehrmals auf etc. Eurer Fantasie sind keine Grenzen gesetzt, und dank TiEmu macht ihr euren Rechner nicht mit skurrilen Error-Meldungen kaputt.

Code: Alles auswählen
  // Auf Tastendruck warten
  ngetchx();


ngetchx() wartet auf einen Tastendruck (außer Lock, Second, Diamond, Alpha und Shift alleine) und liefert dann den Wert der gedrückten Taste (in diesem Beispiel wird er jedoch nicht abgefragt; später mehr dazu). Wenn auch hier nicht ersichtlich, ist 'ngetchx()' jedoch sehr langsam (für C-Verhältnisse).

So, und nun seid erst einmal ihr gefragt. Tirckst mit dem, was ihr jetzt könnt, herum! Das ist der allerbeste Weg, C (oder jede andere (Programmier-)Sprache) zu lernen.


b) Hello World 2

Los geht's! Erstellt ein neues Projekt unter dem Namen "hello2" und ein neues 'C Source File' mit dem Namen 'hello2'. Werkelt rum, damit es so aussieht:

Code: Alles auswählen
// C Source File
// Created 21.04.04; 23:24:59

#include <tigcclib.h>

// Haupt-Funktion
void _main(void)
{
  // Lösche Bildschirminhalt
  ClrScr();           
 
  // Schreibe "Hello World" auf den Bildschirm
  DrawStr(35, 50, "Hello world!", A_NORMAL);
 
  // Auf Tastendruck warten
  ngetchx();             
}


Schickt es an TiEmu und startet es.

Ich werde ab hier noch das erklären, was neu ist. Ist euch etwas unklar, dann schaut weiter oben nach oder wenn es immer noch unverständlich ist, mailt mir.

Nun denn, fangen wir mit der Analyse an:

Code: Alles auswählen
  // Lösche Bildschirminhalt
  ClrScr ();


Auch wenn es nicht den Anschein hat, ist ClrScr() deutlich von clrscr() zu unterscheiden. ClrScr() löscht zwar auch den Bildschirminhalt, setzt die Cursorposition jedoch nicht auf 0 (setzt im vorherigen Besipiel 'hello' mal ClrScr() anstelle von clrscr() ein...) und braucht weniger Speicher (in diesem Beispiel sind es nur 18 Byte, aber stellt euch vor ihr braucht diesen Befehl 100mal..). Ihr solltet euch bei diesen Befehlen überlegen, was nach ihnen kommt, um dann auch die richtigen zu nehmen.

Code: Alles auswählen
  // Schreibe "Hello World" auf den Bildschirm
  DrawStr(35, 50, "Hello world!", A_NORMAL);


So, dass hier ist wirklich neu. DrawStr() ist ein (vielleicht nicht auf den ersten Blick, doch setzt auch hier z.B. mal einen längeren string ein, der über den Bildschirmrad hinausgeht...) einfacherer Befehl als printf() und brauch viel weniger Speicher, obohl er vier Parameter braucht. Als erstes die X-Position des Textanfangs (hier: 35), dann die Y-Position des Textanfangs (hier: 50), als nächstes den zu schreibenden String, und zuguter letzt das Attribut, also der 'Stil'. In diesem Fall ist es 'A_NORMAL', was so viel heisst wie 'schwarz auf weiss'.
Anschliessend warten wir wieder auf einen Tastendruck und schließen das Programm.

Wie schon oben und bei jedem anderen hier reingestelltem Progrämmchen gilt auch hier:
Spielt herum, was das Zeug hält!

So, ich denke das genügt als kleine Einführung. Das nächste Mal geht's dann weiter mit den Möglichkeiten, Tastedrücke zu erkennen...
"All animals are equal. But some animals are more equal than others." - George Orwell (Animal Farm)

boolsoft - software development for texas instruments 68k calculators
Benutzeravatar
saubue
Administrator
Administrator
 
Beiträge: 1434
Registriert: 11. März 2005 13:55
Wohnort: Freiburg im Breisgau

Zurück zu Grundlagen: TIGCC

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast