Beispiel #1
0
void main()
{
  oeffnen();
  eingabe();
  ausgabe();
  ende();
}
void aufgabe4() {
	
    // Wenn ein Taster gedrueckt wird
	if(P1IN & 0x03){
		switch (P1IN & 0x03) {
			case 0x00 : // kein Taster gedrueckt
			break;
			case 0x01 :  // rechter Taster gedrueckt decrementiere
				i = (i - 1) % 8;
			break;
			case 0x02 : // linker Taster gedrueckt incrementiere
				i = (i + 1) % 8;
			break;
			case 0x03 : //beide gedrueckt setze Zaehler auf 0
				i = 0;
			break;
			default :
		}
		
		ausgabe(i);

        // Warte eine kurze Zeit nach der Ausgabe um Prellverhalten
        // vom Taster abzufangen
		delay(100);
	}
}
Beispiel #3
0
int main(int argc, char* argv[])
{
    int zahlen_array[MAX] = {};
	int i = 0;
    int ergebnis = 0;
	int limit = 0;

    /* das Array mit Zahlen befüllen, wobei zahlen_array[0]=1..zahlen_araay[99]=100*/
    for (i=0; i < MAX; i=i+1) zahlen_array[i] = i +1;
   
   /* Funktionsaufruf */
    ergebnis = addition(zahlen_array);
    printf ("Die Summe aller Zahlen von 1 bis 100 ist: %d\n",ergebnis);
	
	/* Wert einlesen */
    printf("Bis zu welchem Indexwert soll ausgegeben werden?");
    scanf("%d", &limit);
	
	/* Prüfen ob die Eingabe Valid ist  */
	if (limit<=MAX)
	    ausgabe(zahlen_array,limit);
	else 
		printf ("ERROR: Index out of bound. Bitte kleiner als %d eingeben\n",MAX+1);
	return 0;
}
/**************************************************************************
   Description   : Sichern der ErrechneteKanaeleTemp Variablen in eine Datei
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	27.08.2007, 0.1, 		Created
**************************************************************************/
void ErrechneteKanaeleSichernTemp(void)
{
    int		i = 1;
    int		Zaehler = 1;
    DWORD	SNBuffer = 0;
    char	TypeBuffer[50] = {0};
    char	Pfad[100] = {0};
    char	DateiName[100] = {0};
    char	DateiBuffer[200] = {0};
    FILE    *Datei = NULL;

    Tools_PathExtractPath(Pfad, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );
    Tools_PathExtractFile(DateiName, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );

    for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
    {

        GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
        GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);

        sprintf(DateiBuffer, "%s/%3ld.%s", Pfad, SNBuffer, DateiName);

        Datei = fopen(DateiBuffer, "w");
        if (!Datei)
        {
            ausgabe(LOG, DEBUGMINI, "ErrechneteKanaele.TempVariablenDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
            return;
        }
        else
        {
            ausgabe(LOG, DEBUGKRECH, "Sichern der ErrechneteKanaeleTemp Variablen in %s gestartet.\n", DateiName);
            for(i = 1; i <= ERRECHNETEKANAELEMAX; i++)
            {
                fwrite(&ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]), 1, Datei);
                fwrite(&ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]), 1, Datei);
                ausgabe(LOG, DEBUGKRECH, "ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1] = %u\n", ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]);
                ausgabe(LOG, DEBUGKRECH, "ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1] = %f\n", ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]);

                if(i <= ErrechneteKanaeleAnzahl)
                {   // Nur StatusDatein für Errechnete Kanäle erstellen
                    StatusDatei(SNBuffer, TypeBuffer, ErrechneteKanaeleName[i - 1], ErrechneteKanaeleWert[Zaehler - 1][i - 1]);
                }
            }
        }
        fclose(Datei);
    }
}
Beispiel #5
0
/**************************************************************************
   Description   : Setzen der Globalen Zeit Variablen
   Parameter     : Zeiger auf einen char * Array
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	19.08.2007, 0.1, 		Created
**************************************************************************/
void timer(void)
{
	ausgabe(SYSLOG, DEBUGALLES, "timer Start\n", SekundenZeit);

	SekundenZeit = time(NULL);

	MinutenZeit = SekundenZeit / 60;

	StundenZeit = MinutenZeit / 60;

	TagZeit = (StundenZeit + 3) / 24;

	ausgabe(LOG, DEBUGALLES, "timer SekundenZeit: %d!!!\n", SekundenZeit);
	ausgabe(LOG, DEBUGALLES, "timer MinutenZeit: %d!!!\n", MinutenZeit);
	ausgabe(LOG, DEBUGALLES, "timer StundenZeit: %d!!!\n", StundenZeit);
	ausgabe(LOG, DEBUGALLES, "timer TagZeit: %d!!!\n", TagZeit);
}
int main (int argc, char* argv[]) {
  char *name = "dhondt-ergebnisse2.txt";
  if (argc > 1)
    name = argv[1];
  eingabe (name);
  berechneProzent();
  berechneDivisoren ();
  berechneSitze();
  ausgabe ();
  return 0;
}
Beispiel #7
0
bool DataImporter::exportXYZ(QList<Point3D> points, QIODevice *d)
{
    //open and check device
    if (!d->open(QIODevice::WriteOnly | QIODevice::Text))
    {
        return false;
    }

     QTextStream ausgabe(d);

     foreach(Point3D p,points)
     {
         vec adjustedPoint=p.getAdjustedPoint();
         ausgabe << adjustedPoint.at(0)<<" "<<adjustedPoint.at(1)<<" "<<adjustedPoint.at(2) <<"\n";

     }
Beispiel #8
0
int main ( void )
{

    int anzb = ANZAHL;
    int anzw = ANZAHL;
    double betraege [ANZAHL]= {};
    char  waehrung [ANZAHL] [Y] = {{}};
    eingabe (betraege, anzb, waehrung, anzw);
    ausgabe (betraege , anzb, waehrung,anzw);





    return 0;

}
Beispiel #9
0
/**************************************************************************
   Description   : Loggen von Werten aller WR in je eine Datei
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	01.09.2007, 0.1, 		Created
**************************************************************************/
void Log(void)
{
	int		Zaehler = 1;
    char	Pfad[100]={0};
    char	OutputDatei[100]={0};

	if(	LogIntervallZeit == 0 ||												// Wenn Intervallzeit = 0 ODER
		(LogLetzteIntervallZeit + LogIntervallZeit) > SekundenZeit ||			// Wenn Intervallzeit nicht abgelaufen
		AnzahlErfassterWR == 0 ||												// ODER Wenn keine WR erfasst
		!(AnzahlSollWR == AnzahlErfassterWR) ||									// ODER Wenn nicht alle WR erfasst
		!ErrechneteKanaeleAktualisierenErfolgreich ||							// ODER Wenn ErrechneteKanaeleAktualisieren nicht erfolgreich
		(KanalAbfragenMoeglich() == -1))										// ODER Wenn WR Abfrage nicht möglich
	{																			// Dann Log Abbrechen
		return;
	}

	ausgabe(LOG, DEBUGALLES, "Log gestartet!!!\n");
	ausgabe(LOG, DEBUGALLES, "LogOutputTypeAnzahl: %i\n", LogOutputTypeAnzahl);
 	ausgabe(LOG, DEBUGALLES, "Sekunden: %u\n", SekundenZeit);

	LogLetzteIntervallZeit = SekundenZeit;										// Log erst nach ablauf der nächsten Intervallzeit wieder starten

	for(Zaehler = 1; Zaehler <= LogOutputTypeAnzahl; Zaehler++)
	{
		ausgabe(LOG, DEBUGALLES, "Zaehler: %i\n", Zaehler);
		ausgabe(LOG, DEBUGALLES, "LogOutputType[Zaehler - 1]: %i\n", LogOutputType[Zaehler - 1]);
		switch(LogOutputType[Zaehler - 1])
		{
			case 1:																		// "Local"
                Tools_PathExtractPath(Pfad, LogOutput[Zaehler - 1], sizeof(LogOutput[Zaehler - 1])-1 );
                Tools_PathExtractFile(OutputDatei, LogOutput[Zaehler - 1], sizeof(LogOutput[Zaehler - 1])-1 );
				ausgabe(LOG, DEBUGALLES, "Log 'Local' gestartet!!!\n");
				LogDatei(Pfad, OutputDatei, LogGesamtOutputFormat[Zaehler - 1]);
				break;
			case 2:																		// "FTP"
                Tools_PathExtractPath(Pfad, LogOutput[Zaehler - 1], sizeof(LogOutput[Zaehler - 1])-1 );
                Tools_PathExtractFile(OutputDatei, LogOutput[Zaehler - 1], sizeof(LogOutput[Zaehler - 1])-1 );
				ausgabe(LOG, DEBUGALLES, "Log 'FTP' gestartet!!!\n");
				LogDatei(Pfad, OutputDatei, LogOutputFormat[Zaehler - 1]);
				break;
		}
	}
}
Beispiel #10
0
/**************************************************************************
   Description   : Loggen der letzten ermittelten Werte von ausgewählten
                   WR in eine Datei um 0:00
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	01.09.2007, 0.1, 		Created
**************************************************************************/
void LogMonat(void)
{
	int		Zaehler = 1;
    char	Pfad[100]={0};
    char	OutputDatei[100]={0};

	if(	LogMonatLetzteIntervallZeit >= TagZeit ||					// Wenn Intervallzeit nicht abgelaufen
		AnzahlErfassterWR == 0 ||									// ODER Wenn keine WR erfasst
		!(AnzahlSollWR == AnzahlErfassterWR))						// ODER Wenn nicht alle WR erfasst
	{																// Dann LogMonat Abbrechen
		return;
	}

	ausgabe(LOG, DEBUGALLES, "LogMonat gestartet!!!\n");
	ausgabe(LOG, DEBUGALLES, "LogMonatOutputTypeAnzahl: %i\n", LogMonatOutputTypeAnzahl);
 	ausgabe(LOG, DEBUGALLES, "Sekunden: %u\n", SekundenZeit);

	LogMonatLetzteIntervallZeit = TagZeit;							// LogMonat erst um 0:00 wieder starten

	for(Zaehler = 1; Zaehler <= LogOutputTypeAnzahl; Zaehler++)
	{
		ausgabe(LOG, DEBUGALLES, "Zaehler: %i\n", Zaehler);
		ausgabe(LOG, DEBUGALLES, "LogMonatOutputType[Zaehler - 1]: %i\n", LogMonatOutputType[Zaehler - 1]);
		switch(LogMonatOutputType[Zaehler - 1])
		{
			case 1:																		// "Local"
                Tools_PathExtractPath(Pfad, LogMonatOutput[Zaehler - 1], sizeof(LogMonatOutput[Zaehler - 1])-1 );
                Tools_PathExtractFile(OutputDatei, LogMonatOutput[Zaehler - 1], sizeof(LogMonatOutput[Zaehler - 1])-1 );
				ausgabe(LOG, DEBUGALLES, "LogMonat 'Local' gestartet!!!\n");
				LogMonatDatei(Pfad, OutputDatei, LogMonatOutputFormat[Zaehler - 1]);
				break;
			case 2:																		// "FTP"
                Tools_PathExtractPath(Pfad, LogMonatOutput[Zaehler - 1], sizeof(LogMonatOutput[Zaehler - 1])-1 );
                Tools_PathExtractFile(OutputDatei, LogMonatOutput[Zaehler - 1], sizeof(LogMonatOutput[Zaehler - 1])-1 );
				ausgabe(LOG, DEBUGALLES, "LogMonat 'FTP' gestartet!!!\n");
				LogMonatDatei(Pfad, OutputDatei, LogMonatOutputFormat[Zaehler - 1]);
				break;
		}
	}
}
Beispiel #11
0
void menu(void){
  int wahl, i;
  do {
    printf("\n1 : Print\n");
    printf("2 : Write person\n");
    printf("3 : properties menu\n");
    printf("Ende: 9\n");
    printf("Auswahl: ");
    scanf("%d", &wahl);
    getchar();
    switch(wahl){
    case 1 : ausgabe();
      break;
    case 2 : pers_eingabe();
      break;
    case 3 : eigen_menu();
      break;
    case 9 :
      break;
    default :
      printf("Falsche Eingabe!!!\n");
    }
  } while(wahl != 9);
}
/**************************************************************************
   Description   : Laden der ErrechneteKanaeleTemp Variablen von einer Datei
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	27.08.2007, 0.1, 		Created
**************************************************************************/
void ErrechneteKanaeleLadenTemp(void)
{
    int		i = 1;
    int		Zaehler = 1;
    DWORD	SNBuffer = 0;
    char	Pfad[100] = {0};
    char	DateiName[100] = {0};
    char	DateiBuffer[200] = {0};
    FILE    *Datei = NULL;

    Tools_PathExtractPath(Pfad, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );
    Tools_PathExtractFile(DateiName, ErrechneteKanaeleTempDateiName, sizeof(ErrechneteKanaeleTempDateiName)-1 );

    for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
    {

        GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);

        sprintf(DateiBuffer, "%s/%3ld.%s", Pfad, SNBuffer, DateiName);

        Datei = fopen(DateiBuffer, "r");
        if (!Datei)
        {
            ausgabe(LOG, DEBUGMINI, "ErrechneteKanaele.TempVariablenDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
            return;
        }
        else
        {
            ausgabe(SYSLOG, DEBUGNORMAL, "Laden der ErrechneteKanaeleTemp Variablen in %s gestartet.\n", DateiBuffer);
            for(i = 1; i <= ERRECHNETEKANAELEMAX; i++)
            {
                ausgabe(LOG, DEBUGINIT, "vor READ ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1] = %u\n", ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]);
                ausgabe(LOG, DEBUGINIT, "vor READ ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1] = %f\n", ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]);
                fread(&ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]), 1, Datei);
                fread(&ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1], sizeof(ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]), 1, Datei);
                ausgabe(LOG, DEBUGINIT, "nach READ ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1] = %u\n", ErrechneteKanaeleLongTemp[Zaehler - 1][i - 1]);
                ausgabe(LOG, DEBUGINIT, "nach READ ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1] = %f\n", ErrechneteKanaeleDoubleTemp[Zaehler - 1][i - 1]);
            }
            fclose(Datei);
        }
    }
}
Beispiel #13
0
void quadrat (int anzahl, int zugriff)
{
 int start;

 kolission = 0;
 
 C_xlong quad;

 ueberlauf.remove();   // Loeschen der Kolissionsliste

 // Anlegen eines dynamischen Arrays von int-Werten fuer den Adressraum

 p = (int) pow(10, zugriff);
 arr = new int[p];
 
 if (arr == 0)
	speicher();
 
 // Vorbelegen des Arrays mit -1

 for(int j=0 ; j<p ; j++)
	 arr[j] = -1;

 /* Durchfuehrung der Zuordnung mit Hilfe der Mitte-des-Quadrats-Methode */
 
 for (int i = 0; i < anzahl; i++)
 {

  // Berechnung des Adressregisters durch quadrieren des jeweiligen
  // Schluesselwertes und anschliessendem herausgreifen der vom Benutzer
  // gewaehlten Anzahl von Ziffern aus der Quadratzahl.
  // Die so gewonnene Zahl gibt das Adressregister an.

  quad = eingabe[i].finput * eingabe[i].finput;
  start = quad.getLength()/2 - zugriff/2;
  
  C_xlong dwarf = quad(start,zugriff);
  
  unsigned int index = tolong(dwarf);

  // Um zu verhindern, dass das errechnete Ergebnis den gewaehlten
  // Adressraum verlaesst, Modulo-Division des Ergebnisses durch die
  // Groesse des Adressraumes

  index = index % p;

  // Falls das ermittelte Register noch unbesetzt ist (Eintrag -1),
  // so wird, um Speicherplatz zu sparen, nur der Laufindex des jeweiligen
  // Schluesselwertes in dem erstellten Adressraum gespeichert

  if (arr[index] == -1)
    arr[index] = i;

  // Falls das ertmittelte Register bereits belegt ist, so wird der
  // Schluesselwert an die Kolissionsliste angefuegt

  else
    {
     kolission++;
	 
	 C_xstrlong tmp(eingabe[i].keystr);
	
	 ueberlauf.append(tmp);
    }
 }

 ((CHashDlg *) (theApp.m_pMainWnd))->setStatus("Status: Berechnung beendet!!!");

 // Aufruf der Ausgabefunktion
 ausgabe(arr);

 p = ADDRESSRANGE;	

 return;
}
Beispiel #14
0
/**************************************************************************
   Description   : Erstellen der Log Gesamt Dateien
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	22.08.2007, 0.1, 		Created
**************************************************************************/
void LogGesamtDatei(char *Pfad, char *OutputDatei, int Format)
{
	int		Zaehler = 1;

	ausgabe(LOG, DEBUGMINI, "LogGesamtDatei gestartet!!!\n");

    for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
    {
        BOOL	NeueDatei = true;
        char	NameBuffer[50] = {0};
    	char	TypeBuffer[50] = {0};
		DWORD	SNBuffer = 0;
		char	DatumBuffer[20] = {0};
    	char	DateiBuffer[200] = {0};
		FILE	*Datei = NULL;

        GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
        GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
        GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
        GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);

        ausgabe(LOG, DEBUGALLES, "LogGesamtDatei für WR %3ld erstellen\n", SNBuffer);

		sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);

        Datei = fopen(DateiBuffer, "r");
        ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
        if (Datei)                   			// Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
        {                                   	// und es muss kein Dateikopf mehr erstellt werden.
            ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
            NeueDatei = false;
            fclose(Datei);
        }

        Datei = fopen(DateiBuffer, "a");
        if (!Datei)
        {
            ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
            return;
        }
        else
        {
        	int			i = 0;
        	int			KanalAnzahl = 0;
            DWORD		KanalHandle[KANALMAX];
            TChanType 	KanalType = ALLCHANNELS;
            char		KanalName[50] = {0};
            char		WertText[50]={0};
			char		ZeitpunktBuffer[50] = {0};

            ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
            setbuf(Datei, 0);                      									// Pufferung abschalten

            // Ab hier Ausgaben in Datei
            KanalAnzahl = GetChannelHandlesEx(WRHandles[Zaehler - 1], KanalHandle, KANALMAX, KanalType);
            GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);

            if(NeueDatei)
            {
                fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
                fprintf(Datei, "WR '%s' hat %d Kanäle:\r\n", NameBuffer, KanalAnzahl);
                fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
                fprintf(Datei, "Zeitpunkt          \t");
				// Kanäle der WR
                for(i = 0; i < KanalAnzahl; i++)
                {
                    GetChannelName(KanalHandle[i], KanalName, sizeof(KanalName)-1);

                    fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle[i]), KanalName);
                }
                // Die Errechneten Kanaele
                for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
                {
                    fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[i], ErrechneteKanaeleName[i]);
                }
            }

            fprintf(Datei, "\r\n");
            fprintf(Datei, "%s\t", ZeitpunktBuffer);

			// Kanäle der WR
            for(i = 0; i < KanalAnzahl; i++)
            {
            	KanalAbfragen(KanalHandle[i], WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1);		// Abfragen eines Kanales

				fprintf(Datei, "%s\t", WertText);
            }
            // Die Errechneten Kanaele
            for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
            {
                fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][i]);
            }
            ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
		}
		fclose(Datei);
	}
}
Beispiel #15
0
/**************************************************************************
   Description   : Erstellen der Log Dateien
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	01.09.2007, 0.1, 		Created
**************************************************************************/
void LogDatei(char *Pfad, char *OutputDatei, int Format)
{
	int		Zaehler = 1;

	ausgabe(LOG, DEBUGALLES, "LogDatei gestartet!!!\n");

    for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
    {
        BOOL	NeueDatei = true;
        char	NameBuffer[50] = {0};
    	char	TypeBuffer[50] = {0};
		DWORD	SNBuffer = 0;
		char	DatumBuffer[20] = {0};
    	char	DateiBuffer[200] = {0};
		FILE	*Datei = NULL;

        GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
        GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
        GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
        GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);

        ausgabe(LOG, DEBUGALLES, "LogDatei für WR %3ld erstellen\n", SNBuffer);

		sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);

        Datei = fopen(DateiBuffer, "r");
        ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
        if (Datei)                   			// Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
        {                                   	// und es muss kein Dateikopf mehr erstellt werden.
            ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
            NeueDatei = false;
            fclose(Datei);
        }

        Datei = fopen(DateiBuffer, "a");
        if (!Datei)
        {
            ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
            return;
        }
        else
        {
        	int			i = 0;
        	int			j = 0;
        	int			KanalAnzahl = 0;
            DWORD		KanalHandle;
            TChanType 	KanalType = ALLCHANNELS;
            char		KanalName[50] = {0};
            char		WertText[50]={0};
			char		ZeitpunktBuffer[50] = {0};

            ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
            setbuf(Datei, 0);                      									// Pufferung abschalten

            // Ab hier Ausgaben in Datei
            GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);

            if(NeueDatei)
            {
                fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
                fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
                fprintf(Datei, "Zeitpunkt          \t");

				ausgabe(LOG, DEBUGALLES, "LogKanalAnzahl %i\n", LogKanalAnzahl);

                for(i = 1; i <= LogKanalAnzahl; i++)
                {
                    KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);

					ausgabe(LOG, DEBUGALLES, "1. KanalHandle %i\n", KanalHandle);

                    if(KanalHandle == 0)
                    {           // Kanal nicht vom WR
                                // Die Errechneten Kanaele durchsuchen
                        for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
                        {
                            if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
                            {
                                KanalHandle = j;
                                break;
                            }
                        }
                        if(KanalHandle == 0)
                        {           // Kanal nicht gefunden
                    		fprintf(Datei, "???%9s???\t", LogKanal[i - 1]);
                        }
                        else
                        {           // Errechneter Kanal
                    		fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[KanalHandle - 1], ErrechneteKanaeleName[KanalHandle - 1]);
                        }
                    }
                    else
                    {           // Kanal vom WR
                        GetChannelName(KanalHandle, KanalName, sizeof(KanalName)-1);
                        fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle), KanalName);
                    }
                }
            }

            fprintf(Datei, "\r\n");
            fprintf(Datei, "%s\t", ZeitpunktBuffer);

            for(i = 1; i <= LogKanalAnzahl; i++)
            {
                KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);

                if(KanalHandle == 0)
                {           // Kanal nicht vom WR
                            // Die Errechneten Kanaele durchsuchen
                    for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
                    {
                        if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
                        {
                            KanalHandle = j;
                            break;
                        }
                    }
                    if(KanalHandle == 0)
                    {           // Kanal nicht gefunden
                        fprintf(Datei, "               \t");
                    }
                    else
                    {           // Errechneter Kanal
                		fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][KanalHandle - 1]);
                    }
                }
                else
                {           // Kanal vom WR
            	KanalAbfragen(KanalHandle, WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1);		// Abfragen eines Kanales
				fprintf(Datei, "%s\t", WertText);
                }
            }
            ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
		}
		fclose(Datei);
	}
}
Beispiel #16
0
/**************************************************************************
   Description   : Erstellen der Log Datei der letzten ermittelten Werte
                   von ausgewählten WR in eine Datei um 0:00
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	03.09.2007, 0.1, 		Created
**************************************************************************/
void LogMonatDatei(char *Pfad, char *OutputDatei, int Format)
{
    int     i = 0;
    int     j = 0;
    int     k = 0;
	int		Zaehler = 1;
	char	DatumBuffer[DATUMMAX] = {0};
	char	ZeitpunktBuffer[ZEITPUNKTMAX] = {0};
    char	DateiBuffer[DATEINAMEPFADMAX] = {0};
    BOOL    NeueDatei = true;
    FILE    *Datei = NULL;
    char	KanalName[KANALNAMEMAX] = {0};
    char	WertText[KANALWERTTEXTMAX]={0};
    int     Zeichen = 0;
    DWORD   KanalHandle;

	ausgabe(LOG, DEBUGALLES, "LogMonatDatei gestartet!!!\n");

    GetMonat(DatumBuffer, sizeof(DatumBuffer)-1);
    GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);

    sprintf(DateiBuffer, "%s/%s.%s", Pfad, DatumBuffer, OutputDatei);

	ausgabe(LOG, DEBUGALLES, "LogDatei %s erstellen\n", DateiBuffer);

    Datei = fopen(DateiBuffer, "r");
    ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
    if (Datei)                              // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
    {                                       // und es muss kein Dateikopf mehr erstellt werden.
        ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
        NeueDatei = false;
        fclose(Datei);
    }

    Datei = fopen(DateiBuffer, "a");
    if (!Datei)
    {
        ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
        return;
    }
    else
    {	// Logdatei wurde zum Schreiben geöffnet
        ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
        setbuf(Datei, 0);                                                       // Pufferung abschalten

		// Erstellen des Dateikopfes wenn nötig
        if(NeueDatei)
        {
            fprintf(Datei, "LogMonatDatei erstellt am %s von %s %s\r\n", ZeitpunktBuffer, ProgrammName, ProgrammVersion);
            fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
            fprintf(Datei, "                   \t");

            for(i = 1; i <= LogMonatWRAnzahl; i++)
            {
                for(j = 1; j <= LogMonatKanalAnzahl; j++)
                {
                    KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);

                    if(KanalHandle == 0)
                    {           // Kanal nicht vom WR
                                // Die Errechneten Kanaele durchsuchen
                        for(k = 1; k <= ErrechneteKanaeleAnzahl; k++)
                        {
                            if(strncmp(LogMonatKanal[j - 1], ErrechneteKanaeleName[k - 1], sizeof(LogMonatKanal[j - 1])-1) == 0)
                            {
                                KanalHandle = k;
                                break;
                            }
                        }
                        if(KanalHandle == 0)
                        {           // Kanal nicht gefunden
                        	Zeichen = 15;
                        }
                        else
                        {           // Errechneter Kanal
                       		Zeichen = ErrechneteKanaeleZeichen[KanalHandle - 1];
                        }
                    }
                    else
                    {           // Kanal vom WR
                        Zeichen = KanalWertZeichenAnzahlMAX(KanalHandle);
                    }

                    if(j == 1)
                    {
                    	char *Temp[20] = {0};

                    	if(strncmp(LogMonatWR[i - 1], "9999999999", 10) == 0)
                    	{
                    		strncpy(Temp, LogMonatSummeUeberschrift, sizeof(Temp)-1);
                    	}
                    	else
                    	{
                    		strncpy(Temp, LogMonatWR[i - 1], sizeof(Temp)-1);
                    	}

                    	if(Zeichen < strlen(Temp))
                    	{
                    		Zeichen = strlen(Temp);
                    	}
                        fprintf(Datei, "%-*s\t", Zeichen, Temp);
                    }
                    else
                    {
                        fprintf(Datei, "%*s\t", Zeichen, "");
                    }
                }
            }

            fprintf(Datei, "\r\nZeitpunkt          \t");

            for(i = 1; i <= LogMonatWRAnzahl; i++)
            {
                for(j = 1; j <= LogMonatKanalAnzahl; j++)
                {
                    KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);

                    if(KanalHandle == 0)
                    {           // Kanal nicht vom WR
                                // Die Errechneten Kanaele durchsuchen
                        for(k = 1; k <= ErrechneteKanaeleAnzahl; k++)
                        {
                            if(strncmp(LogMonatKanal[j - 1], ErrechneteKanaeleName[k - 1], sizeof(LogMonatKanal[j - 1])-1) == 0)
                            {
                                KanalHandle = k;
                                break;
                            }
                        }
                        if(KanalHandle == 0)
                        {           // Kanal nicht gefunden
                            fprintf(Datei, "???%*s???\t", LogMonatDateiZeichenAnzahl(j, 15, i)-6, LogMonatKanal[j - 1]);
                        }
                        else
                        {           // Errechneter Kanal
                        	fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, ErrechneteKanaeleZeichen[KanalHandle - 1], i), ErrechneteKanaeleName[KanalHandle - 1]);
                        }
                    }
                    else
                    {           // Kanal vom WR
                    	GetChannelName(KanalHandle, KanalName, sizeof(KanalName)-1);
                    	fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, KanalWertZeichenAnzahlMAX(KanalHandle), i), KanalName);
                    }
                }
            }
		}

		// AB hier wird die Datei mit Daten gefüttert
        fprintf(Datei, "\r\n");
        fprintf(Datei, "%s\t", ZeitpunktBuffer);

        for(i = 1; i <= LogMonatWRAnzahl; i++)
        {
            for(j = 1; j <= LogMonatKanalAnzahl; j++)
            {
                KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);

                if(KanalHandle == 0)
                {           // Kanal nicht vom WR
                    if(GetWertCalcKanalSN(LogMonatKanal[j - 1], LogMonatWR[i - 1], WertText, sizeof(WertText)-1) == -1)
                    {		// Kanal nicht gefunden
                        fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, 15, i), "");
                    }
                    else
                    {		// Kanal gefunden
                        fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, GetZeichenCalcKanal(LogMonatKanal[j - 1]), i), WertText);
                    }
				}
                else
                {           // Kanal vom WR
					KanalAbfragenSN(KanalHandle, LogMonatWR[i - 1], WertText, sizeof(WertText)-1);

                    fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, KanalWertZeichenAnzahlMAX(KanalHandle), i), WertText);
                }
            }
        }
		fclose(Datei);
	}
}
/**************************************************************************
   Description   : Aktualisieren der Errechneten Kanäle
   Parameter     : (none)
   Return-Value  : (none)
   Changes       : Author, 		Date, 		Version, 	Reason
                   ********************************************************
                   Dotterweich,	24.08.2007, 0.1, 		Created
**************************************************************************/
void ErrechneteKanaeleAktualisieren(void)
{
    int		i = 1;
    int		Zaehler = 1;
    DWORD	KanalHandle = 0;

    // ErrechneteKanaele aktualisieren???
    if(	ErrechneteKanaeleErrechnungsIntervallZeit == 0 ||																	// Wenn Intervallzeit = 0 ODER
            (ErrechneteKanaeleErrechnungsLetzteIntervallZeit + ErrechneteKanaeleErrechnungsIntervallZeit) > SekundenZeit)		// Wenn Intervallzeit nicht abgelaufen
    {   // Dann ErrechneteKanaeleAktualisieren Abbrechen
        return;
    }

    ErrechneteKanaeleAktualisierenErfolgreich = FALSE;

    // ErrechneteKanaele aktualisieren möglich???
    if(	AnzahlErfassterWR == 0 ||														// ODER Wenn keine WR erfasst
            !(AnzahlSollWR == AnzahlErfassterWR) ||											// ODER Wenn nicht alle WR erfasst
            (KanalAbfragenMoeglich() == -1))												// ODER Wenn WR Abfrage nicht möglich
    {   // Dann ErrechneteKanaeleAktualisieren Abbrechen
        return;
    }

    ausgabe(LOG, DEBUGNORMAL, "ErrechneteKanaeleAktualisieren gestartet!!!\tSekunden: %u\n", SekundenZeit);

    ErrechneteKanaeleErrechnungsLetzteIntervallZeit = SekundenZeit;			// ErrechneteKanaele erst nach Ablauf der nächsten Intervallzeit wieder berechnen

    for(Zaehler = 1; Zaehler <= ErrechneteKanaeleAnzahl; Zaehler++)
    {
        switch(ErrechneteKanaeleArt[Zaehler - 1])
        {
        case 1:																			// "TagesDifferenz"
            // Für jeden WR Extra
            for(i = 1; i <= AnzahlErfassterWR; i++)
            {
                double	Wert = 0;
                char	Temp[50] = {0};

                KanalHandle = FindChannelName(WRHandles[i - 1], ErrechneteKanaeleKanal[Zaehler - 1]);

                if(KanalHandle == 0)
                {
                    sprintf(ErrechneteKanaeleWert[i - 1][Zaehler - 1], "RECHERR");		// Wenn Kanal nicht gefunden
                    return;
                }
                else
                {
                    GetChannelUnit(KanalHandle, ErrechneteKanaeleEinheit[i - 1][Zaehler - 1], sizeof(ErrechneteKanaeleEinheit[i - 1][Zaehler - 1])-1);
                    Wert = KanalAbfragen(KanalHandle, WRHandles[i - 1], Temp, sizeof(Temp)-1);          // Abfragen eines Kanales

                    if (Wert == -1)
                    {   // Wenn Kanalabfrage nicht erfolgreich ABBRECHEN
                        return;
                    }

                    // TagesDifferenz Werte nach Ablauf eines Tages Zurücksetzen
                    if( ErrechneteKanaeleLongTemp[i - 1][Zaehler - 1] == 0 ||           // Wenn TagesDifferenzLetzterReset == 0 ODER
                            ErrechneteKanaeleLongTemp[i - 1][Zaehler - 1] < TagZeit)		// Wenn ein Tag abgelaufen
                    {   // Dann TagesDifferenzWert = 0
                        ErrechneteKanaeleLongTemp[i - 1][Zaehler - 1] = TagZeit;        // TagesDifferenz Kanäle erst am nächsten Tag zurücksetzen
                        ErrechneteKanaeleDoubleTemp[i - 1][Zaehler - 1] = Wert;         // TagesEndWert setzen
                    }

                    ErrechneteKanaeleWertZahl[i - 1][Zaehler - 1] = Wert - ErrechneteKanaeleDoubleTemp[i - 1][Zaehler - 1];		// Wert errechnen

                    GetWertTextCalcKanal( ErrechneteKanaeleWertZahl[i - 1][Zaehler - 1], Zaehler - 1,
                                          ErrechneteKanaeleWert[i - 1][Zaehler - 1], sizeof(ErrechneteKanaeleWert[i - 1][Zaehler - 1])-1);	// Wert als Text
                }
            }
            break;

        case 2:
            break;
        }
    }

    ErrechneteKanaeleAktualisierenErfolgreich = TRUE;										// Aktualisieren erfolgreich
    ErrechneteKanaeleSichernTemp();
}
Beispiel #18
0
void divisionsrest (int anzahl)
{ 
 kolission = 0;

 char divisor[20];

 sprintf(divisor,"%d",p);

 ueberlauf.remove();  // Loeschen der Kolissionsliste
 
 // Anlegen eines dynamischen Arrays von int-Werten fuer den Adressraum

 arr = new int[p];
 if (arr == 0)
	speicher();

 // Vorbelegen des Arrays mit -1

 for (int j = 0; j < p; j++)
  arr[j] = -1;  
 
 /* Durchfuehrung der Zuordnung mit Hilfe der Divisions-Rest-Methode */

 for (j = 0; j < anzahl; j++)
 {
   
   // Berechnung des jeweiligen Adressregisters durch Modulo-Division des
   // Schluesselwertes durch die Groesse des Adressraumes
   
   C_xlong dwarf = eingabe[j].finput % divisor;
   
   long index = tolong(dwarf);
  
   // Um zu verhindern, dass das errechnete Ergebnis den gewaehlten
   // Adressraum verlaesst, Modulo-Division des Ergebnisses durch die
   // Groesse des Adressraumes

   index = index % p;

   // Falls das ermittelte Register noch unbesetzt ist (Eintrag -1),
   // so wird, um Speicherplatz zu sparen, nur der Laufindex des jeweiligen
   // Schluesselwertes in dem erstellten Adressraum gespeichert

   if (arr[index] == -1)
	   arr[index] = j;

   // Falls das ertmittelte Register bereits belegt ist, so wird der
   // Schluesselwert an die Kolissionsliste angefuegt

   else
   {
     kolission++;
	 
	 C_xstrlong tmp(eingabe[j].keystr);
	
	 ueberlauf.append(tmp);
   }
 }

  ((CHashDlg *) (theApp.m_pMainWnd))->setStatus("Status: Berechnung beendet!!!");

  // Aufruf der Ausgabefunktion

 ausgabe(arr);

 p = ADDRESSRANGE;

 return;
}
Beispiel #19
0
void transform (int anzahl, int basis)
{
	int exp;
	long ind;
	char range[20];

    sprintf(range,"%d",p);

	kolission = 0;
 
    ueberlauf.remove();   // Loeschen der Kolissionsliste
  	     
 // Anlegen eines dynamischen Arrays von int-Werten fuer den Adressraum

 arr = new int[p];
  
 if (arr == 0)
	speicher();
 
 // Vorbelegen des Arrays mit -1

 for(int j=0 ; j<p ; j++)
   arr[j] = -1;

 /* Durchfuehrung der Zuordnung mit Hilfe der Basis-Transformations-Methode */
 
 // Hierbei wird jeder Schluesselwert in eine neue, vom Benutzer waehlbare
 // Basis transformiert (nach dem ueblichen Transformationsverfahren).

 for (int i = 0; i < anzahl; i++)
 {
  exp = 0;
  C_xlong index = 0;

  for(int l=(eingabe[i]).finput.getLength() - 1 ; l>=0 ; l--)
  {
   char str[20];
   sprintf(str,"%lu",(unsigned long) pow(basis, exp));
   index = index + ((eingabe[i]).finput(l, 1) * C_xlong(str)); 
  
   // Um zu verhindern, dass das errechnete Ergebnis den gewaehlten
   // Adressraum verlaesst, Modulo-Division des Ergebnisses durch die
   // Groesse des Adressraumes
   
   index = index % C_xlong(range);
   
   exp++;
  }

  ind = tolong(index);
  
  // Falls das ermittelte Register noch unbesetzt ist (Eintrag -1),
  // so wird, um Speicherplatz zu sparen, nur der Laufindex des jeweiligen
  // Schluesselwertes in dem erstellten Adressraum gespeichert

  if (arr[ind] == -1)
    arr[ind] = i;

  // Falls das ertmittelte Register bereits belegt ist, so wird der
  // Schluesselwert an die Kolissionsliste angefuegt

  else
  {
     kolission++;
	 
	 C_xstrlong tmp(eingabe[i].keystr);
	
	 ueberlauf.append(tmp);
  }
 }

 // Aufruf der Ausgabefunktion

 ((CHashDlg *) (theApp.m_pMainWnd))->setStatus("Status: Berechnung beendet!!!");
 
 ausgabe(arr);

 p = ADDRESSRANGE;

 return;
}
Beispiel #20
0
void grenzfaltung (int anzahl, int zugriff)
{
 kolission = 0;
 
 ueberlauf.remove();   // Loeschen der Kolissionsliste
 
 // Anlegen eines dynamischen Arrays von int-Werten fuer den Adressraum

 arr = new int[p];
  
 if (arr == 0)
	speicher();

 // Vorbelegen des Arrays mit -1

 for(int j=0 ; j<p ; j++)
   arr[j] = -1;

 /* Durchfuehrung der Zuordnung mit Hilfe der Schiebefaltungs-Methode */
 
 // aehnlich der vorangegangenen Methode wird hier ebenfalls jeder
 // Schluesselwert in Abschnitte mit beliebiger Laenge zerlegt. Allerdings
 // wird vor dem Aufsummieren jeder zweite Abschnitt invertiert.

 for (int i = 0; i < anzahl; i++)
 {
  C_xlong invers;
  long index = 0;
  int laufen = 0;

  for(int l=1 ; l<=((eingabe[i].finput.getLength() + (zugriff-1))/zugriff) ; l++)
              // Ermittlung der Anzahl der Abschnitte mit der vom
              // Benutzer gewaehlten Laenge

  {
   // Aufsummierung der "ungeraden" Abschnitte

   if(l%2 > 0)
     index += tolong(eingabe[i].finput(laufen, zugriff));

   // Invertierung aller "geraden" Abschnitte und anschliessendes Aufsummieren

   else
     {
	  invers = (eingabe[i]).finput.invert(laufen, zugriff);
      index = index + tolong(invers(0, zugriff));
     }

   // Inkrementierung des Laufindex um auf den naechsten Abschnitt
   // zugreifen zu koennen

   laufen += zugriff;
  }
  
  // Um zu verhindern, dass das errechnete Ergebnis den gewaehlten
  // Adressraum verlaesst, Modulo-Division des Ergebnisses durch die
  // Groesse des Adressraumes

  index = index % p;
  
  // Falls das ermittelte Register noch unbesetzt ist (Eintrag -1),
  // so wird, um Speicherplatz zu sparen, nur der Laufindex des jeweiligen
  // Schluesselwertes in dem erstellten Adressraum gespeichert
  
  if (arr[index] == -1)
    arr[index] = i;

  // Falls das ertmittelte Register bereits belegt ist, so wird der
  // Schluesselwert an die Kolissionsliste angefuegt

  else
    {
     kolission++;
	 
	 C_xstrlong tmp(eingabe[i].keystr);
	
	 ueberlauf.append(tmp);
    }
 }

 ((CHashDlg *) (theApp.m_pMainWnd))->setStatus("Status: Berechnung beendet!!!");

 // Aufruf der Ausgabefunktion

 ausgabe(arr);

 p = ADDRESSRANGE;

 return;
}
Beispiel #21
0
int main()
{
    int check=0;
    char c;
    char filepath[50];
    int i, j;
    
    do {
        //Menü
        printf("Auswahl:\n(a)Test Raetzel 1\n(b)Test Raetzes 2\n(c)Filename Eingeben\n(e)Beenden\n");
        
            scanf("%s",&c);
            switch (c) {
                case 'a' :
                    raetsel1();
                    ausgabe();
                    //Wenn Sudoku Lösbar, dann ausgabe von gelöstem Sudoku
                    // sonst ausgabe "NO SOLUTION"
                    if(fillsudoku(sudokuarr, 0, 0)){
                        printf("Loesung:\n\n");
                        ausgabe();
                    }
                    else{
                        printf("NO SOLUTION\n\n");
                    }
                    break;
                    
                case 'b' :
                    raetsel2();
                    ausgabe();
                    //Wenn Sudoku Lösbar, dann ausgabe von gelöstem Sudoku
                    // sonst ausgabe "NO SOLUTION"
                    if(fillsudoku(sudokuarr, 0, 0)){
                        printf("Loesung:\n\n");
                        ausgabe();
                    }else{printf("NO SOLUTION\n\n");}
                    break;
                    
                case 'c' :
                    filetoarray();
                    ausgabe();
                    //Wenn Sudoku Lösbar, dann ausgabe von gelöstem Sudoku
                    // sonst ausgabe "NO SOLUTION"
                    if(fillsudoku(sudokuarr, 0, 0)){
                    printf("Loesung:\n\n");
                    ausgabe();
                    }else{printf("NO SOLUTION\n\n");}
                    break;
                    
                case 'e':
                    check=1;
                    break;
                    
                default:
                    printf("\nFalsche Eingabe\n\n");
                    break;
            }
        fflush(stdin);
    } while (check==0);

    return EXIT_SUCCESS;
}