; -------> SeaInclude including C:\Discom\Measurement\Basic\Multimeter\Application\Conf_Include.sea

;<# 	global [LANG] = German #>

; --------------------------------------------------------------------------
; Source-Thread (Data source & Resampling)
; --------------------------------------------------------------------------

; Tas-Box
;--------------------------------------------------------------
; <# include Conf_System.sea () #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_System.sea
; Conf_system.sea
;
; Tas-System-Setup
; 
; Konfigurationsbaustein für eine und einzige Tas-Box, incl. Container
;
; $Date: 2020-09-15 17:05:40 +0200 (Di, 15. Sep 2020) $
; $Revision: 26506 $

; FIXME: [SourceChanClone] ist hier obsolet -- Verwende die gleiche Option
; fuer Conf_General.sea!
; <# option [SourceChanClone]		"TRUE: mit Kanalverdoppler an der Quelle" #>
; -------> with   [SourceChanClone]: option not set   ("TRUE: mit Kanalverdoppler an der Quelle")
; <# option [SoundCardInput]		"TRUE: mit SoundCard-Input statt TasContainer" #>
; -------> with   [SoundCardInput]: option not set   ("TRUE: mit SoundCard-Input statt TasContainer")
; <# option [CAN]					"TRUE: mit CAN-Bus Interface"					#>
; -------> with   [CAN]: option not set   ("TRUE: mit CAN-Bus Interface")
; <# option [TAC]					"TRUE: mit TAC PwrGen-Steuermodul"				#>
; -------> with   [TAC]: option not set   ("TRUE: mit TAC PwrGen-Steuermodul")
; <# option [Legacy]				"TRUE: mit Verkabelung für Binaries vor 9.März 2018 (23951)"	#>
; -------> with   [Legacy]: option not set   ("TRUE: mit Verkabelung für Binaries vor 9.März 2018 (23951)")

; <# 
;    if ([LANG] == German) 
; 	local "Calibration"						= "Kalibrierung"
; 	local "Clone source channels"			= "Quell-Kanäle duplizieren"
; 	local "Soundcard Input"					= "Soundkarten-Eingang"
; 	local "TAC Power Control"				= "TAC Schwingkreis-Kontrolle"
; 
;    elsif ([LANG] == Italian) 
; 	local "Calibration"						= "Calibratore"
; 	local "Clone source channels"			= "Copiare di canale origine"
; 
;    elsif ([LANG] ==	Espanol)
; 	local "Calibration"						= "Calibración"
; 	local "Clone source channels"			= "clonar canales del fuente"
; 
;    elsif ([LANG] == Japanese) 
; 	local "Calibration"						= "校正"
; 
;    elsif ([LANG] == Chinese) 
; 	local "Calibration"						= "校准"
; 
;    elsif ([LANG] == Korean) 
; 	local "Calibration"						= "교정"
; 
;    elsif ([LANG] == Russian) 
; 	local "Calibration"						= "калибровка"
; 
;    elsif ([LANG] == Portuguese) 
; 	local "Calibration"						= "Calibração"
; 	local "Clone source channels"			= "clonar canais-fonte"
; 
;    elsif ([LANG] == Hungarian) 
; 	local "Calibration"						= "Kalibráció"
; 
; 
;    else
;    end
; #>
 
; <# local [SourceWirePlugIn]		= SourceData	#>

; --------------------------------------------------------------------------
; SourceChanClone: Kanalverdoppler im Quell-Datenstrom (Teil 1 hier, Teil 2 am Ende dieser Datei)
; FIXME: [SourceChanClone] ist hier obsolet -- Verwende die gleiche Option
; fuer Conf_General.sea!

; <# if ([SourceChanClone] == TRUE) #>
; <# local [SourceWirePlugIn]		= -[SourceWirePlugIn]	#>
; <# end #>

; --------------------------------------------------------------------------
; CAN Bus Input (Teil 1 hier, Teil 2 am Ende dieser Datei)

; <# if ([CAN] == TRUE) #>
; 	<# include Conf_Can.sea( [InWireName]=<-[SourceWirePlugIn]>, [OutWireName]=<[SourceWirePlugIn]> ) #>
; 	<# local [SourceWirePlugIn]		= -[SourceWirePlugIn]	#>
; <# end #>

; --------------------------------------------------------------------------
; TAS-Input
; --------------------------------------------------------------------------

; <# if ([SoundCardInput] != TRUE) #>
SourceThread.Modules: {+
	CTasSystemModule	TasContainer					"TAS Input"					92
}

TasContainer.Modules: {
	CTasContainer		TAS-Box						"Tas Box"					37
; <# if ([TAC] == TRUE) #>
; <# end #>
}

TAS-Box.Modules: {
; <# if( [Legacy] == TRUE ) #>
; <# end #>
 	CUsbInterfaceModule	USBInterface				"TAS USB Module"			13
	CTasDataToMux		Byte2Mux					"Byte to MuxData"			26
}

USBInterface.Modules: {
; <# if( [Legacy] == TRUE ) #>
; <# end #>
	 CModuleOutputWire	DataFromUSB					<A/D-Data>					9
}

; <# if( [Legacy] == TRUE ) #>
; <# end #>

Byte2Mux.Modules: {
	CModuleInputWire	Input						<A/D-Data>						8
	CCalibrator			Calibration					"Calibration"					51		Calibrator
	CtOutputWire		Output						<SourceData>			9
}

LoadDll: {+
	lCalib
}

;;; <# if ([SoundCardInput] != TRUE) #>
; <# else #>
; --------------------------------------------------------------------------
; Aternativ: Soundkarten-Input
; --------------------------------------------------------------------------
;;; <# if ([SoundCardInput] != TRUE) #>
; <# end #>

; --------------------------------------------------------------------------
; CAN Bus Input (Teil 2 hier, Teil 1 am Anfang dieser Datei)
; --------------------------------------------------------------------------

; <# if ([CAN] == TRUE) #>
; <# end #>

; --------------------------------------------------------------------------
; SourceChanClone (Teil 2)
; --------------------------------------------------------------------------

; <# if ([SourceChanClone] == TRUE) #>
; <# end #>

; Fuehrungsgroessen
;--------------------------------------------------------------
; <# include Conf_SimpleFG.sea([Name]=AnalogVal, [UserName]="Analog Value") #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_SimpleFG.sea
; Conf_SimpleFG.sea
;
; Konfigurationsfile für die Universal-Applikation
; -> Einfache Führungsgrösse (z.B. Drehmoment, Temperatur, ...)
;
; $Date: 2009-04-21 14:01:03 +0200 (Di, 21. Apr 2009) $
; $Revision: 19080 $
; <# param  [Name]		"Interner Name" #>
; -------> with   [Name]=AnalogVal   ("Interner Name")
; <# param  [UserName]	"Benutzername der Führungsgrösse" #>
; -------> with   [UserName]="Analog Value"   ("Benutzername der Führungsgrösse")
; <# option [Scalable]	"TRUE: FueGroeSkaliert statt FueGroeEinfach einbauen" #>
; -------> with   [Scalable]: option not set   ("TRUE: FueGroeSkaliert statt FueGroeEinfach einbauen")

FüGröBox.Modules: {+
; <# if ([Scalable]) #>
; <# else #>
	CFueGroeEinfach			FGAnalogVal		"Analog Value"		27		"Contol value AnalogVal"
; <# end #>
}
; <# include Conf_Spd.sea([Nr]=1, [UserName]="Speed Pulses") #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_Spd.sea
; Conf_Spd.sea
;
; Konfigurationsfile für die Universal-Applikation
; Drehzahlquelle (Standard)
;
; $Date: 2019-07-26 09:32:45 +0200 (Fr, 26 Jul 2019) $
; $Revision: 25216 $
; <# param  [Nr]			"Enumerator" #>
; -------> with   [Nr]=1   ("Enumerator")
; <# param  [UserName]	"Benutzername der Drehzahlquelle" #>
; -------> with   [UserName]="Speed Pulses"   ("Benutzername der Drehzahlquelle")
; <# option [VCO]			"TRUE: VCO-Drehzahlquelle einbauen" #>
; -------> with   [VCO]: option not set   ("TRUE: VCO-Drehzahlquelle einbauen")

FüGröBox.Modules: {+
; <# if ([VCO]) #>
; <# else #>
	CDrehzahlQuelleStandard	Dz.Analog.1		"Speed Pulses"				19	"Analog Speed 1 "Speed Pulses""
; <# end #>
}

; General
;--------------------------------------------------------------
; <# include Conf_General.sea ([AFilter]=TRUE) #>	
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_General.sea
; Conf_General.sea
;
; Konfigurationsfile für die Universal-Applikation
; Allgemeine Infrastruktur
;
; $Date: 2021-02-23 10:53:33 +0100 (Di, 23 Feb 2021) $
; $Revision: 27025 $

