B Beispielprogramm

Im Folgenden ist als Beispiel för die Programme, die ich zur Versuchssteuerung schrieb, das Programm namens ,,absolut`` abgedruckt.

Das Programm ist selbsterklÙrend kommentiert. Bemerkenswert ist, daû im gesamten Program kein Aufruf andie APOS-Hardware erfolgt. Alle Schnittstellen zur Hardware sind in den Klassenbibliotheken ,,Melody`` und,,Ton``. Diese umfassen 2500 weitere Programmzeilen.

//====================================================
/*  		letzte …nderung: 8.5.1996

Dieses Programm steuert das Experiment, in dem Absoluthðrer
zu einer AM eine musikalische Note angeben mössen. 

Die VP kriegen 36 Tðne vorgespielt, deren Modulationsfrequenz 
zufÙllig gewÙhlt ist. Sie muû nach jedem Ton eine Taste 
von F1 bis F12 dröcken, welche den Tðnen c bis h entsprechen.
Danach muû sie noch eine Taste dröcken, um die Oktave des Tons festzuhalten.
*/

#pragma hdrfile "absolut.S"a{}M"
// dient der Beschleunigung der Komilierung

/* zuerst die Compileranweisungen: */
#define TEST 0          // 1= Ja, nur ein test, d.h es wird kein Kommando               
                        // an den AD-Wandler geschickt
                        // 0= Nein, nur Ausgabe auf Bildschirm
#define VERBOSE 0       // 1= Vebose-mode an, d.h šberwachung der 
                        // Ausgabe auf APOS auch auf Schirm
                        // 0= Verbose off, Ausgabe nur an APOS

#include <assert.h>     // för die Fehlerbehandlung
#include <stdlib.h>     // Standartbefehle
#include <math.h>       // Mathematische Bibliothek
#include <time.h>       // noch ein paar biosroutinen
#include <stdio.h>      // Standard Input/Output /printf
#include <bios.h>       // Allgemeine I/O-Routinen
#include <process.h>    // Allgemeine I/O-Routinen
#include <conio.h>      // Konsole Input/Output
#include <iostream.h>   // Allgemeine I/O-Routinen

extern "C" {
           // die sind in C programmiert - wir arbeiten in C++
        #include <xbdrv.h>      // die XBDRV-Bibliothek
        #include <apos.h>       // und natörlich: APOS-Die Programmiersprache
        #include "c:\tdt\source\tdtplot.c"
}                               // (Apos weiû, was Programmierer wönschen)

// hier stehen einige globale Variablen:
const int schritte=36;          // Soviel Messungen pro Durchgang
float lautstaerke=60;   // Die LautstÙrke soll för alle Signale gleich sein
int globaltries;        // wieviele Versuche
brauchte die VP
int globaltime;                 // wann der Versuch anfing


//    Die Folgenden Bibliotheken sind die von mir programmierten 
//    Klassenbibliotheken - Sie umfassen öber 2500 Progammzeilen
#include "c:\tdt\source\apostest.h"// Die interaktiven Testroutinen
#include "c:\tdt\source\eingabe.h" // Alle Ein und Ausgaben
#include "c:\tdt\source\ton.h"
    // Alle Tongenerierungssoftware
#include "c:\tdt\source\melody.h"
 // Die Verwaltung der Objekte

