void RadioSubTitle::NewMessage(const int theTalker, const int theFrag, const unsigned long thePlayTime, const char theFilter)
{
#ifdef THREADSTUFF // locking out the graphicsthread..
EnterCriticalSection(&cs_radiosubtitle);
#endif
currentlyEditedNode = new SubTitleNode();
if (!currentlyEditedNode)
{
assert(false);
#ifdef THREADSTUFF
LeaveCriticalSection(&cs_radiosubtitle);
#endif
return;
}
LinkedListCount++;
currentlyEditedNode->messageStartTime = thePlayTime;
currentlyEditedNode->associatedChannel = FindChannelColour(theFilter);
#ifndef DISPLAY_CHANNEL_NAME
char* rchunk = GetRadioChunk(theTalker, theFrag);
if (rchunk)
{
OverWriteString(¤tlyEditedNode->theSpokenLine, rchunk);
}
#else
char* chan = FindChannelName(theFilter);
char* rchunk = GetRadioChunk(theTalker, theFrag);
if (rchunk)
{
char* sum = (char*)malloc(strlen(chan)+strlen(rchunk)+1);
if (sum)
{
strcpy(sum,chan);
strcat(sum,rchunk);
OverWriteString(¤tlyEditedNode->theSpokenLine, sum);
free(sum);
}
}
#endif
SubTitleNode* index = (SubTitleNode*)theRadioChatterList->GetHead();
while ((index)&&(index->messageStartTime < thePlayTime))
{
index = (SubTitleNode*)index->GetSucc();
}
if (index)
currentlyEditedNode->InsertAfter(index);
else
theRadioChatterList->AddTail(currentlyEditedNode);
#ifdef THREADSTUFF
LeaveCriticalSection(&cs_radiosubtitle);
#endif
}
/**************************************************************************
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();
}
/**************************************************************************
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);
}
}