; <# option [Torque]				"TRUE: Drehzahl-Führungsgröße einbauen" #>
; -------> with   [Torque]: option not set   ("TRUE: Drehzahl-Führungsgröße einbauen")
; <# option [2ndMirror]			"TRUE: mit 2. Mirror-Modul" #>
; -------> with   [2ndMirror]: option not set   ("TRUE: mit 2. Mirror-Modul")
; <# option [AFilter]				"TRUE: mit CRawFilter-Modul" #>
; -------> with   [AFilter]=TRUE   ("TRUE: mit CRawFilter-Modul")
; <# option [CVFilter]			"TRUE: Filter für Führungsgrößen-Signale" #>
; -------> with   [CVFilter]: option not set   ("TRUE: Filter für Führungsgrößen-Signale")
; <# option [SourceChanClone]		"TRUE: mit Kanalverdoppler an der Quelle" #>
; -------> with   [SourceChanClone]: option not set   ("TRUE: mit Kanalverdoppler an der Quelle")
; <# option [Modulation]			"TRUE: Modulationsanalyse einbauen"	#>
; -------> with   [Modulation]: option not set   ("TRUE: Modulationsanalyse einbauen")
; <# option [LearnMachine]		"FALSE: Lernmaschine für autom. Grenzfindung weglassen"	#>
; -------> with   [LearnMachine]: option not set   ("FALSE: Lernmaschine für autom. Grenzfindung weglassen")
; <# option [TransmissionError]	"TRUE: Übersetzungsfehler ermitteln"	#>
; -------> with   [TransmissionError]: option not set   ("TRUE: Übersetzungsfehler ermitteln")
; <# option [DataExportService]	"TRUE: Netzwerkservice zur Externen Interaktion"	#>
; -------> with   [DataExportService]: option not set   ("TRUE: Netzwerkservice zur Externen Interaktion")
; <# option [TestConditionLookout]	"TRUE: Suche stabile Testbedingungen"	#>
; -------> with   [TestConditionLookout]: option not set   ("TRUE: Suche stabile Testbedingungen")
; <# option [AudioMonitor]			"FALSE: Monitor-Modul weglassen"		#>
; -------> with   [AudioMonitor]: option not set   ("FALSE: Monitor-Modul weglassen")

; Behandlung der Optionen mit Defaultwert 'TRUE'
; <# ifdef ([LearnMachine]) #>
; <# else #>
; <# local [LearnMachine]		= TRUE	#>
; <# end #>
; <# ifdef( [AudioMonitor] ) #>
; <# else #>
; <# local [AudioMonitor]		= TRUE	#>
; <# end #>

