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);
}
}
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);
}
}
/**************************************************************************
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;
}
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";
}
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;
}
/**************************************************************************
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;
}
}
}
/**************************************************************************
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;
}
}
}
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);
}
}
}
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;
}
/**************************************************************************
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);
}
}
/**************************************************************************
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);
}
}
/**************************************************************************
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();
}
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;
}
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;
}
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;
}
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;
}