//=====================================================================
void main() {

        init();    // Aufruf der Hardware, testen der Harware, 
                   // Initialisierung der Software

       AM A;
     // Allocieren eines AM-Objekts
        // dieses Objekt umfaût alle Eigenschaften, die eine            
	   // hat. Einzelheiten: Siehe unten

        Melody M,Signal,Piep; // verschiedene Tonfolgen, die ich brauche
        Ton blip(50,50,1000);          // hier ein kurzes Tonsignal
        Pause P(50),P2(100);
        // einige Pausen
        Ton t1(100,50,600),t2(100,50,700),t3(100,50,800),t4(100,50,900);
        Signal=&t1;// und hier werden die Tðne zu Melodien verarbeitet
        Signal=Signal+&t2;Signal=Signal+&t3;Signal=Signal+&t4;
        Signal=Signal+&t3;Signal=Signal+&t2;Signal=Signal+&t3;
        Signal=Signal+&t2;Signal=Signal+&t1;
	
        M=&P;            // Die AM besteht aus einem Ton und einer Pause
          
        M=M+&A;
        Piep=&blip;  // ein kurzes Signal, wenn der Stimulus gewechselt wird
        Piep=Piep+&P2;// bestehend aus einigen Tðnen
        Piep=Piep+&blip;
        Piep=Piep+&P2;
        Piep=Piep+&blip;

        int i,j;                          // lokale ZÙhler der DurchgÙnge
        int taste,c;                      // för die Ein-Ausgabe
        float modulation=NOTE_a;
         // Die Modulationsfrequenz
                   // Hier wird die erste AM erzeugt:
        A.Setzetondauer(1000);	          // Setze die Tondauer fest
        A.Setzemodulation(modulation);	  // Modulationsfrequenz
        A.Setzegrad(1);	                  // Modulationstiefe
        A.Setzelautstaerke(lautstaerke);  // LautstÙrke in dB

        handle=neuedatei();               // erst mal eine neue Datei!
        messwert mess;	                  // mess ist ein Messwert

        M=&A;
            // Baue die Melodie zusammen, 
                          // in diesem Fall besteht sie nur aus einem Ton
        // Berechnung der Musikalischen Grundfreqeunz:
        double fgrund=double(440.0)/pow(pow(2.0,1.0/12.0),9.0);	
        // Dies entspricht einem C
                     // hier stehen die orginalen Frequenzen:
        int f[schritte];
        float frequenz[schritte];	
        float frequenz2[schritte];        // Zwischenspeicher
        float note[12];
        note[0]=NOTE_c1;// die Definition der 12 Halbtðne
        note[1]=NOTE_c1is;
        note[2]=NOTE_d1;
        note[3]=NOTE_d1is;
        note[4]=NOTE_e1;
        note[5]=NOTE_f1;
        note[6]=NOTE_f1is;
        note[7]=NOTE_g1;
        note[8]=NOTE_g1is;
        note[9]=NOTE_a1;
        note[10]=NOTE_a1is;
        note[11]=NOTE_h1;

        if(neue_datei){               // Anlegen eier neuen Datei
                for(i=0;i<schritte;i++)
                        frequenz2[i]=4*modulation+600.0/(schritte-1)*i-300;
                cout<<endl<<"erzeuge Zufallsreihenfolge "<<endl;
                randomize();
        // Eine zufÙllige Reienfolge
                for(i=0;i<schritte;i++){	  // zum Durchmischen
                        z=random(schritte-i);
                        frequenz[i]=frequenz2[z];
                        for(j=z;j<schritte-1;j++)
                                        frequenz2[j]=frequenz2[j+1];
                }
                erstelledatei(frequenz);
        } else {
                 // war schon eine alte Datei vorhanden
                fileread();
      // z.B durch Unterbrechung des Versuchs
                for(i=0;i<schritte;i++)
                        frequenz[i]=daten[i].x;
                for(i=0;i<schritte;i++) {
                        if(daten[i].y!=0) {
                                ab=i+1;
                        }
        // dann wird die geladen
                }
        }
        if (ab>=schritte-1) {    // Im Falle, daû alter Versuch 
                cout<<"Messreihe war vollstaendig!"<<endl;
 
                close(handle);
  // wird, werden die Variablen angepasst
                exit(1);
        }
        clrscr();                // lðsche Schirm

        clock_t start;
          // Der Versuch beginnt HIER!
        int bre=FALSE;	         // Flag, die einen Abbruch signalisiert
        int nochmal=FALSE;       // ob der Ton nochmal gehðrt werden will
        int richtige=0;
         // einige lokale ZÙhlvariablen, um
        int falsche=0;           // eine Bildschirmausgabe zu ermðglichen
        int oktave;
             
        for(i=ab;i<schritte;i++) {     // Hauptschleife
                A.Setzetraeger(frequenz[i]);// Setze die TrÙgerfreqeunz fest  
                start = clock();
           // starte die lokale Uhr
                gotoxy(1,10);
              // Irgendeinen Bildschirmausgabe
                cout<<"Durchgang: "<<i+1<<endl<<"   ";
                cout<<"noch verbleibende DurchgÙnge: 
                                "<<schritte-i-1<<endl<<"   ";
                do {
                        // Eingabeschleife
                        M.Spielen();// Spiele den Ton vor
                        c=ex_taste_mit();// und warte auf eine Taste

                        switch(c){// welche Taste wurde gedröckt?
                                case F1: taste=0;break;
                                case F2: taste=1;break;
                                case F3: taste=2;break;
                                case F4: taste=3;break;
                                case F5: taste=4;break;
                                case F6: taste=5;break;
                                case F7: taste=6;break;
                                case F8: taste=7;break;
                                case F9: taste=8;break;
                                case F10: taste=9;break;
                                case F11: taste=10;break;
                                case F12: taste=11;break;
                                case ESC: wait();i--;break;
                                case BACKSPACE: bre=TRUE;break;	
                                               // halt signalisiert

                                default: taste=-1;break;
                        }
                }while(taste<0 || taste>11);  // nur diese Tasten dörfen 
                Piep.Spielen();
           // Spiele ein kleines Fertig-Signal
                oktave=taste_mit();
     // Frage noch die Oktave ab
                Piep.Spielen();        // und wieder piepts
                cout<<endl;
      
                cout<<"Frequenz "<<frequenz[i]<<
                                " gehðrt: "<<note[taste]<<"           "<<endl;
                // Speichere die Ergebnisse ab:
                mess.x=frequenz[i];     // in x steht die korrekte Frequenz
                mess.y=taste;
          // welcher Ton wurde gehðrt
                mess.a=oktave;
         // In welcher Oktave? 
                mess.b=(clock()-start)/CLK_TCK;//wie lange Bedenkzeit
                mess.c=0;
              // dummy
                append(mess);  // hÙnge das neue Ergebnis an die alten
                int tast;
                if (bre) {//Es wurde Stop gedröckt
                        printf("Wirklich Stop? (j/n) \n");
                        tast=taste_mit();
                        if(tast==_J){
                                close(handle);
			}
                        bre=FALSE;
                }
      // Ende if
        }
              // Ende Hauptschleife
        close(handle);
               // Datei schliessen
        Signal.Spielen();
            // zur Belohnung gibts eine Melodie
}