; <# 
;    if ([LANG] == German) 
; 	local "Source"							= "Quelle"
; 	local "Processing"						= "Verarbeitung"
; 	local "Evaluation"						= "Auswertung"
; 	local "Clone source channels"			= "Quell-Kanäle duplizieren"
; 	local "Wave Audio Playback"				= "Wave-Datei Wiedergabe"
; 	local "Inject System State"				= "System-Status einfügen"
; 	local "Control Values Container"		= "Führungsgrößen bilden"
; 	local "Wave Audio Recording"			= "Wave-Datei Aufzeichnen"
; 	local "Signal Monitor"					= "Signal-Monitor"
; 	local "Clone channels"					= "Kanäle duplizieren"
; 	local "Rectify"							= "Gleichrichten"
; 	local "Resampling"						= "Resampling"
; 	local "Control Values"					= "Führungsgrößen"
; 	local "Autom. Mode Generator"			= "Autom. Prüfzustände"
; 	local "Control Value Tracking"			= "Führungsgrößen messen"
; 	local "Torque"							= "Drehmoment"
; 	local "Trigger"							= "Trigger"
; 	local "Start/Stop Measurement"			= "Messung Start/Stop"
; 	local "Test Speed"						= "Test Drehzahl"
; 	local "Main Thread Connections"			= "Main Thread Kabelverbindungen"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Scopes"
; 	local "Measured Values"					= "Gemessene Werte"
; 	local "Mosaic Window"					= "Mosaikfenster"
; 	local "Analysis Results"				= "Analyseergebnisse"
; 	local "Test History"					= "Prüfungs-Verlauf"
; 	local "Result Indicator"				= "Bewertungsergebnis"
; 	local "Command Center"					= "Kommandozentrale"
; 	local "Automatic serial number"			= "Autom. Seriennummer erzeugen"
; 	local "Store Results"					= "Ergebnisse Speichern"
; 	local "Archive Measurements"			= "Messungen archivieren"
; 	local "Copy/Move Archives"				= "Archive kopieren/verschieben"
; 	local "Move Archives"					= "Archive verschieben"
; 	local "Concatenate Archives"			= "Archive kleben"
; 	local "Archive Reloader"				= "Archiv-Daten laden"
; 	local "Report Generator"				= "Berichts-Generator"
; 	local "Unit Test"						= "Selbsttest"
; 	local "Logger Settings"					= "Meldungen Konfigurieren"
; 	local "Command Playback"				= "Playback-Steuerung"
; 	local "Resampled Time Signals"			= "Zeitsignale Resamp"
; 	local "Central Analysis"				= "Auswertezentrale"
; 	local "Database Cache"					= "Datenbank-Cache"
; 	local "Learning Supervisor"				= "Lern-Steuerung"
; 	local "Parameter Database"				= "Parameterdatenbank"
; 
;    elsif ([LANG] == Espanol) 
; 	local "Source"							= "Fuente"
; 	local "Processing"						= "Procesamiento"
; 	local "Evaluation"						= "Evaluación"
; 	local "Wave Audio Playback"				= "Reproducir archivo Wave"
; 	local "Inject System State"				= "Agregar Estado de sistema"
; 	local "Control Values Container"		= "Crear variables de referencia"
; 	local "Clone source channels"			= "clonar canales del fuente"
; 	local "Wave Audio Recording"			= "Grabar archivo Wave"
; 	local "Clone channels"					= "Clonar canales"
; 	local "Rectify"							= "Rectificar"
; 	local "Resampling"						= "Resampling"
; 	local "Control Values"					= "Variables de referencia"
; 	local "Autom. Mode Generator"			= "Estados de prueba automáticos"
; 	local "Control Value Tracking"			= "Grabar variables de referencia"
; 	local "Torque"							= "Torque"
; 	local "Trigger"							= "Trigger"
; 	local "Start/Stop Measurement"			= "Iniciar/detener medición"
; 	local "Test Speed"						= "Velocidad de prueba"
; 	local "Main Thread Connections"			= "Conecciones Main Thread"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Áreas"
; 	local "Measured Values"					= "Valores medidos"
; 	local "Mosaic Window"					= "Ventana mosaico"
; 	local "Test History"					= "Secuencia de testo"
; 	local "Analysis Results"				= "Resultados del análisis"
; 	local "Result Indicator"				= "Indicador de resultado"
; 	local "Command Center"					= "Central de comando"
; 	local "Automatic serial number"			= "Generar estados de prueba automáticos"
; 	local "Store Results"					= "Guardar mediciones"
; 	local "Archive Measurements"			= "Archivar mediciones"
; 	local "Copy/Move Archives"				= "Copiar/Mover archivos"
; 	local "Move Archives"					= "Mover archivos"
; 	local "Concatenate Archives"			= "Pegar archivos"
; 	local "Archive Reloader"				= "Cargar datos de archivo"
; 	local "Unit Test"						= "Autotest"
; 	local "Logger Settings"					= "Configurar mensajes"
; 	local "Command Playback"				= "Comando Playback"
; 	local "Resampled Time Signals"			= "Modificar señal de tiempo"
; 	local "Central Analysis"				= "Central de análisis"
; 	local "Database Cache"					= "Cache de banco de datos"
; 	local "Learning Supervisor"				= "Comando de aprendizaje"
; 	local "Parameter Database"				= "Banco de datos de parámetros"
; 	local "Time signal"						= "Señal de tiempo"
; 
;    elsif ([LANG] == French) 
; 	local "Wave Audio Playback"				= "Lecture d'une fichier d'audio"
; 	local "Inject System State"				= "Injecter le state du Systéme"
; 	local "Control Values Container"		= "Creér des valeurs de contrôle"
; 	local "Wave Audio Recording"			= "Enregistrer d'une fichier d'audio"
; 	local "Clone channels"					= "Copier des canaux"
; 	local "Rectify"							= "Redresser"
; 	local "Resampling"						= "Echantillonnage"
; 	local "Control Values"					= "Valeurs de contrôle"
; 	local "Autom. Mode Generator"			= "Etats de mesure automatiquement"
; 	local "Control Value Tracking"			= "Enregistrer des valeurs de contrôle"
; 	local "Torque"							= "Torque"
; 	local "Trigger"							= "Trigger"
; 	local "Start/Stop Measurement"			= "Start/Stop du mésure"
; 	local "Test Speed"						= "vitesse du Test"
; 	local "Main Thread Connections"			= "connexiones du main thread"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Scopes"
; 	local "Measured Values"					= "Valeurs mesurée"
; 	local "Mosaic Window"					= "Fénêtre Mosaic"
; 	local "Analysis Results"				= "Resultats d'Analyse"
; 	local "Result Indicator"				= "Indicateur des resultats"
; 	local "Command Center"					= "Centre des commandes"
; 	local "Automatic serial number"			= "Creer des serials automatiquement"
; 	local "Store Results"					= "Archiver des données de mesure"
; 	local "Archive Measurements"			= "Archiver des données de mesure"
; 	local "Copy/Move Archives"				= "Copier/Déplacer des Archives"
; 	local "Move Archives"					= "Déplacer des Archives"
; 	local "Concatenate Archives"			= "Concat. des Archives"
; 	local "Unit Test"						= "Test"
; 	local "Logger Settings"					= "Propiétés du Logger"
; 	local "Command Playback"				= "Contrôle Playback"
; 	local "Resampled Time Signals"			= "Signaux de temps"
; 	local "Central Analysis"				= "Centrum d'evaluation"
; 	local "Database Cache"					= "Base de données (Cache)"
; 	local "Learning Supervisor"				= "Contrôler d'apprentissage"
; 	local "Parameter Database"				= "Base de données des parametres"
; 
;    elsif ([LANG] == Italian) 
; 	local "Source"							= "Origine"
; 	local "Processing"						= "Elaborazione"
; 	local "Evaluation"						= "Analisi"
; 	local "Clone source channels"			= "Copiare di canale origine"
; 	local "Wave Audio Playback"				= "Riproduzione des files 'wav'"
; 	local "Inject System State"				= "Inserire il stato di sistema"
; 	local "Control Values Container"		= "Container des valores di controllo"
; 	local "Wave Audio Recording"			= "Registrazione des files 'wav'"
; 	local "Clone channels"					= "Copiare di canale"
; 	local "Rectify"							= "Raddrizzare"
; 	local "Resampling"						= "Resampling"
; 	local "Control Values"					= "Valores di controllo"
; 	local "Autom. Mode Generator"			= "Autom. Mode Generator"
; 	local "Control Value Tracking"			= "Registrazione des valores di controllo"
; 	local "Torque"							= "Momento torcente"
; 	local "Trigger"							= "Trigger"
; 	local "Start/Stop Measurement"			= "Misurazione Start/Stop"
; 	local "Test Speed"						= "Test Speed"
; 	local "Main Thread Connections"			= "Connessione cavo Main Thread"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Scopes"
; 	local "Measured Values"					= "Valores di analisi"
; 	local "Mosaic Window"					= "Mosaic window"
; 	local "Analysis Results"				= "Risulatato di analisi"
; 	local "Result Indicator"				= "Indicatore di risultato"
; 	local "Command Center"					= "Centrale di controllo"
; 	local "Automatic serial number"			= "Automatic serial number"
; 	local "Store Results"					= "Memorizzare des valores di analisi"
; 	local "Archive Measurements"			= "Archiviare des valores di analisi"
; 	local "Copy/Move Archives"				= "Copiare/Dislocare de archivio"
; 	local "Move Archives"					= "Dislocare de archivio"
; 	local "Concatenate Archives"			= "Agglutinarsi de archivio"
; 	local "Unit Test"						= "Unit test"
; 	local "Logger Settings"					= "Logger Settings"
; 	local "Command Playback"				= "Playback"
; 	local "Resampled Time Signals"			= "Resampled Time Signals"
; 	local "Central Analysis"				= "Centrale di analisi"
; 	local "Database Cache"					= "Cache de banco dati"
; 	local "Learning Supervisor"				= "Controllo d'apprendere"
; 	local "Parameter Database"				= "Banco dati"
; 	
;    elsif ([LANG] == Czech) 
; 	local "Source"							= "Zdroj"
; 	local "Processing"						= "Zpracování"
; 	local "Evaluation"						= "Vyhodnocení"
; 	local "Wave Audio Playback"				= "Přehrát Wave-Soubory"
; 	local "Inject System State"				= "Přiložit system-status"
; 	local "Control Values Container"		= "Vstupní hodnoty"
; 	local "Wave Audio Recording"			= "Vytvořit audio záznam"
; 	local "Clone channels"					= "Kanály duplikovat"
; 	local "Rectify"							= "Vyrovnat"
; 	local "Resampling"						= "Převzorkování"
; 	local "Control Values"					= "Řídící hodnoty"
; 	local "Autom. Mode Generator"			= "Autom. zkušební stavy"
; 	local "Control Value Tracking"			= "Záznam řídících hodnot"
; 	local "Torque"							= "Točivý moment "
; 	local "Trigger"							= "Spouštěč"
; 	local "Start/Stop Measurement"			= "Měření Start/Stop"
; 	local "Test Speed"						= "Počet otáček Test"
; 	local "Main Thread Connections"			= "Hlavní spojení"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Grafy"
; 	local "Measured Values"					= "Naměřené hodnoty"
; 	local "Mosaic Window"					= "Mozaikové okno"
; 	local "Analysis Results"				= "Výsledky analýzy"
; 	local "Result Indicator"				= "Výsledek hodnocení"
; 	local "Command Center"					= "Řídíci ústředna"
; 	local "Automatic serial number"			= "Vytvořit autom. sériové číslo"
; 	local "Store Results"					= "Archivovat měření..."
; 	local "Archive Measurements"			= "Archivovat měření"
; 	local "Copy/Move Archives"				= "Archivy kopírovat/posunout"
; 	local "Move Archives"					= "Archivy posunout"
; 	local "Concatenate Archives"			= "Archivy seskupit"
; 	local "Archive Reloader"				= "Archiv-údaje načíst"
; 	local "Unit Test"						= "Samočinný test"
; 	local "Logger Settings"					= "Nastavení hlášení"
; 	local "Command Playback"				= "Playback-řízení"
; 	local "Resampled Time Signals"			= "Převzorkované časové signály"
; 	local "Central Analysis"				= "Vyhodnocovací centrála"
; 	local "Database Cache"					= "Databáze-Cache"
; 	local "Learning Supervisor"				= "Průvodce učením"
; 	local "Parameter Database"				= "Databáze parametrů"
; 
;    elsif ([LANG] == Japanese) 
; 	local "Source"							= "ソース"
; 	local "Processing"						= "解析中"
; 	local "Evaluation"						= "評価"
; 	local "Wave Audio Playback"				= "Waveファイル再生"
; 	local "Wave Audio Recording"			= "Waveファイル録音"
; 	local "Signal Monitor"					= "信号モニタ"
; 	local "Control Values"					= "制御値"
; 	local "Torque"							= "トルク "
; 	local "Trigger"							= "トリガー"
; 	local "Measured Values"					= "測定値"
; 	local "Analysis Results"				= "解析結果"
; 	local "Result Indicator"				= "判定結果"
; 	local "Command Center"					= "コマンドセンター"
; 	local "Resampled Time Signals"			= "時間信号"
; 	local "Parameter Database"				= "パラメータデータベース"
; 
;    elsif ([LANG] == Chinese) 
; 	local "Source"							= "信号源"
; 	local "Processing"						= "信号处理"
; 	local "Evaluation"						= "分析评估"
; 	local "Wave Audio Playback"				= "声音文件播放"
; 	local "Wave Audio Recording"			= "声音文件记录"
; 	local "Signal Monitor"					= "信号监测"
; 	local "Analysis Results"				= "报告窗口"
; 	local "Result Indicator"				= "测试结果"
; 	local "Command Center"					= "控制中心"
; 	local "Parameter Database"				= "参数数据库"
; 	local "Measured Values"					= "测量值"
; 	local "Central Analysis"				= "分析中心"
; 	local "Store Results"					= "结果存储"
; 	local "Archive Measurements"			= "结果存档"
; 	local "Copy/Move Archives"				= "复制/移动档案文件"
; 	
;    elsif ([LANG] == Korean) 
; 	local "Source"							= "소스"
; 	local "Processing"						= "처리중"
; 	local "Evaluation"						= "결과"
; 	local "Wave Audio Playback"				= "웨이브파일 재생기"
; 	local "Wave Audio Recording"			= "웨이브파일 녹음기"
; 	local "Signal Monitor"					= "주파수 모니터"
; 	local "Torque"							= "Torque"
; 	local "Analysis Results"				= "분석 결과"
; 	local "Result Indicator"				= "결과 표시기"
; 	local "Command Center"					= "커맨드센터"
; 	local "Parameter Database"				= "파라미터 데이터베이스"
; 
;    elsif ([LANG] == Portuguese) 
; 	local "Source"							= "Fonte"
; 	local "Processing"						= "Processamento"
; 	local "Evaluation"						= "Evaliação"
; 	local "Clone source channels"			= "clonar canais-fonte"
; 	local "Wave Audio Playback"				= "Reproduzir Arquivo de Áudio"
; 	local "Inject System State"				= "Estado do Sistema de Injeção"
; 	local "Control Values Container"		= "Crear variables de referencia"
; 	local "Wave Audio Recording"			= "Grabar archivo Wave"
; 	local "Clone channels"					= "Clonar canales"
; 	local "Rectify"							= "Rectificar"
; 	local "Resampling"						= "Resampling"
; 	local "Control Values"					= "Valores de Controle"
; 	local "Autom. Mode Generator"			= "Gerador do Modo Automático"
; 	local "Control Value Tracking"			= "Rastreio do Valor de Controle"
; 	local "Torque"							= "Torque"
; 	local "Trigger"							= "Acionar"
; 	local "Start/Stop Measurement"			= "Iniciar/Parar Medição"
; 	local "Test Speed"						= "Velocidade do Teste"
; 	local "Main Thread Connections"			= "Conexões das linhas principais"
; 	local "Terminal"						= "Terminal"
; 	local "Scopes"							= "Escopos"
; 	local "Measured Values"					= "Valores medidos"
; 	local "Mosaic Window"					= "Janela de Mosáicos"
; 	local "Analysis Results"				= "Resultados das Análises"
; 	local "Result Indicator"				= "Indicador de resultados"
; 	local "Command Center"					= "Central de comando"
; 	local "Automatic serial number"			= "No. Serial Automático"
; 	local "Store Results"					= "Salvar Resultados"
; 	local "Archive Measurements"			= "Salvar medições"
; 	local "Copy/Move Archives"				= "Copiar/Mover Arquivos"
; 	local "Move Archives"					= "Mover Arquivos"
; 	local "Concatenate Archives"			= "Concatenar Arquivos"
; 	local "Archive Reloader"				= "Recarregar Arquivo"
; 	local "Unit Test"						= "Teste da Unidade"
; 	local "Logger Settings"					= "Configs. do Registrador"
; 	local "Command Playback"				= "Reproduzir Playback"
; 	local "Resampled Time Signals"			= "Sinais de tempo reamostrados"
; 	local "Central Analysis"				= "Central de análises"
; 	local "Database Cache"					= "Cache do banco de dados"
; 	local "Learning Supervisor"				= "Supervisor de Aprendizagem"
; 	local "Parameter Database"				= "Banco de dasos de parámetros"
; 
;    elsif ([LANG] == Russian) 
; 	local "Source"							= "Источник данных"
; 	local "Processing"						= "Обработка"
; 	local "Evaluation"						= "Aнализ"
; 	local "Wave Audio Playback"				= "Воспроизведение WAVE-Файла"
; 	local "Wave Audio Recording"			= "Запись WAVE-Файла"
; 	local "Signal Monitor"					= "Монитор"
; 	local "Torque"							= "Момент силы"
; 	local "Measured Values"					= "Valores medidos"
; 	local "Analysis Results"				= "Протокол"
; 	local "Result Indicator"				= "Результат"
; 	local "Command Center"					= "центр управления"
; 	local "Parameter Database"				= "База данных"
; 
;    elsif ([LANG] == Polish) 
; 	local "Source"							= "żrńdło"
; 	local "Processing"						= "Obliczanie"
; 	local "Evaluation"						= "Ewaluacja"
; 	local "Wave Audio Playback"				= "Wave-Datei Wiedergabe"
; 	local "Wave Audio Recording"			= "Wave-Datei Aufzeichnen"
; 	local "Signal Monitor"					= "Signal-Monitor"
; 	local "Control Values Container"		= "Führungsgrößen bilden"
; 	local "Control Values"					= "Führungsgrößen"
; 	local "Control Value Tracking"			= "Führungsgrößen messen"
; 	local "Torque"							= "Drehmoment"
; 	local "Trigger"							= "Trigger"
; 	local "Start/Stop Measurement"			= "Messung Start/Stop"
; 	local "Test Speed"						= "Test Drehzahl"
; 	local "Measured Values"					= "Gemessene Werte"
; 	local "Analysis Results"				= "Analyseergebnisse"
; 	local "Result Indicator"				= "Bewertungsergebnis"
; 	local "Command Center"					= "Kommandozentrale"
; 	local "Automatic serial number"			= "Autom. Seriennummer erzeugen"
; 	local "Store Results"					= "Ergebnisse Speichern"
; 	local "Archive Measurements"			= "Messungen archivieren"
; 	local "Copy/Move Archives"				= "Archive kopieren/verschieben"
; 	local "Move Archives"					= "Archive verschieben"
; 	local "Concatenate Archives"			= "Archive kleben"
; 	local "Archive Reloader"				= "Archiv-Daten laden"
; 	local "Central Analysis"				= "Auswertezentrale"
; 	local "Parameter Database"				= "Parameterdatenbank"
; 
;    elsif ([LANG] == Hungarian) 
; 	local "Source"							= "Forrás"
; 	local "Processing"						= "Feldolgozás"
; 	local "Evaluation"						= "Kiértékelés"
; 	local "Wave Audio Playback"				= "Hangfájl lejátszás"
; 	local "Wave Audio Recording"			= "Hangfájl rögzítés"
; 	local "Signal Monitor"					= "Jel megjelenítő"
; 	local "Parameter Database"				= "Paraméteradatbázis"
; 	local "Result Indicator"				= "Eredménykijelző"
; 	local "Analysis Results"				= "Kiértékelés eredmények"
; 	local "Time signal"						= "Időjel"
; 
;    else
;    end
; #>

; <# if ([Modulation]!=TRUE) local <SourceMonitor>	= <Source>	end #>

; <# local [SourceWirePlugIn]		= SourceData	#>

; --------------------------------------------------------------------------
; CVFilter: Filter fuer Fuehrungsgroessen-Signale

; <# if ([CVFilter] == TRUE) #>
; <# local [AFilter]	= TRUE	#>
; <# end #>

; -----------------------------------------------------------------------------
; TestConditionLookoutModule: Segmentierung des Führungsgrößen-Kennfeldes

; <# if ([TestConditionLookout] == TRUE) #>
; Die Wave-Wiedergabe soll in den Segmentierer gehen, daher muss das Kabel hier konfiguriert werden, bevor [SourceWirePlugIn] umbenannt wird:
; [SourceWirePlugIn] umbenennen (so dass alle folgenden Module an der Ausgabe des Segmentierers hängen, nicht direkt an der Tas-Box)
; <# local [SourceWirePlugIn]		= [SourceWirePlugIn]-Segm	#>
; <# end #>

; --------------------------------------------------------------------------
; SourceChanClone: Kanalverdoppler im Quell-Datenstrom

; <# if ([SourceChanClone] == TRUE) #>
; [SourceWirePlugIn] umbenennen (so dass alle folgenden Module an der Ausgabe des Kanalverdopplers hängen, nicht direkt an der Tas-Box)
; <# local [SourceWirePlugIn]		= [SourceWirePlugIn]-SrcChnCln	#>
; <# end #>

; --------------------------------------------------------------------------

Root.Modules: {
	CThreadHead			SourceThread		"Source"					89		Source
	CModule				WorkerThreads		"Processing"				1		Processing
	CThreadHeadMT		MainThread			"Evaluation"				2		Evaluation
}

SourceThread.Modules: {+
	CDialogModule	CWavPlayerModuleT=WavPlayerModuleT	"Wave Audio Playback"		84		Wave-Playback
	CSystemStateInjector	SystemStateInjector			"Inject System State"		13		"System State Injector"
	CFueGroeContainer		CommandVariables			"Control Values Container"	37		"Control Values (Container)"
; <# if([TransmissionError] == TRUE) #>
; <# end #>
	CTasWavRecorder			TasWavRecorder				"Wave Audio Recording"		85		"Wave Recorder"
	CAddMuxChannels			MuxExpand					"Clone channels"			64		"Channel Cloner"
; <# if ([AFilter] == TRUE) #>
	CRawFilter				IIRFilter					"Filter"					50		Filter
; <# end #>
; <# if( [AudioMonitor] == TRUE ) #>
	CMonitorModule			AudioSignalMonitor			"Signal Monitor"			52		Signal-Monitor
; <# end #>
; <# if ([Modulation])		#>
; <# end #>
}

; --------------------------------------------------------------------------
; Source-Thread (Datenquellen und Resampling)
; --------------------------------------------------------------------------

; <# if ([TestConditionLookout] != TRUE) #>
WavPlayerModuleT.Modules: {	
	CtOutputWire			Output			<SourceData>	9
}
; <# end #>

SystemStateInjector.Modules: {
	CtOutputWire			Output			<SourceData>	9
}

CommandVariables.Modules: {
	CtInputWire				Input			<SourceData>	8
; <# if ([CVFilter] == TRUE) #>
; <# end #>
	CModule					FüGröBox		"Control Values"		4		"Control Values "
; <# if ([TransmissionError] == TRUE) #>
; <# else #>
	CtOutputWire			Output			<TriggerOut>			9
; <# end #>
	CCommandVariableTracker	CommandVariableTracker		"Control Value Tracking"	40		"Control Values Tracking"
}

FüGröBox.Modules: {+
	CDrehzahlQuelleTester	TestDz				"Test Speed"		19	"Test Speed Generator"
}

; <# if ([Torque] == TRUE) #>
; <# include Conf_SimpleFG.sea([Name]=Torque, [UserName]="Torque") #>
; <# end #>

; <# if ([TransmissionError] == TRUE) #>
; <# end #>

CommandVariableTracker.Modules: {
	CtInputWire				Input			<TriggerOut>			8
	CtOutputWire			Output			<RailroadTriggered>		9
	CtOutputWire			FinalOutput		<RailroadFinal>			9
}

TasWavRecorder.Modules: {
	CtInputWire				Input			<TriggerOut>			8
}

MuxExpand.Modules: {
	CtInputWire				Input			<TriggerOut>			8
; <# if ([AFilter] == TRUE) #>
	CtOutputWire			Output			<MuxExpandOut>			9
; <# else #>
; <# end #>
}

; <# if ([AFilter] == TRUE) #>
IIRFilter.Modules: {
	CtInputWire				Input			<MuxExpandOut>			8
	CtOutputWire			Output			<Source>			9
}
; <# end #>

; <# if( [AudioMonitor] == TRUE ) #>
AudioSignalMonitor.Modules: {
	CtInputWire				Input			<Source>			8
}
; <# end #>

Rectify.Modules: {
	CtInputWire				Input			<Source>			8
	CtOutputWire			Output			<Source>				9
}

; --------------------------------------------------------------------------
; Worker Threads
; --------------------------------------------------------------------------


; --------------------------------------------------------------------------
; Main Thread
; --------------------------------------------------------------------------

MainThread.Modules: {+
	CModule				MtWireBox					"Main Thread Connections"	17		"Main Thread Wire Box"

	CMainStation		Terminal					"Terminal"				24		Terminal

	CModule				ScopeContainer				"Scopes"				14		Scope-Box
	CTableWindowModule	TableWindow					"Measured Values"		26		"Measured Value Table"
	CTestVerlaufsModul	TestHistory					"Test History"			62		"Test Sequence History"
	CDiggerWindowModule	MosaicWindow				"Mosaic Window"			62		"Mosaic Result Window"
	CReportWindowModule	ReportWindow				"Analysis Results"		26		"Report Text Window"
	CAmpelModul			ErgebnisAmpel				"Result Indicator"		91		"Result Indicator Window"

; Ablaufsteuerung
	CDialogModule	CCommandCentre=CommandCentre	"Command Center"		12		"Command Center "

	CQEvSequencer		EvSequencer					"Central Analysis"		44		"Central Analysis "

	CModule				ArchiveContainer			"Archive Measurements"	87	"Archivation container"
	CParameterDataBaseInterfaceModule	ParamDb		"Parameter Database"	66		"Parameter Data Base"
;	CAutoTestModule		TestModule					"Unit Test"			55
}

CommandCentre.Modules: {
	CModuleOutputWire	Commands					<Commands>				9
	CControlSequencer	ControlSequencer			"Control Sequencer"		13	
	
	CDialogModule	CPlaybackDecoder=PlaybackDecoder	"Command Playback"			45 	"Command Playback "
}

ControlSequencer.Modules: {
	 CModuleInputWire	Commands					<Commands>				8
}

Terminal.Modules: {
	CtInputWire			FinalInput					<TerminalFinal>			8
	CtInputWire			TriggeredInput				<TerminalTriggered>		8
	CModuleOutputWire	TrackQuinterOutput			<TrackQuinter>			9
}

MtWireBox.Modules: {+
	CtBufferWire		InputTriggeredRailroad		<RailroadTriggered>		8
	CtOutputWire		OutputTerminalTriggered		<TerminalTriggered>		9
	CtBufferWire		InputFinalRailroad			<RailroadFinal>			8
	CtOutputWire		OutputFinalTriggered		<TerminalFinal>			9
}

EvSequencer.Modules: {
; <# if ([LearnMachine] == TRUE) #>
	CDialogModule	CQLearnFileDlg=LearnFileDlg		"Learning Supervisor"		41		"Learn Control"
; <# end #>
	CDialogModule	CQEvValueInspector=ValueInspector	"Inspector Q"			86
; <# if ([TestConditionLookout] == TRUE ) #>
; <# end #>
}

ArchiveContainer.Modules: {+
	CStorageModule		Archivator					"Archive Measurements"	53		"Write Archives"
	CMirrorModule		ArchiveMirror				"Copy/Move Archives"	30				"Move/Copy Archives"
; <# if ([2ndMirror] == TRUE) #>
; <# end #>
	CDialogModule		CGtrFilerModuleDialog=GtrFileKleber	"Concatenate Archives"	74	"Archive Concatenation"
	CArchiveReloader	ArchiveReloader				"Archive Reloader"		55			"Archive Reloader "
	CExportCurvePicts	HtmlExporter 				"Excel Exporter" 		75	"Html/Png Export"
	CMarvisReportGenerator	MvReportGenerator		"Report Generator"		20 "Mv Report Generator"
}

; <# ifdef ([DataExportService]) #>
; <# end #>

;--------------------------------------------------------------
; dll's to load
;--------------------------------------------------------------

LoadDll: {+
	lTas
	lBasicModules
	lDisplayModules
	lEvalModules
	lModUsb
	lAudio
	lResampling
	lSpecShow
	lSpsMcc
	lStorage
	lSpsInterface
; <# ifdef ([DataExportService]) #>
; <# end #>
}

; Resampling Container
;--------------------------------------------------------------
; <# include Conf_Resampling.sea () #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_Resampling.sea
; Conf_Resampling.sea
;
; Konfigurationsfile für die Universal-Applikation
; ResamplingContainer
;
; $Date: 2011-05-10 14:17:32 +0200 (Di, 10. Mai 2011) $
; $Revision: 20850 $

; <#
; 	option	[Cont]			"Containerbezeichnung bei mehreren Resampling-Containern"
; 	ifdef( [Cont] )
; 		local	[ChanName]	= "Resampling [Cont]"
; 		local	[Object]	=  ResampContainer.[Cont]
; 	else
; 		local	[ChanName]	= "Resampling"
; 		local	[Object]	=  ResampContainer
; 	end
; #>
; -------> with   [Cont]: option not set   ("Containerbezeichnung bei mehreren Resampling-Containern")

SourceThread.Modules: {+
	CResampContainer		ResampContainer		"Resampling"				90		Resampling
}

ResampContainer.Modules: {
	CtInputWire				Input			<Source>				8
}


; Processing Channels
;--------------------------------------------------------------

; <# include Conf_ResampGroupMux.sea([ChanName]=FixFs, [GroupName]=Fix) #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_ResampGroupMux.sea
; Conf_ResampChanInput.sea
;
; Konfigurationsfile für die Universal-Applikation
; Synchron-Verarbeitungskanal, ein Anschluss
;
; $Date: 2012-02-28 13:10:30 +0100 (Di, 28. Feb 2012) $
; $Revision: 21430 $

; <# param  [GroupName]		"Name dieser Resampling-Gruppe (z.B. 'Sync')" #>
; -------> with   [GroupName]=Fix   ("Name dieser Resampling-Gruppe (z.B. 'Sync')")
; <# param  [ChanName]		"Name der Verarbeitungskette (z.B. 'Sync-LS')" #>
; -------> with   [ChanName]=FixFs   ("Name der Verarbeitungskette (z.B. 'Sync-LS')")
; <# option [Cont]			"Optionale Bezeichnung des Resampling-Containers"
; 	ifdef( [Cont] )
; 		local	[Object]	=  ResampContainer.[Cont]
; 	else
; 		local	[Object]	=  ResampContainer
; 	end
; #>
; -------> with   [Cont]: option not set   ("Optionale Bezeichnung des Resampling-Containers")

; <# 
;    if ([LANG] == German) 
; 	local "Resampling Group [GroupName]"		= "Resampling-Gruppe [GroupName]"
;    elsif ([LANG] == French) 
; 	local "Resampling Group [GroupName]"		= "Resampling Group [GroupName]"
;    elsif ([LANG] == Italian) 
; 	local "Resampling Group [GroupName]"		= "Resampling Group [GroupName]"
;    else
;    end
; #>

; -------------------------------------------------------------------------------------------------
; Einrichten der Resampling-Gruppe:

ResampContainer.Modules: {+
	CResampMultiGroup			ResampGroup.Fix		"Resampling Group Fix"	82	"Resampling Fix"	
}

; Die ResampMultiGroup braucht nur ein einziges MuxOutput-Kabel:
ResampGroup.Fix.Modules: {+
	CtOutputWire		MuxOutput				<Resamp.Fix>				9
}

; -------------------------------------------------------------------------------------------------
; Anschließen im entsprechenden Verarbeitungskanal

WireBox.FixFs.Modules: {+
	CtBufferWire			Resamp.Fix				<Resamp.Fix>			8
	CtOutputWire			SoundSignal.FixFs			<SoundSignal.FixFs>		9
}
; <# include Conf_FixChanBase.sea([ChanName]=FixFs) #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_FixChanBase.sea
; Conf_FixChanBase.sea
;
; Konfigurationsfile für die Universal-Applikation
; Festfrequenz-Verarbeitungskanal, Basis
;
; $Date: 2020-08-27 11:49:27 +0200 (Do, 27. Aug 2020) $
; $Revision: 26435 $

; <# param  [ChanName]			"Kanalname (z.B. 'Fix.1')"			#>
; -------> with   [ChanName]=FixFs   ("Kanalname (z.B. 'Fix.1')")
; <# option [Sum]					"TRUE: Kanalmittler einbauen"		#>
; -------> with   [Sum]: option not set   ("TRUE: Kanalmittler einbauen")
; <# option [Sum2]				"TRUE: 2.Kanalmittler einbauen"		#>
; -------> with   [Sum2]: option not set   ("TRUE: 2.Kanalmittler einbauen")
; <# option [SumAndSingle]		"TRUE: wenn Kanalmittler: Alle Einzelsignale behalten"	#>
; -------> with   [SumAndSingle]: option not set   ("TRUE: wenn Kanalmittler: Alle Einzelsignale behalten")
; <# option [Diff]				"TRUE: Kanal-Differenz einbauen"		#>
; -------> with   [Diff]: option not set   ("TRUE: Kanal-Differenz einbauen")
; <# option [SpecTransform]		"TRUE: Spektral-Transformation einbauen"	#>
; -------> with   [SpecTransform]: option not set   ("TRUE: Spektral-Transformation einbauen")
; <# option [Geyser]				"TRUE: Clavis-Umkuddler einbauen"	#>
; -------> with   [Geyser]: option not set   ("TRUE: Clavis-Umkuddler einbauen")
; <# option [OrdMon]				"FALSE: OrdMon ausbauen"				#>
; -------> with   [OrdMon]: option not set   ("FALSE: OrdMon ausbauen")
; <# option [StoreTime]			"Zeitsignal speichern"									#>
; -------> with   [StoreTime]: option not set   ("Zeitsignal speichern")
; <# option [ModSpektrogramm]		"TRUE: Modulationsspektrogramm & Co. einbauen"			#>
; -------> with   [ModSpektrogramm]: option not set   ("TRUE: Modulationsspektrogramm & Co. einbauen")
; <# option [skipFFT]				"TRUE: ohne Spektralverarbeitung, nur Crest usw." #>
; -------> with   [skipFFT]: option not set   ("TRUE: ohne Spektralverarbeitung, nur Crest usw.")
; <# option [LogPostAver]			"TRUE: Logarithmierer NACH dem Spektralen Mittler einordnen"		#>
; -------> with   [LogPostAver]: option not set   ("TRUE: Logarithmierer NACH dem Spektralen Mittler einordnen")
; <# option [NoDetox]				"TRUE: Störbefreiung weglassen"				#>
; -------> with   [NoDetox]: option not set   ("TRUE: Störbefreiung weglassen")

; <# 
;    if ([LANG] == German) 
; 	local "Processing Channel [ChanName]"	= "Verarbeitungskanal [ChanName]"
; 	local "Time Domain Average [ChanName]"	= "Zeitbereichs-Mittelung [ChanName]"
; 	local "Single Values"					= "Einzahlkennwerte"
; 	local "Band sum"						= "Band-Summe"
; 	local "Channel average [ChanName]"		= "Kanal-Mittelung [ChanName]"
; 	local "Channel average 2 [ChanName]"		= "Kanal-Mittelung 2 [ChanName]"
; 	local "Spectral Average"				= "Spektrale Mittelung"
; 	local "Spectral Maximum [ChanName]"		= "Spektrales Maximum [ChanName]"
; 	local "Logarithm"						= "Logarithmierer"
; 	local "Channel difference [ChanName]"	= "Kanal-Differenz [ChanName]"
; 	local "Spectral Transform [ChanName]"	= "Spektral-Transformation [ChanName]"
; 	local "Trigger Filter"					= "Trigger-Filter"
; 	local "Railway Switch (Trigger)"		= "Weiche (Trigger)"
; 	local "Railway Switch (Final)"			= "Weiche (Final)"
; 	local "Trigger Settings"				= "Trigger Einstellungen"
; 	local "Single Value Display"			= "EKZ Anzeige"
; 	local "Shifting Noise"					= "Schaltgeräusch-Detektion"
; 	local "Short time spectrogram [ChanName]"	= "Kurzzeit-Spektrogramm [ChanName]"
; 	local "Short time spectrogram Maximum [ChanName]"	= "Maximiertes Kurzzeit-Spektrogramm [ChanName]"
; 	local "Modulation Spectrogram [ChanName]"	= "Modulationsspektrogramm [ChanName]"
; 	local "Modulation Spectrum [ChanName]"	= "Modulationsspektrum [ChanName]"
; 	local "Modulation Spectrum Maximum [ChanName]"	= "Maximiertes Modulationsspektrum [ChanName]"
; 	local "Spectrogram Areas [ChanName]"	= "Spektrogramm-Flächen [ChanName]"
; 	local "Mod. Spectrogram Areas [ChanName]"	= "Mod.Spektrogramm-Flächen [ChanName]"
; 
;    elsif ([LANG] == Italian) 
; 	local "Processing Channel [ChanName]"	= "Canale di elaborazione [ChanName]"
; 	local "Time Domain Average [ChanName]"	= "Time Domain Average [ChanName]"
; 	local "Single Values"					= "Single Values"
; 	local "Band sum"						= "Band sum"
; 	local "Spectral Average"				= "Spectral Average"
; 	local "Spectral Maximum [ChanName]"		= "Spectral Maximum [ChanName]"
; 	local "Logarithm"						= "Logarithm"
; 	local "Trigger Filter"					= "Trigger-Filter"
; 	local "Railway Switch (Trigger)"		= "Railway Switch (Trigger)"
; 	local "Railway Switch (Final)"			= "Railway Switch (Final)"
; 	local "Trigger Settings"				= "Trigger Settings"
; 	local "Single Value Display"			= "Single Value Display"
; 
;    elsif ([LANG] ==	Espanol)
; 	local "Processing Channel [ChanName]"	= "Canal de procesamiento [ChanName]"
; 	local "Time Domain Average [ChanName]"	= "Time Domain Average [ChanName]"
; 	local "Single Values"					= "Single Values"
; 	local "Band sum"						= "Band sum"
; 	local "Spectral Average"				= "Spectral Average"
; 	local "Spectral Maximum [ChanName]"		= "Spectral Maximum [ChanName]"
; 	local "Logarithm"						= "Logarithm"
; 	local "Trigger Filter"					= "Trigger-Filter"
; 	local "Railway Switch (Trigger)"		= "Railway Switch (Trigger)"
; 	local "Railway Switch (Final)"			= "Railway Switch (Final)"
; 	local "Trigger Settings"				= "Trigger Settings"
; 	local "Single Value Display"			= "Single Value Display"
; 
; 
;    elsif ([LANG] == Chinese)
; 	local "Processing Channel [ChanName]"	= "信号处理[ChanName]"
;  	local "Time Domain Average"				= "Time Domain Average"
; 	local "Single Values"					= "Single Values"
; 	local "Band sum"						= "Band sum"
; 	local "Spectral Average"				= "Spectral Average"
; 	local "Spectral Maximum"				= "Spectral Maximum"
; 	local "Logarithm"						= "Logarithm"
; 	local "Trigger Filter"					= "Trigger-Filter"
; 	local "Railway Switch (Trigger)"		= "Railway Switch (Trigger)"
; 	local "Railway Switch (Final)"			= "Railway Switch (Final)"
; 	local "Trigger Settings"				= "Trigger Settings"
; 	local "Single Value Display"			= "Single Value Display"
; 
; 
;    elsif ([LANG] ==	Portuguese)
; 	local "Processing Channel [ChanName]"	= "Canal de processamento [ChanName]"
; 	local "Time Domain Average [ChanName]"	= "Média do Domínio do Tempo [ChanName]"
; 	local "Single Values"					= "Valores Individuais"
; 	local "Band sum"						= "Soma da Banda"
; 	local "Spectral Average"				= "Média Espectral"
; 	local "Spectral Maximum [ChanName]"		= "Máxima Espectral [ChanName]"
; 	local "Logarithm"						= "Logaritmo"
; 	local "Trigger Filter"					= "Acionar Filtro"
; 	local "Railway Switch (Trigger)"		= "Trocar Trilho (Acionar)"
; 	local "Railway Switch (Final)"			= "Trocar Trilho (Final)"
; 	local "Trigger Settings"				= "Configs. de Acionamento"
; 	local "Single Value Display"			= "Exibição de valor individual"
; 
;    elsif ([LANG] == Chinese)
; 	local "Processing Channel [ChanName]"	= "信号处理[ChanName]"
; 
;   else
;    end
; #>

; <# if ([OrdMon] == FALSE) #>
; <# else #>
; <# local [OrdMon] = TRUE #> 
; <# end #>

; <# local [Switch] = FALSE #>
; <# if ([Sum2]==TRUE)
; 	local [Switch] = TRUE
;    end
; #>
; <# if ([SumAndSingle]==TRUE)
; 	local [Switch] = TRUE
;    end
; #>
; <# if ([skipFFT]!=TRUE) 
; 	local [TrigFilt] = TRUE
;    end
; #>
; <# if( [ModSpektrogramm]==TRUE ) 
; 	local [TrigFilt] = TRUE
;    end
; #>

; Debug
; <# if ([Switch] == TRUE) #>
;switch
; <# end #>
; <# if ([Sum2]==TRUE) #>
;Sum2
; <# end #>
; <# if ([SumAndSingle]==TRUE) #>
;SumAndSingle
; <# end #>
; <# if ([skipFFT]==TRUE) #>
;skipFFT
; <# end #>
; <# if ([ModSpektrogramm]==TRUE) #>
;ModSpektr
; <# end #>

; --------------------------------------------------------------------------
; Verarbeitungs-Kanal
; --------------------------------------------------------------------------
 
; --------------------------------------------------------------------------
; Zeitsignal-Bearbeitung

WorkerThreads.Modules: {+
	CThreadHead				ThreadHead.FixFs			"Processing Channel FixFs"		1	"FixFs Processing"
}

ThreadHead.FixFs.Modules: {
	CModule					WireBox.FixFs				"Input Connections"				43
; <# if( [NoDetox] == TRUE   ) #>
; <# else #>
	CDetoxModule			Detox.FixFs				"Reject Distorted Signals FixFs"	34	"FixFs Reject Distorted Signals"
; <# end #>
	CShiftingNoise			ShiftNoise.FixFs			"Shifting Noise"				37	"Shifting Noise Detection"
	CEzakeweModule			Mequant.FixFs.EZK			"Single Values"					37	"Single Values Calculation"
; <# if( [skipFFT] != TRUE     ) #>
	CMuxFftModul			tFft.FixFs					"Fft FixFs"				35
; <# if( [Sum] ) #>
; <# end #>
; <# if( [Sum2] ) #>
; <# end #>
; <# if( [Switch] ) #>
; <# end #>
; <# if( [Geyser] ) #>
; <# end #>
; <# if ([StoreTime] == TRUE) #>
; <# end #>
; <# if ([LogPostAver] == TRUE) #>
; <# else #>
	CLogarithmModule		Log.FixFs					"Logarithm"						35		Logarithm
; <# end #>
; <# if( [Diff] ) #>
; <# end #>
	CMuxMittelungsModul		fAverLog.FixFs				"Spectral Average"				35		"Spectral Average "
; <# if ([LogPostAver] == TRUE) #>
; <# end #>
; <# if( [OrdMon] ) #>
	COrdMonModule			OrdMon.FixFs				"Band sum"						37		"Band Sum"
; <# end #>
	CMuxMaximierungsModul	fMax.FixFs					"Spectral Maximum FixFs"	35		"FixFs Spectral Maximum"
; <# if( [SpecTransform] == TRUE ) #>
; <# end #>
; Ende [skipFFT]!=TRUE
; <# end #>
; <# if( [ModSpektrogramm] ) #>
; <# end #>
; <# if ([TrigFilt] == TRUE) #>
	CTriggerFilter			TriggerFilter.FixFs		"Trigger Filter"				35		"Trigger-Filter"
; <# end #>
	CRailroadSwitch			TriggerRailroadSwitch.FixFs	"Railway Switch (Trigger)"	43		"Trigger Railway Switch"
	CRailroadSwitch			FinalRailroadSwitch.FixFs	"Railway Switch (Final)"		43		"Final Result Railway Switch"
}

; <# if( [NoDetox] == TRUE ) #>
; <#	local [InputWire]			= SoundSignal.[ChanName]	#>
; <# else #>
Detox.FixFs.Modules: {
	CtInputWire				Input						<SoundSignal.FixFs>			8
	CtOutputWire			Output						<DetoxSignal.FixFs>			9
}
; <#	local [InputWire]			= DetoxSignal.[ChanName]	#>
; <# end #>

ShiftNoise.FixFs.Modules: {
	CtInputWire				Input						<DetoxSignal.FixFs>						8
	CtOutputWire			Output						<ShiftNoise.FixFs>				9
	CtOutputWire			Control						<ShiftNoiseCtrl.FixFs>			9
}

Mequant.FixFs.EZK.Modules: {
	CtInputWire				Input						<DetoxSignal.FixFs>						8
	CtOutputWire			FinalOutput					<EZK.FixFs-Final>				9
	CtOutputWire			TriggeredOutput				<EZK.FixFs-Triggered>			9
}

tFft.FixFs.Modules: {
	CtInputWire				Input						<DetoxSignal.FixFs>						8
; <# if( [Sum] ) #>
; <# else #>
	CtOutputWire			Output						<Fft.FixFs>					9
; <# end #>
}

; <# if( [Sum] ) #>
; <# if( [Switch] ) #>
; <# else #>
; <# end #>
; <# end #>

; <# if( [Sum2] ) #>
; <# end #>

; <# if( [Switch] ) #>
; <# if( [SumAndSingle] ) #>
; <# end #>
; <# if( [Sum2] ) #>
; <# end #>
; <# end #>

; <# if( [Geyser] ) #>
; <# end #>

; <# if ([StoreTime] == TRUE) #>
;	CtOutputWire			RunningOutput				<RunningStoreSignal.[ChanName]>		9
; <# end #>

; <# local [LogInWire] = <Fft.[ChanName]> #>
; <# if( [Geyser] ) #>
; <# local [LogInWire] = <**Fft.[ChanName]> #>
; <# end #>

; <# if ( [LogPostAver] == TRUE) #>
; <# else #>
Log.FixFs.Modules: {
	CtInputWire				Input						<Fft.FixFs>					8
	CtOutputWire			Output						<Log.FixFs>					9
}
; <# end #>

; <# if( [Diff] ) #>
; <# if ( [LogPostAver] == TRUE) #>
; <# else #>
; <# end #>
; <# end #>

; <# local [AverInWire] = <Log.[ChanName]> #>
; <# if ([LogPostAver] == TRUE) #>
; <# local [AverInWire] = <Fft.[ChanName]> #>
; <# end #>
; <# if( [Diff] ) #>
; <# local [AverInWire] = <DiffSpec.[ChanName]> #>
; <# end #>
; <# if( [Modulation] == TRUE   ) #>
; <# local [AverInWire] = <Fft.[ChanName]> #>
; <# end #>

fAverLog.FixFs.Modules: {
	CtInputWire				Input						<Log.FixFs>				8
; <# if ( [LogPostAver] == TRUE) #>
; <# else #>
	CtOutputWire			Output						<AverSpec.FixFs>				9
; <# end #>
}

; <# if ( [LogPostAver] == TRUE) #>
; <# end #>

; <# if( [OrdMon] ) #>
OrdMon.FixFs.Modules: {
	CtInputWire				Input						<AverSpec.FixFs>				8
	CtOutputWire			Output						<EZK.FixFs-Triggered>			9
}
; <# end #>

fMax.FixFs.Modules: {
	CtInputWire				Input						<AverSpec.FixFs>				8
	CtOutputWire			Output						<MaxSpec.FixFs>				9
	CtOutputWire			RunningOutput				<RunningMaxSpec.FixFs>			9
}

; <# if( [SpecTransform] ) #>
; <# end #>

; <# if( [ModSpektrogramm] ) #>
; Hinweis: ab hier laufen 2D-Datenpakete (Spektrogramme) durch die Verarbeitungskette
; <# end #>

; <# if ([TrigFilt] == TRUE) #>
TriggerFilter.FixFs.Modules: {
; <# if ( [skipFFT] != TRUE ) #>
	CtInputWire				Input						<AverSpec.FixFs>				8
; <# end #>
; <# if( [ModSpektrogramm] ) #>
; <# end #>
	CtOutputWire			Output						<TriggerFilter.FixFs>			9
}
; <# end #>
TriggerRailroadSwitch.FixFs.Modules: {
; <# if ([TrigFilt] == TRUE) #>
	CtInputWire				InputTriggerFilter			<TriggerFilter.FixFs>			8
; <# end #>
	CtInputWire				InputEZKTriggered			<EZK.FixFs-Triggered>			8
; <# if( [ModSpektrogramm] ) #>
; <# end #>
	CtOutputWire			Output						<RailroadTriggered>					9
}

FinalRailroadSwitch.FixFs.Modules: {
	CtInputWire				InputShiftNoise				<ShiftNoise.FixFs>				8
	CtInputWire				InputEZKFinal				<EZK.FixFs-Final>				8
; <# if( [ModSpektrogramm] ) #>
; <# end #>
; <# if ( [skipFFT] != TRUE ) #>
	CtInputWire				InputMaxSpec				<MaxSpec.FixFs>				8
; <# end #>
; <# if ([StoreTime] == TRUE) #>
; <# end #>
; <# if( [SpecTransform] == TRUE ) #>
; <# end #>
; <# if( [ModSpektrogramm] ) #>
; <# end #>
	CtOutputWire			Output						<RailroadFinal>						9
}

; --------------------------------------------------------------------------
; Test Stand interface
; --------------------------------------------------------------------------
; <# include Conf_SerialSps.sea([UDP]=TRUE) #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_SerialSps.sea
; Conf_SerialSps.sea
;
; Konfigurationsfile für die Universal-Applikation
; Serieller Decoder + Interface
;
; $Date: 2020-08-27 11:49:27 +0200 (Do, 27. Aug 2020) $
; $Revision: 26435 $

; <# option  [Cif]				"TRUE: Cif-Interface statt seriell" #>
; -------> with   [Cif]: option not set   ("TRUE: Cif-Interface statt seriell")
; <# option  [Cifx]				"TRUE: Cifx-Interface statt seriell" #>
; -------> with   [Cifx]: option not set   ("TRUE: Cifx-Interface statt seriell")
; <# option  [UDP]				"TRUE: UDP-Interface statt seriell" #>
; -------> with   [UDP]=TRUE   ("TRUE: UDP-Interface statt seriell")
; <# option  [SerialMfc]			"TRUE: seriell: MFC Modul statt MSCOMM Modul verwenden" #>
; -------> with   [SerialMfc]: option not set   ("TRUE: seriell: MFC Modul statt MSCOMM Modul verwenden")
; <# option  [ExtErrors]			"TRUE: SetExtError-Kommando-Plugin einbauen" #>
; -------> with   [ExtErrors]: option not set   ("TRUE: SetExtError-Kommando-Plugin einbauen")
; <# option  [ShiftForce]			"TRUE: Schaltkraft-Kommando-Plugins einbauen" #>
; -------> with   [ShiftForce]: option not set   ("TRUE: Schaltkraft-Kommando-Plugins einbauen")
; <# option  [RatioTest]			"TRUE: Übersetzungspr.-Kommando-Plugins einbauen" #>
; -------> with   [RatioTest]: option not set   ("TRUE: Übersetzungspr.-Kommando-Plugins einbauen")
; <# option  [GetValues]			"TRUE: GetValues-Plugin (= Unipas-Plugin) einbauen" #>
; -------> with   [GetValues]: option not set   ("TRUE: GetValues-Plugin (= Unipas-Plugin) einbauen")
; <# option  [TriggerParams]		"TRUE: Trigger Parameter-Plugin („SetTriggerParams”) einbauen" #>
; -------> with   [TriggerParams]: option not set   ("TRUE: Trigger Parameter-Plugin („SetTriggerParams”) einbauen")
; <# option  [SensorConfig]		"TRUE: Sensor Configuration-Plugin („SetSensorConfig”) einbauen" #>
; -------> with   [SensorConfig]: option not set   ("TRUE: Sensor Configuration-Plugin („SetSensorConfig”) einbauen")
; <# option  [Mesam]				"TRUE: Mesam-Protokoll-Kommando-Plugins einbauen" #>
; -------> with   [Mesam]: option not set   ("TRUE: Mesam-Protokoll-Kommando-Plugins einbauen")
; <# option  [AquraMot]			"TRUE: AquraMot Spezial-Plugins einbauen" #>
; -------> with   [AquraMot]: option not set   ("TRUE: AquraMot Spezial-Plugins einbauen")
; <# option  [Recode]				"TRUE: Umcodierungs-Plugins einbauen" #>
; -------> with   [Recode]: option not set   ("TRUE: Umcodierungs-Plugins einbauen")
; <# option  [DummyCommands]		"TRUE: DummyCommands-Plugin einbauen" #>
; -------> with   [DummyCommands]: option not set   ("TRUE: DummyCommands-Plugin einbauen")
; <# option  [Rotas]				"TRUE: Rotas-Varianten einbauen" #>
; -------> with   [Rotas]: option not set   ("TRUE: Rotas-Varianten einbauen")

; <# 
;  if ([LANG] == German) 
; 	local "Command Decoder"									= "Kommando-Decoder"
; 	local "Serial Interface"								= "Serielles Interface"
; 	local "UDP Interface"									= "UDP Interface"
; 	local "Ratio Test Decoder Extension"					= "Decoder-Erweiterung für Übersetzungsprüfung"
; 	local "Ratio Test Command Extension"					= "Kommando-Erweiterung für Übersetzungsprüfung"
; 	local "Shift Force Decoder Extension"					= "Decoder-Erweiterung für Schaltkraft"
; 	local "»SetExtError« Command Extension"					= "Kommando-Erweiterung für „SetExtError”"
; 	local "Get/Set Values Command Extension"				= "Kommando-Erweiterung für Werte-Abfrage und -Setzen"
; 	local "Mesam Decoder Extension"							= "Decoder-Erweiterung für Mesam-Protokoll"
; 	local "Change Type Extension"							= "„Umcodieren”-Decoder-Erweiterung"
; 	local "Change Type Command Extension"					= "Kommando-Erweiterung für „Umcodieren”"
; 	local "Modify Command Input"							= "Eingabe-Kommandos modifizieren"
; 	
;    elsif ([LANG] == Italian) 
; 	local "Command Decoder"									= "Decoder di commando"
; 	local "Serial Interface"								= "Interfaccia seriale"
; 	local "UDP Interface"									= "Interfaccia UDP"
; 	local "Ratio Test Decoder Extension"					= "Estensione di Decoder par prova di Ratio"
; 	local "Ratio Test Command Extension"					= "Estensione di Decoder par prova di Diff."
; 	local "Shift Force Decoder Extension"					= "Estensione di Decoder par prova di forza di cambio"
; 	local "Shift Force Command Extension"					= "Estensione di comando par prova di forza di cambio"
; 	local "Mesam Decoder Extension"							= "Extensione di Decoder par Mesam"
; 	
;    elsif ([LANG] == Japanese) 
; 	local "Serial Interface"								= "シリアル通信"
; 	local "UDP Interface"									= "UDP通信"	
;    elsif ([LANG] == Chinese) 
; 	local "Serial Interface"								= "串行通信"
; 	local "UDP Interface"									= "UDP通信"	
;    elsif ([LANG] == Korean) 
; 	local "Serial Interface"								= "시리얼통신"
;    elsif ([LANG] == Russian) 
; 	local "Serial Interface"								= "Последовательное соединение"
; 	local "UDP Interface"									= "UDP-Соединение "
;   elseif ([LANG] == Hungarian) 
; 	local "Serial Interface"								= "Soros kommunikáció"
; 	local "UDP Interface"									= "UDP kommunikáció"
;  else
;  end #>


CommandCentre.Modules: {+
	CDialogModule	CTasDecoder=TasDecoder		"Command Decoder"		45		Command-Decoder

; <# if ([RatioTest]) #>
; <# end #>
; <# if ([ShiftForce]) #>
; <# end #>
; <# if ([Recode]) #>
; <# end #>
; <# if ([AquraMot]) #>
; <# end #>

; <# if ([Cif]) #>
; <# elsif ([Cifx]) #>
; <# elsif ([UDP]) #>
	CUDPModule		UDPInterface					"UDP Interface"			22		"UDP Interface Module"
; <# elsif ([SerialMfc]) #>
; <# else #>
; <# end #>
}

TasDecoder.Modules: {+
	CModuleInputWire	CommandInput				<Sps-Commands>			48
	CModuleOutputWire	CommandOutput				<Sps-Reply>				49
; <# if ([DummyCommands]) #>
; <# end #>
; <# if ([ExtErrors]) #>
; <# end #>
; <# if ([RatioTest]) #>
; <# end #>
; <# if ([TriggerParams]) #>
; <# end #>
; <# if ([SensorConfig]) #>
; <# end #>
; <# if ([ShiftForce]) #>
; <# end #>
; <# if ([GetValues]) #>
; <# end #>
; <# if ([Mesam]) #>
; <# else #>
; <# if ([AquraMot]) #>
; <# end #>
; <# end #>
; <# if ([Recode]) #>
; <# end #>
; <# if ([Rotas]) #>
; <# end #>
}

SerialDecoder.Modules: {+
	CModuleInputWire	CommandInput				<Sps-Commands>			48
	CModuleOutputWire	CommandOutput				<Sps-Reply>				49
}


; <# if ([UDP]) #>
UDPInterface.Modules: {
		CModuleInputWire	Input					<Sps-Reply>				48
		CModuleOutputWire	Output					<Sps-Commands>			49
}
; <# else #>
; <# end #>

; <# if ([Cif]) #>
; <# end #>
; <# if ([Cifx]) #>
; <# end #>

; <# include Conf_ManualSps.sea ([AutoSerial]=TRUE,[AutoModeController]=TRUE) #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_ManualSps.sea
; Conf_ManualSps.sea
;
; Konfigurationsfile für die Universal-Applikation
; Kommandozentralen-Ergänzungen
;
; $Date: 2018-05-18 15:35:40 +0200 (Fr, 18. Mai 2018) $
; $Revision: 24026 $
; <# option  [AutoModeController]	"TRUE: Auto-Mode-Controller einbauen" #>
; -------> with   [AutoModeController]=TRUE   ("TRUE: Auto-Mode-Controller einbauen")
; <# option  [AutoSerial]			"TRUE: Auto-Seriennummern-Plugin einbauen" #>
; -------> with   [AutoSerial]=TRUE   ("TRUE: Auto-Seriennummern-Plugin einbauen")
; <# option  [TestKindSelector]	"TRUE: Messart-Auswahl-Plugin einbauen" #>
; -------> with   [TestKindSelector]: option not set   ("TRUE: Messart-Auswahl-Plugin einbauen")
; <# option  [BarcodeScanner]		"TRUE: Barcode-Scanner-Decoder einbauen" #>
; -------> with   [BarcodeScanner]: option not set   ("TRUE: Barcode-Scanner-Decoder einbauen")
; <# option  [ResultIndicator]	"TRUE: Result-Indicator-Licht einbauen" #>
; -------> with   [ResultIndicator]: option not set   ("TRUE: Result-Indicator-Licht einbauen")

; <# 
;    if ([LANG] == German) 
; 	local "Automatic test sequence"							= "Automatischer Ablauf"
; 	local "Automatic serial number"							= "Automatische Seriennummer"
; 	local "Test kind selector"								= "Messart-Auswahl"
; 	local "Barcode Scanner Control"							= "Barcode-Scanner Steuerung"
;    elsif ([LANG] == Korean) 
; 	local "Automatic test sequence"							= "자동 테스트 시퀀스"
;  else
;  end #>


CommandCentre.Modules: {+
; <# if ([AutoSerial]) #>
	CCommandCenterPluginAutoSerial		AutoSerialGenerator		"Automatic serial number"	61	"Automatic Serial Generator"
; <# end #>
; <# if ([AutoModeController]) #>
	CAutoModeController					AutoModeController		"Automatic test sequence"	45	"Automatic Test Sequence"
; <# end #>
; <# if ([TestKindSelector]) #>
; <# end #>
; <# if ([BarcodeScanner]) #>
; <# end #>
}

; <# if ([ResultIndicator]) #>
; <# end #>

; <# if ([BarcodeScanner]) #>
; <# end #>

; Scopes
;--------------------------------------------------------------

; <# include Conf_Scope.sea ([Nr]=1, [UserName]="Time Signals") #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_Scope.sea
; Conf_Scope.sea
;
; Konfigurationsfile für die Universal-Applikation
; Standard-Scope (Zeitsignale)
;
; $Date: 2015-04-08 10:16:30 +0200 (Mi, 08. Apr 2015) $
; $Revision: 22981 $
; <# param  [Nr]				"Enumerator" #>
; -------> with   [Nr]=1   ("Enumerator")
; <# param  [UserName]		"Benutzername des Scopes" #>
; -------> with   [UserName]="Time Signals"   ("Benutzername des Scopes")
; <# option [RawSignal]		"Systembaum-Icon 15 statt standard Kurven-Scope" #>
; -------> with   [RawSignal]: option not set   ("Systembaum-Icon 15 statt standard Kurven-Scope")
; <# option [Spectrogram]		"Systembaum-Icon für Spektrogramm statt Kurven-Scope" #>
; -------> with   [Spectrogram]: option not set   ("Systembaum-Icon für Spektrogramm statt Kurven-Scope")

ScopeContainer.Modules: {+
; <# if ([RawSignal] == TRUE) #>
; <# elsif ([Spectrogram] == TRUE) #>
; <# else #>
	CScopeModule		Scope1			"Time Signals"				11		"Scope 1"
; <# end #>
}
; <# include Conf_LimitScope.sea ([Nr]=2, [UserName]="Spectra") #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_LimitScope.sea
; Conf_LimitScope.sea
;
; Konfigurationsfile für die Universal-Applikation
; Scope für Kurven mit Grenzen (keine Tracks)
;
; $Date: 2011-05-10 14:17:32 +0200 (Di, 10. Mai 2011) $
; $Revision: 20850 $
; <# param  [Nr]			"Enumerator" #>
; -------> with   [Nr]=2   ("Enumerator")
; <# param  [UserName]	"Benutzername der Drehzahlquelle" #>
; -------> with   [UserName]="Spectra"   ("Benutzername der Drehzahlquelle")

ScopeContainer.Modules: {+
	CLimitScopeModule	SpecScope2		"Spectra"			11		"Spectra Scope 2"
}
;<# include Conf_TrackScope.sea ([Nr]=3, [UserName] = "Spectral Tracks") #>
; <# include Conf_TrackScope.sea ([Nr]=4, [UserName]="Spectrogram", [Spectrogram]=TRUE) #>
; -------> SeaInclude  including C:\Discom\Measurement\MultiRot\Configuration\Conf_TrackScope.sea
; Conf_TrackScope.sea
;
; Konfigurationsfile für die Universal-Applikation
; Track-Scope
;
; $Date: 2011-05-10 14:17:32 +0200 (Di, 10. Mai 2011) $
; $Revision: 20850 $
; <# param  [Nr]				"Enumerator" #>
; -------> with   [Nr]=4   ("Enumerator")
; <# param  [UserName]		"Benutzername des Scopes" #>
; -------> with   [UserName]="Spectrogram"   ("Benutzername des Scopes")
; <# option [Spectrogram]		"Systembaum-Icon für Spektrogramm statt Kurven-Scope" #>
; -------> with   [Spectrogram]=TRUE   ("Systembaum-Icon für Spektrogramm statt Kurven-Scope")

ScopeContainer.Modules: {+
; <# if ([Spectrogram] == TRUE) #>
	CTrackScopeModule	TrackScope4			"Spectrogram"					88		"Track Scope 4"
; <# else #>
; <# end #>
}

TrackScope4.Modules: {
	CModuleInputWire	Input					<TrackQuinter>				8
}

