function varargout = BiaxialerVersuch(varargin)
%      Grafisches Kontrollprogramm für den biaxialen Versuch
%      -----------------------------------------------------
%
%      Das Aufrufen des Befehls "BiaxialerVersuch" im MATLAB Command-Window
%      startet die grafische Benutzeroberfläche, die eine Ansteuerung des
%      Versuchsstands ermöglicht.
%
%      Grundsätzlich sollte zunächst darauf geachtet werden, dass alle
%      Kabel korrekt angeschlossen sind. Die Wahl der Kanal anspricht der
%      Benennung am Anschlussblock (AO=Ausgangskanäle, AI=Eingangskanäle).
%
%      Die grafische Oberfläche ermöglicht nun das Ansteuern der einzelnen 
%      Teilversuche. Bei den Eingaben sollte grundsätzlich Folgendes 
%      beachtet werden:
%      1.Die Druckniveaus können nur bis zu einer Genauigkeit von +- 10mbar
%        erreicht werden. 
%      2.Im Intervallmodus sollten Schrittweiten >= 20mbar gewählt werden
%      3.Ein Drucksnivea von unter 50mbar kann durch den Regler nicht
%        stabil erreicht werden. Im Intervallmodus B ist dies daher der
%        Mindestwert, bis auf den der Druck reduziert wird
%      4.Sollte während der Reglung der "Versuch beenden" Button betätigt
%        werden, kann es zu Abstürzen des Programms kommen. Der Druck wird
%        dennoch auf 0 reduziert. In diesem Fall empfiehlt es sich, MATLAB
%        und die GUI erneut zu starten und von vorne zu beginnen.
%
% Für weitere Informationen sollte nach folgenden Hilfethemen gesucht werden: 
% GUIDE, GUIDATA, GUIHANDLES
%
% Zuletzt modifiziert: 23.10.2011 23:11


% Automatisch generiert: Beginn des Initialisierungscodes - NICHT VERÄNDERN
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @BiaxialerVersuch_OpeningFcn, ...
                   'gui_OutputFcn',  @BiaxialerVersuch_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end
% Automatisch generiert: Ende des Initialisierungscodes  - NICHT VERÄNDERN

% Wird ausgeführt, kurz bevor die GUI angezeigt wird 
function BiaxialerVersuch_OpeningFcn(hObject, eventdata, handles, varargin) %#ok<INUSL>
% Automatisch generiert: Choose default command line output for BiaxialerVersuch
handles.output = hObject;

%Eingefügt für die Intervallmodus Buttongroup:
set(handles.Intervallmodus_ButtonGroup,'SelectionChangeFcn',@Intervallmodus_ButtonGroup_SelectionChangeFcn);

% Grafik zu Intervallmodus A  einfügen 
axes(handles.Grafik_Intervall1);        %#ok<MAXES> % Auswahl des entsprechenden Axes-Objekts 
g1=imread('IntervallA.jpg','jpg');      % Einlesen der Grafik 
image (g1); axis image;                 % Grafik ausgeben, Grafik entzerren 
axis off                                % Koordinatenachsen ausblenden

% Sichtbarkeit der einzelnen Elemente festlegen:
set(handles.Endwert_staticText,'Visible','Off');
set(handles.EndwertEinheit_staticText,'Visible','Off');
set(handles.Endwert_editText,'Visible','Off');
set(handles.Wartezeit2_staticText,'Visible','Off');
set(handles.Wartezeit2Einheit_staticText,'Visible','Off');
set(handles.Wartezeit2_editText,'Visible','Off');
set(handles.IBstart_pushbutton,'Visible','Off');
set(handles.ICstart_pushbutton,'Visible','Off');

%[Handles] Struktur aktualisieren
guidata(hObject, handles);

% Automatisch generiert: Outputs from this function are returned to the command line.
function varargout = BiaxialerVersuch_OutputFcn(hObject, eventdata, handles)  %#ok<INUSL>
% Automatisch generiert: Get default command line output from handles structure
varargout{1} = handles.output;

%[Handles] Struktur aktualisieren      
guidata(hObject, handles);

% Ausgeführt bei Betätigen des AusgabeStarten-Pushbuttons
function AusgabeStarten_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Gewählten Ausgangskanal auslesen
switch get(handles.popupmenuAusgang,'Value')
    case 1
        ausgangskanal = 0;
    case 2
        ausgangskanal = 1;
    otherwise
end
    
%Textfeld gewaehlter Eingangskanal aktualisiert    
set(handles.GewaehlterAusgang_staticText,'String',ausgangskanal); 
    
%Ausgangskanal für andere Komponenten verfügbar machen
handles.ausgangskanal=ausgangskanal;

%Code zum Ansteuern des analogen Ausgangs
%Bereitstellen "eines Analog Output-Objekts"
ao=analogoutput('nidaq','PXI1Slot2');
%Wahl & Öffnen eines Output-Kanals
addchannel(ao,ausgangskanal);
%Einstellen der Eigenschaften des Outputs
set(ao,'sampleRate',1000);
set(ao,'TriggerType','Immediate');
set(ao,'RepeatOutput',inf);

%"Analog Output-Objekt" für andere Komponenten verfügbar machen
handles.ao=ao;
    
%[Handles] Struktur aktualisieren      
guidata(hObject, handles);


% Ausgeführt bei Betätigen des EingangStarten-Pushbuttons
function EingangStarten_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Gewählten Eingangskanal auslesen
switch get(handles.popupmenuEingang,'Value')
    case 1
        eingangskanal = 0;
    case 2
        eingangskanal = 1;
    case 3
        eingangskanal = 2;
    case 4
        eingangskanal = 3;
    case 5
        eingangskanal = 4;
    case 6
        eingangskanal = 5;
    case 7
        eingangskanal = 6;
    case 8
        eingangskanal = 7;
    case 9
        eingangskanal = 8;
    case 10
        eingangskanal = 9;
    case 11
        eingangskanal = 10;
    case 12
        eingangskanal = 11;
    case 13
        eingangskanal = 12;
    case 14
        eingangskanal = 13;
    case 15
        eingangskanal = 14;
    otherwise
end
    
%Textfeld gewaehlter Eingangskanal aktualisiert    
set(handles.GewaehlterEingang_staticText,'String',eingangskanal); 

%Ausgangskanal für andere Komponenten verfügbar machen
handles.eingangskanal=eingangskanal;
    
%Ausschalten des Hinweises
set(handles.Hinweis_staticText,'Visible','Off');

%Code zum Ansteuern des analogen Ausgangs
%Bereitstellen eines "Analog Input-Objekts"
ai=analoginput('nidaq','PXI1Slot2');
%Wahl & Öffnen eines Input-Kanals
addchannel(ai,eingangskanal);
%Einstellen der Eigenschaften des Inputs
set(ai,'sampleRate',1000);
%"Analog Input-Objekts" für andere Komponenten verfügbar machen
handles.ai=ai;    

%[Handles] Struktur aktualisieren    
guidata(hObject, handles);



function slider_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%String aus dem [slider_editText]-Fenster auslesen
sliderValue = get(handles.slider_editText,'String');
 
%Falls möglich, String zu Zahl konvertieren, sonst leer zurückgeben
sliderValue = str2num(sliderValue); %#ok<ST2NM>
 
%Falls die Eingabe keine Zahl ist oder die Eingabe <0 oder größer 10000, wird
%der Slider auf 0 gesetzt
if (isempty(sliderValue) || sliderValue < 0 || sliderValue > 1000)
    set(handles.slider1,'Value',0);
    set(handles.slider_editText,'String','0');
else
    set(handles.slider1,'Value',sliderValue);
end
    
%[Handles] Struktur aktualisieren
guidata(hObject, handles);

% Automatisch generiert: Executes during object creation, after setting all properties.
function slider_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


% Wird bei Bewegung des Sliders ausgeführt:
function slider1_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Slider-Wert aus dem Slider auslesen
sliderValue = get(handles.slider1,'Value');
 
%Slider-Wert in das [slider_editText]-Fenster einfügen
set(handles.slider_editText,'String', num2str(sliderValue));
 
%[Handles] Struktur aktualisieren
guidata(hObject, handles);



% Automatisch generiert: Executes during object creation, after setting all properties.
function slider1_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

% Hint: slider controls usually have a light gray background.
if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);

%Starten der Initialisierung des Ultraschallsensors
function sonicsensor = start_ultrasound()
    % Initialize Serial Port Object
    serialport  = port;
    sonicsensor = serial(serialport);
    fopen(sonicsensor);
    % Set Instrument in Remote Mode
    fprintf(sonicsensor,'SYSTEM:REMOTE');
    fread(sonicsensor, 512)
    % Start transfer
    fprintf(sonicsensor,'s');


%Ausgeführt bei Betätigen des SpannungAusgeben-Pushbuttons
function SpannungAusgeben_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Wert aus dem Slider auslesen
sliderValue = get(handles.slider1,'Value');

%Sliderwert in Spannung ausgeben
V = (sliderValue/100);

    if V > 0  && V < 10
        %Ausgabe einer Spannung wird vorsichtshalber beendet
        stop(handles.ao);
        %Spannung wird angepasst, um den Druck "von unten" zu erreichen
        Vangepasst = V-0.4;
        %Spannung wird ausgegeben
        putdata(handles.ao,Vangepasst);
        start(handles.ao);
        %Aktualisieren des Statusfeldes
        set(handles.StatusAntwort_staticText,'String', 'Druck wird aufgebaut')
        %Abwarten, welcher Druck sich einstellt
        pause(5)
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        %Spannung vom Sensor in Druck umrechnen
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Statusfeldes
        Spannungtext=(['Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar']);
        set(handles.StatusAntwort_staticText,'String',Spannungtext);
        %Regelschleife um den Druck +- 0.1 bar zu erreichen
        while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %klein ist
            while  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Ausgabe einer angepassten Spannung
                stop(handles.ao); 
                Vangepasst = Vangepasst+0.02;
                putdata(handles.ao,Vangepasst); 
                start(handles.ao);
                %Pause um die Reaktion des Systems abzuwarten
                pause(4);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
                set(handles.StatusAntwort_staticText,'String',regeltext);
            end
            %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
            %groß ist
            while Sensordruck > V * 0.1 + 0.01 && V~=0
                %Ausgabe einer angepassten Spannung
                stop(handles.ao); 
                Vangepasst = Vangepasst-0.02;
                putdata(handles.ao,Vangepasst); 
                start(handles.ao);
                %Pause um die Reaktion des Systems abzuwarten
                pause(4);
                %Einlesen des Drucks am Sensor
                start(handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
                set(handles.StatusAntwort_staticText,'String',regeltext);  
            end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
                set(handles.StatusAntwort_staticText,'String',regeltext);
        end    
        pause(5);
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Textes im Statusfeld
        endetext=(['Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar']);
        set(handles.StatusAntwort_staticText,'String',endetext);
    
    %Verhalten, falls der gewünschte Druck=0 ist    
    elseif V == 0  
        stop(handles.ao);
        putdata(handles.ao,V);
        start(handles.ao);
        nulltext=(['Druck am Sensor: ',num2str(V), ' bar']);
        set(handles.StatusAntwort_staticText,'String',nulltext);
    end
    
%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert: Executes on selection change in popupmenuAusgang.
function popupmenuAusgang_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject,handles)


%Automatisch generiert: Executes during object creation, after setting all properties.
function popupmenuAusgang_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject,handles)


%Automatisch generiert: Executes on selection change in popupmenuEingang.
function popupmenuEingang_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject,handles)



%Automatisch generiert: Executes during object creation, after setting all properties.
function popupmenuEingang_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Ausgeführt bei Betätigen des VersuchBeenden-Pushbuttons
function VersuchBeenden_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Werte des Sliders und [slider_editText]-Fensters auf 0 setzen
set(handles.slider1,'Value',0);
set(handles.slider_editText,'String','0');
%Angezeigte Werte der Kanäle zurücksetzen 
set(handles.GewaehlterAusgang_staticText,'String','-'); 
set(handles.GewaehlterEingang_staticText,'String','-'); 
%Spannung von 0 Volt ausgeben
stop(handles.ao);
V=0;
putdata(handles.ao,V);
start(handles.ao);
stop(handles.ao);
stop(handles.ai);
%Textfelder aktualisieren
set(handles.StatusAntwort_staticText,'String','-');
set(handles.StatusAntwort2_staticText,'String','-');
set(handles.Endwert_editText,'String','-');
set(handles.Startwert_editText,'String','-');
set(handles.Schrittweite_editText,'String','-');
set(handles.Wartezeit_editText,'String','-');
set(handles.Wartezeit2_editText,'String','-');
%Einschalten des Kanal-Hinweises
set(handles.Hinweis_staticText,'Visible','On');
%Kanäle löschen, Variablen löschen    
clear handles.ai;
clear handles.eingangskanal;
clear handles.ao;
clear handles.ausgangskanal;
daqreset;
    
%[Handles] Struktur aktualisieren
guidata(hObject, handles);


function Intervallmodus_ButtonGroup_SelectionChangeFcn(hObject, eventdata)

%[Handles] Struktur auslesen
handles = guidata(hObject);

switch get(eventdata.NewValue,'Tag') %"Tag" der gewählten Objekte einlesen
    case 'IntervallA_radiobutton'
        % Grafik zu Intervallmodus A  einfügen 
        axes(handles.Grafik_Intervall1);        %#ok<MAXES> % Auswahl des entsprechenden Axes-Objekts 
        g1=imread('IntervallA.jpg','jpg');      % Einlesen der Grafik 
        image (g1); axis image;                 % Grafik ausgeben, Grafik entzerren 
        axis off
        
        %Textfelder aktualisieren
        set(handles.Endwert_staticText,'Visible','Off');
        set(handles.EndwertEinheit_staticText,'Visible','Off');
        set(handles.Endwert_editText,'Visible','Off');
        set(handles.Wartezeit2_staticText,'Visible','Off');
        set(handles.Wartezeit2Einheit_staticText,'Visible','Off');
        set(handles.Wartezeit2_editText,'Visible','Off');
        set(handles.Belastungsart_staticText,'String','Belasten bis zum Versagen');
        set(handles.IAstart_pushbutton,'Visible','On');
        set(handles.IBstart_pushbutton,'Visible','Off');
        set(handles.ICstart_pushbutton,'Visible','Off');
        set(handles.StatusAntwort_staticText,'String','-');
        set(handles.StatusAntwort2_staticText,'String','-');
        set(handles.Endwert_editText,'String','-');
        set(handles.Startwert_editText,'String','-');
        set(handles.Schrittweite_editText,'String','-');
        set(handles.Wartezeit_editText,'String','-');
        set(handles.Wartezeit2_editText,'String','-');
        
    case 'IntervallB_radiobutton'
        % Grafik zu Intervallmodus A  einfügen 
        axes(handles.Grafik_Intervall1);        %#ok<MAXES> % Auswahl des entsprechenden Axes-Objekts 
        g2=imread('IntervallB.jpg','jpg');      % Einlesen der Grafik 
        image (g2); axis image;                 % Grafik ausgeben, Grafik entzerren 
        axis off      
        
        %Textfelder aktualisieren
        set(handles.Endwert_staticText,'Visible','On');
        set(handles.EndwertEinheit_staticText,'Visible','On');
        set(handles.Endwert_editText,'Visible','On');
        set(handles.Wartezeit2_staticText,'Visible','Off');
        set(handles.Wartezeit2Einheit_staticText,'Visible','Off');
        set(handles.Wartezeit2_editText,'Visible','Off');
        set(handles.Belastungsart_staticText,'String','Be- und Endlasten bis zu Maximalwert');
        set(handles.IAstart_pushbutton,'Visible','Off');
        set(handles.IBstart_pushbutton,'Visible','On');
        set(handles.ICstart_pushbutton,'Visible','Off');
        set(handles.StatusAntwort_staticText,'String','-');
        set(handles.StatusAntwort2_staticText,'String','-');
        set(handles.Endwert_editText,'String','-');
        set(handles.Startwert_editText,'String','-');
        set(handles.Schrittweite_editText,'String','-');
        set(handles.Wartezeit_editText,'String','-');
        set(handles.Wartezeit2_editText,'String','-');
        
    case 'IntervallC_radiobutton'
        % Grafik zu Intervallmodus A  einfügen 
        axes(handles.Grafik_Intervall1);        %#ok<MAXES> % Auswahl des entsprechenden Axes-Objekts 
        g3=imread('IntervallC.jpg','jpg');      % Einlesen der Grafik 
        image (g3); axis image;                 % Grafik ausgeben, Grafik entzerren 
        axis off         
        
        %Textfelder aktualisieren
        set(handles.Endwert_staticText,'Visible','On');
        set(handles.EndwertEinheit_staticText,'Visible','On');
        set(handles.Endwert_editText,'Visible','On');
        set(handles.Wartezeit2_staticText,'Visible','On');
        set(handles.Wartezeit2Einheit_staticText,'Visible','On');
        set(handles.Wartezeit2_editText,'Visible','On');
        set(handles.Belastungsart_staticText,'String','Belasten bis zu Maximalwert und Halten der Belastung');
        set(handles.IAstart_pushbutton,'Visible','Off');
        set(handles.IBstart_pushbutton,'Visible','Off');
        set(handles.ICstart_pushbutton,'Visible','On');
        set(handles.StatusAntwort_staticText,'String','-');
        set(handles.StatusAntwort2_staticText,'String','-');
        set(handles.Endwert_editText,'String','-');
        set(handles.Startwert_editText,'String','-');
        set(handles.Schrittweite_editText,'String','-');
        set(handles.Wartezeit_editText,'String','-');
        set(handles.Wartezeit2_editText,'String','-');
        
    otherwise
        %Hier würde der Code für andere Fälle stehen
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);

 


%Automatisch generiert:
function Startwert_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert: Executes during object creation, after setting all properties.
function Startwert_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert:
function Schrittweite_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


% %Automatisch generiert: Executes during object creation, after setting all properties.
function Schrittweite_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert:
function Wartezeit_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


% %Automatisch generiert: Executes during object creation, after setting all properties.
function Wartezeit_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert:
function Endwert_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert: Executes during object creation, after setting all properties.
function Endwert_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Automatisch generiert:
function Wartezeit2_editText_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%[Handles] Struktur aktualisieren
guidata(hObject, handles);

%Automatisch generiert: Executes during object creation, after setting all properties.
function Wartezeit2_editText_CreateFcn(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Ausgeführt bei Betätigen des SensorAuslesen-Pushbuttons
function SensorAuslesen_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Sensordruck wird eingelsen und im Statusfeld angezeigt
start (handles.ai);
s2 = getdata (handles.ai);
Sensoreingang2 = mean(s2);
stop (handles.ai);
Sensordruck2 = Sensoreingang2*0.049;
Spannungtext2=(['Druck am Sensor: ',num2str(Sensordruck2) , ' bar']);
set(handles.SensorAuslesen_staticText,'String',Spannungtext2);

%[Handles] Struktur aktualisieren
guidata(hObject, handles);


%Ausgeführt bei Betätigen des WerteZuruecksetzen-Pushbuttons
function WerteZuruecksetzen_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Statusfelder aktualisieren
set(handles.StatusAntwort_staticText,'String','-');
set(handles.StatusAntwort2_staticText,'String','-');
set(handles.Endwert_editText,'String','-');
set(handles.Startwert_editText,'String','-');
set(handles.Schrittweite_editText,'String','-');
set(handles.Wartezeit_editText,'String','-');
set(handles.Wartezeit2_editText,'String','-');
set(handles.SensorAuslesen_staticText,'String','-');
        
%[Handles] Struktur aktualisieren
guidata(hObject, handles);

% Wird ausgeführt, sobald der "Intervallmodus A starten"-Button gedrückt wird 
function IAstart_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>
 
%Bereitstellen der Daten aus den Textfeldern und Umrechnen der
%einstellbaren Drücke in Spannungen
a = get(handles.Startwert_editText,'String');
b = get(handles.Schrittweite_editText,'String');
d = get(handles.Wartezeit_editText,'String');
Vumwandeln = str2double(a);
V = (Vumwandeln/100);
schrittweiteumwandeln = str2double(b);
schrittweite = (schrittweiteumwandeln/100);
endwert = 10;
wartezeit = str2double(d);
    
%Beginn der eigentlichen Datenausgabe
if V <= 10 && V >0
    %Textdatei öffnen
    fid = fopen('IntervallmodusA.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe=(['Intervallmodus A gestartet - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n \n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Für den Fall einer laufenden Ausgabe von Daten die Ausgabe stoppen
    stop(handles.ao);
    %Auszugebende Spannung leicht reduzieren um am Anfang zu große
    %Spannungen und zuviel regeln zu vermeiden
    Vangepasst = V-0.3;
    %Ausgabe der angepassten Spannung
    putdata(handles.ao,Vangepasst);
    start(handles.ao);
    %Aktualisieren des Textes im Statusfeld
    set(handles.StatusAntwort2_staticText,'String','Druck wird aufgebaut')
    %Pause, damit sich der Druck am Sensor einpendeln kann
    pause(5)
    %Einlesen der Spannung am Sensor und Umrechnen in einen Druck
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Anfangsschritt: Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    pause(2);
    %Regelschleife um den Druck +- 0.01 bar zu erreichen
    while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %klein ist
        while  Sensordruck < V * 0.1 - 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst+0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);
        end
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %groß ist
        while Sensordruck > V * 0.1 + 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst-0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start(handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);  
        end
        %Pause um "Überspringen" des Drucks zu vermeiden
        pause(5);
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Textes im Statusfeld
        regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
        set(handles.StatusAntwort2_staticText,'String',regeltext);
    end
    %Aktualisieren des Textes im Statusfeld
    pause(5);
    w = wartezeit;
    endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
    set(handles.StatusAntwort2_staticText,'String',endetext); 
    merktext=(['Letzter stabiler Druck: ',num2str(Sensordruck), ' bar']);
    set(handles.StatusAntwort_staticText,'String',merktext);
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusA.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe =(['Anfangsschritt: Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Schleife, um während der Wartezeit die Statusleiste zu
    %aktualisieren und Restdauer anzuzeigen
    while w>0 && V~=0
        pause(1)
        w=w-1;
        endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
        set(handles.StatusAntwort2_staticText,'String',endetext);      
    end
    %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
    %prüfen
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusA.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe =(['Anfangsschritt: Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    %Einführen eines Schrittzählers, um die weiteren Schritte zu
    %nummerieren
    Schrittzaehler=0;
    %Regelschleife für die Steigungsschritte nach dem Ersten
    while  V+schrittweite < endwert && V~=0
        %Spannung wird entsprechend der gewählten Schrittweite erhöht 
        V = V+schrittweite;
        %Schrittzähler wird erhöht
        Schrittzaehler=Schrittzaehler+1;
        %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
        %verursachen
        stop (handles.ao);
        putdata(handles.ao,Vangepasst);
        start(handles.ao);
        %Pause, damit sich der Druck am Sensor einpendeln kann
        pause(5);
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Textes im Statusfeld
        Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
        set(handles.StatusAntwort2_staticText,'String',Spannungtext);
        pause(2);
        %Regelschleife um den Druck +- 0.01 bar zu erreichen
        while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
            %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
            %klein ist
            while  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Ausgabe einer angepassten Spannung
                stop(handles.ao); 
                Vangepasst = Vangepasst+0.02;
                putdata(handles.ao,Vangepasst); 
                start(handles.ao);
                %Pause um die Reaktion des Systems abzuwarten
                pause(4);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end
            %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
            %groß ist
            while Sensordruck > V * 0.1 + 0.01 && V~=0
                %Ausgabe einer angepassten Spannung
                stop(handles.ao); 
                Vangepasst = Vangepasst-0.02;
                putdata(handles.ao,Vangepasst); 
                start(handles.ao);
                %Pause um die Reaktion des Systems abzuwarten
                pause(4);
                %Einlesen des Drucks am Sensor
                start(handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);  
            end
            %Pause um "Überspringen" des Drucks zu vermeiden
            pause(5);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);
        end 
        %Aktualisieren des Textes im Statusfeld
        pause(5);
        endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck),' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
        set(handles.StatusAntwort2_staticText,'String',endetext);
        merktext=(['Letzter stabiler Druck: ',num2str(Sensordruck), ' bar']);
        set(handles.StatusAntwort_staticText,'String',merktext); 
        w = wartezeit;
        %Schreiben der Werte in eine Textdatei
        %Textdatei öffnen
        fid = fopen('IntervallmodusA.txt','at'); 
        %Erstellen einer Textvariablen
        Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
        %Schreiben der Variablen in die Textdatei
        fprintf(fid,'\n %s',Textausgabe);
        %Textausgabe beenden
        fclose(fid);
        %Schleife, um während der Wartezeit die Statusleiste zu
        %aktualisieren und Restdauer anzuzeigen
        while w>0 && V~=0
            pause(1)
            w=w-1;
            endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
            set(handles.StatusAntwort2_staticText,'String',endetext); 
        end
        %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
        %prüfen
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Schreiben der Werte in eine Textdatei
        %Textdatei öffnen
        fid = fopen('IntervallmodusA.txt','at'); 
        %Erstellen einer Textvariablen
        Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
        %Schreiben der Variablen in die Textdatei
        fprintf(fid,'\n %s',Textausgabe);
        %Textausgabe beenden
        fclose(fid);
        Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
        set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    end

%Abfrage für den Fall, das die gewünschte Spannung = 0 ist               
elseif V == 0
    stop(handles.ao);
    putdata(handles.ao,V);
    start(handles.ao);
    nulltext=(['Druck am Sensor: ',num2str(V), ' bar']);
    set(handles.StatusAntwort2_staticText,'String',nulltext); 
end

%[Handles] Struktur aktualisieren
guidata(hObject, handles);       


% Wird ausgeführt, sobald der "Intervallmodus B starten"-Button gedrückt
function IBstart_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>

%Bereitstellen der Daten aus den Textfeldern und Umrechnen der
%einstellbaren Drücke in Spannungen
a = get(handles.Startwert_editText,'String');
b = get(handles.Schrittweite_editText,'String');
c = get(handles.Endwert_editText,'String');
d = get(handles.Wartezeit_editText,'String');
Vumwandeln = str2double(a);
V = (Vumwandeln/100);
schrittweiteumwandeln = str2double(b);
schrittweite = (schrittweiteumwandeln/100);
endwertumwandeln = str2double(c);
endwert = (endwertumwandeln/100);
wartezeit = str2double(d);
      
%Beginn der eigentlichen Datenausgabe
if V <= 10 && V >0
    %Textdatei öffnen
    fid = fopen('IntervallmodusB.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Intervallmodus B gestartet - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n \n %s',Textausgabe);
    Parameterausgabe = (['Startwert: ',a,' bar ,Schrittweite: ',b,' bar ,Maximalwert: ',c,' bar, Wartezeit: ',d,' s']);
    fprintf(fid,'\n %s',Parameterausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Für den Fall einer laufenden Ausgabe von Daten die Ausgabe stoppen
    stop(handles.ao);
    %Auszugebende Spannung leicht reduzieren um am Anfang zu große
    %Spannungen und zuviel regeln zu vermeiden
    Vangepasst = V-0.2;
    %Ausgabe der angepassten Spannung
    putdata(handles.ao,Vangepasst);
    start(handles.ao);
    %Aktualisieren des Textes im Statusfeld
    set(handles.StatusAntwort2_staticText,'String','Druck wird aufgebaut')
    %Pause, damit sich der Druck am Sensor einpendeln kann
    pause(5)
    %Einlesen der Spannung am Sensor und Umrechnen in einen Druck
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Anfangsschritt: Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    pause(2);
    %Regelschleife um den Druck +- 0.01 bar zu erreichen
    while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %klein ist
        while  Sensordruck < V * 0.1 - 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst+0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);
        end
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %groß ist
        while Sensordruck > V * 0.1 + 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst-0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start(handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);  
        end
        %Pause um "Überspringen" des Drucks zu vermeiden
        pause(5);
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Textes im Statusfeld
        regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
        set(handles.StatusAntwort2_staticText,'String',regeltext);                
    end
    %Aktualisieren des Textes im Statusfeld
    pause(5);
    w = wartezeit;
    endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
    set(handles.StatusAntwort2_staticText,'String',endetext); 
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusB.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe =(['Anfangsschritt: Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Schleife, um während der Wartezeit die Statusleiste zu
    %aktualisieren und Restdauer anzuzeigen
    while w>0 && V~=0
        pause(1)
        w=w-1;
        endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
        set(handles.StatusAntwort2_staticText,'String',endetext); 
    end
    %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
    %prüfen
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusB.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Anfangsschritt: Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    %Einführen eines Schrittzählers, um die weiteren Schritte zu
    %nummerieren
    Schrittzaehler=0;
    %Regelschleife für die Steigungsschritte nach dem Ersten
    while  V < endwert && V~=0
        if  V+schrittweite < (endwert-0.001) && V~=0
            %Spannung wird entsprechend der gewählten Schrittweite erhöht 
            V = V+schrittweite;
            %Schrittzähler wird erhöht
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop (handles.ao);
            putdata(handles.ao,Vangepasst);
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(5);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(5);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end 
            %Aktualisieren des Textes im Statusfeld
            pause(5);
            endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck),' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
            set(handles.StatusAntwort2_staticText,'String',endetext);   
            w = wartezeit;
            %Schleife, um während der Wartezeit die Statusleiste zu
            %aktualisieren und Restdauer anzuzeigen
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            while w>0 && V~=0
                pause(1)
                w=w-1;
                endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
                set(handles.StatusAntwort2_staticText,'String',endetext); 
            end
            %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
            %prüfen
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
        
        %Schleife, falls der Wert über den Endwert hinaus geht            
        elseif V+schrittweite >= (endwert-0.001) && V~=0
            V=endwert;
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop(handles.ao);
            putdata(handles.ao,Vangepasst);               
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5)
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(5);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(5);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end            
            %Aktualisieren des Textes im Statusfeld
            pause(5);
            endetext=(['Maximalwert erreicht: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
            set(handles.StatusAntwort2_staticText,'String',endetext);   
            w = wartezeit;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            %Schleife, um während der Wartezeit die Statusleiste zu
            %aktualisieren und Restdauer anzuzeigen
            while w>0 && V~=0
                pause(1)
                w=w-1;
                endetext=(['Maximalwert erreicht: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
                set(handles.StatusAntwort2_staticText,'String',endetext); 
            end
            %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
            %prüfen
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V-schrittweite)/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);    
        end 
    end 
        
    %Schleife zum Abwärtsregeln
    while  V > 0.7 && V~=0
        if  V-schrittweite > 0.7001 && V~=0
            %Spannung wird entsprechend der gewählten Schrittweite erhöht 
            V = V-schrittweite;
            %Schrittzähler wird erhöht
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop (handles.ao);
            putdata(handles.ao,Vangepasst);
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.01;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.01;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end 
            %Aktualisieren des Textes im Statusfeld
            pause(5);
            endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck),' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
            set(handles.StatusAntwort2_staticText,'String',endetext);   
            w = wartezeit;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            %Schleife, um während der Wartezeit die Statusleiste zu
            %aktualisieren und Restdauer anzuzeigen
            while w>0 && V~=0
                pause(1)
                w=w-1;
                endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
                set(handles.StatusAntwort2_staticText,'String',endetext); 
            end
            %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
            %prüfen
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V-schrittweite)/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);   
        
        elseif V-schrittweite <= 0.7001 && V~=0
            %Spannung wird entsprechend der gewählten Schrittweite erhöht 
            V = 0.7;
            %Schrittzähler wird erhöht
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop (handles.ao);
            putdata(handles.ao,Vangepasst);
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Letzter Schritt: Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Minimal erreichbares Druckniveau)']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.01;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Letzter Schritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Minimal erreichbares Druckniveau)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.01;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Letzter Schritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Minimal erreichbares Druckniveau)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Letzter Schritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Minimal erreichbares Druckniveau)']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end 
            %Aktualisieren des Textes im Statusfeld
            pause(5);
            endetext=(['Letzter Schritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck),' bar, ',num2str(wartezeit), ' Sekunden bis zum Beenden des Versuchs ']);
            set(handles.StatusAntwort2_staticText,'String',endetext);   
            w = wartezeit;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Letzter Schritt: Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            %Schleife, um während der Wartezeit die Statusleiste zu
            %aktualisieren und Restdauer anzuzeigen
            while w>0 && V~=0
                pause(1)
                w=w-1;
                endetext=(['Letzter Schritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar , ',num2str(w), ' Sekunden bis zum Beenden des Versuchs ']);
                set(handles.StatusAntwort2_staticText,'String',endetext); 
            end
            %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
            %prüfen
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusB.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Letzter Schritt: Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
        end
    end        
    V=0; %#ok<NASGU>
    Vangepasst=0;
    %Druck von Null ausgeben, um den Versuch zu beenden
    stop(handles.ao);
    putdata(handles.ao,Vangepasst);               
    start(handles.ao);
    stop(handles.ao);
    endetext=('Minimal erreichbares Druckniveau, Versuch wurde beendet');
    set(handles.StatusAntwort2_staticText,'String',endetext);
    %Ende Abwärtsregelschleife


%Abfrage für den Fall, das die gewünschte Spannung = 0 ist        
elseif V == 0
stop(handles.ao);
putdata(handles.ao,V);
start(handles.ao);
nulltext=(['Druck am Sensor: ',num2str(V), ' bar']);
set(handles.StatusAntwort2_staticText,'String',nulltext); 

end

%[Handles] Struktur aktualisieren
guidata(hObject, handles); 



% Wird ausgeführt, sobald der "Intervallmodus B starten"-Button gedrückt
function ICstart_pushbutton_Callback(hObject, eventdata, handles) %#ok<INUSL,DEFNU>
    
%Bereitstellen der Daten aus den Textfeldern und Umrechnen der
%einstellbaren Drücke in Spannungen
a = get(handles.Startwert_editText,'String');
b = get(handles.Schrittweite_editText,'String');
c = get(handles.Endwert_editText,'String');
d = get(handles.Wartezeit_editText,'String');
e = get(handles.Wartezeit2_editText,'String');
Vumwandeln = str2double(a);
V = (Vumwandeln/100);
schrittweiteumwandeln = str2double(b);
schrittweite = (schrittweiteumwandeln/100);
endwertumwandeln = str2double(c);
endwert = (endwertumwandeln/100);
wartezeit = str2double(d);
wartezeit2 = str2double(e);

%Beginn der eigentlichen Datenausgabe
if V <= 10 && V >0
    %Textdatei öffnen
    fid = fopen('IntervallmodusC.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Intervallmodus B gestartet - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n \n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Für den Fall einer laufenden Ausgabe von Daten die Ausgabe stoppen
    stop(handles.ao);
    %Auszugebende Spannung leicht reduzieren um am Anfang zu große
    %Spannungen und zuviel regeln zu vermeiden
    Vangepasst = V-0.3;
    %Ausgabe der angepassten Spannung
    putdata(handles.ao,Vangepasst);
    start(handles.ao);
    %Aktualisieren des Textes im Statusfeld
    set(handles.StatusAntwort2_staticText,'String','Druck wird aufgebaut')
    %Pause, damit sich der Druck am Sensor einpendeln kann
    pause(5)
    %Einlesen der Spannung am Sensor und Umrechnen in einen Druck
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Anfangsschritt: Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    pause(2);
    %Regelschleife um den Druck +- 0.01 bar zu erreichen
    while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %klein ist
        while  Sensordruck < V * 0.1 - 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst+0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);
        end
        %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
        %groß ist
        while Sensordruck > V * 0.1 + 0.01 && V~=0
            %Ausgabe einer angepassten Spannung
            stop(handles.ao); 
            Vangepasst = Vangepasst-0.02;
            putdata(handles.ao,Vangepasst); 
            start(handles.ao);
            %Pause um die Reaktion des Systems abzuwarten
            pause(4);
            %Einlesen des Drucks am Sensor
            start(handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',regeltext);  
        end
        %Pause um "Überspringen" des Drucks zu vermeiden
        pause(5);
        %Einlesen des Drucks am Sensor
        start (handles.ai);
        s = getdata (handles.ai);
        Sensoreingang = mean(s);
        stop (handles.ai);
        Sensordruck = Sensoreingang*0.049;
        %Aktualisieren des Textes im Statusfeld
        regeltext=(['Anfangsschritt: Regele, aktueller Druck: ',num2str(Sensordruck), ' bar']);
        set(handles.StatusAntwort2_staticText,'String',regeltext);                
    end
    %Aktualisieren des Textes im Statusfeld
    pause(5);
    w = wartezeit;
    endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
    set(handles.StatusAntwort2_staticText,'String',endetext);
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusC.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe =(['Anfangsschritt: Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Schleife, um während der Wartezeit die Statusleiste zu
    %aktualisieren und Restdauer anzuzeigen
    while w>0 && V~=0
        pause(1)
        w=w-1;
        endetext=(['Anfangsschritt: Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
        set(handles.StatusAntwort2_staticText,'String',endetext); 
    end
    %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
    %prüfen
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusC.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Anfangsschritt: Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Aktualisieren des Textes im Statusfeld
    Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
    set(handles.StatusAntwort2_staticText,'String',Spannungtext);
    %Einführen eines Schrittzählers, um die weiteren Schritte zu
    %nummerieren
    Schrittzaehler=0;
    %Regelschleife für die Steigungsschritte nach dem Ersten
    while  V < endwert && V~=0
        if  V+schrittweite < (endwert-0.001) && V~=0
            %Spannung wird entsprechend der gewählten Schrittweite erhöht 
            V = V+schrittweite;
            %Schrittzähler wird erhöht
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop (handles.ao);
            putdata(handles.ao,Vangepasst);
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5);
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end 
            %Aktualisieren des Textes im Statusfeld
            pause(5);
            endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck),' bar, ',num2str(wartezeit), ' Sekunden bis zum nächsten Schritt ']);
            set(handles.StatusAntwort2_staticText,'String',endetext);   
            w = wartezeit;
            %Schleife, um während der Wartezeit die Statusleiste zu
            %aktualisieren und Restdauer anzuzeigen
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusC.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            while w>0 && V~=0
                pause(1)
                w=w-1;
                endetext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung): ',num2str(Sensordruck), ' bar, ',num2str(w), ' Sekunden bis zum nächsten Schritt ']);
                set(handles.StatusAntwort2_staticText,'String',endetext); 
            end
            %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
            %prüfen
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Schreiben der Werte in eine Textdatei
            %Textdatei öffnen
            fid = fopen('IntervallmodusC.txt','at'); 
            %Erstellen einer Textvariablen
            Textausgabe = (['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
            %Schreiben der Variablen in die Textdatei
            fprintf(fid,'\n %s',Textausgabe);
            %Textausgabe beenden
            fclose(fid);
            Spannungtext=(['Nächster Schritt: Gewünschter Druck ist ',num2str((V+schrittweite)/10),' bar']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
        
        %Schleife, falls der Wert über den Endwert hinaus geht            
        elseif V+schrittweite >= (endwert-0.001) && V~=0
            V=endwert;
            Schrittzaehler=Schrittzaehler+1;
            %Zunächst Ausgabe der alten Spannung um keine Sprünge zu
            %verursachen
            stop(handles.ao);
            putdata(handles.ao,Vangepasst);               
            start(handles.ao);
            %Pause, damit sich der Druck am Sensor einpendeln kann
            pause(5)
            %Einlesen des Drucks am Sensor
            start (handles.ai);
            s = getdata (handles.ai);
            Sensoreingang = mean(s);
            stop (handles.ai);
            Sensordruck = Sensoreingang*0.049;
            %Aktualisieren des Textes im Statusfeld
            Spannungtext=(['Schritt ',num2str(Schrittzaehler) ,': Druck am Sensor (vor Regelung): ',num2str(Sensordruck) , ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
            set(handles.StatusAntwort2_staticText,'String',Spannungtext);
            pause(2);
            %Regelschleife um den Druck +- 0.01 bar zu erreichen
            while Sensordruck > V * 0.1 + 0.01  ||  Sensordruck < V * 0.1 - 0.01 && V~=0
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %klein ist
                while  Sensordruck < V * 0.1 - 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst+0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start (handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);
                end
                %Anweisungen für den Fall, dass der Druck mehr als 0.01 bar zu
                %groß ist
                while Sensordruck > V * 0.1 + 0.01 && V~=0
                    %Ausgabe einer angepassten Spannung
                    stop(handles.ao); 
                    Vangepasst = Vangepasst-0.02;
                    putdata(handles.ao,Vangepasst); 
                    start(handles.ao);
                    %Pause um die Reaktion des Systems abzuwarten
                    pause(4);
                    %Einlesen des Drucks am Sensor
                    start(handles.ai);
                    s = getdata (handles.ai);
                    Sensoreingang = mean(s);
                    stop (handles.ai);
                    Sensordruck = Sensoreingang*0.049;
                    %Aktualisieren des Textes im Statusfeld
                    regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                    set(handles.StatusAntwort2_staticText,'String',regeltext);  
                end
                %Pause um "Überspringen" des Drucks zu vermeiden
                pause(5);
                %Einlesen des Drucks am Sensor
                start (handles.ai);
                s = getdata (handles.ai);
                Sensoreingang = mean(s);
                stop (handles.ai);
                Sensordruck = Sensoreingang*0.049;
                %Aktualisieren des Textes im Statusfeld
                regeltext=(['Schritt ',num2str(Schrittzaehler) ,': Regele, aktueller Druck: ',num2str(Sensordruck), ' bar, gewünschter Druck ist: ',num2str(V/10),' bar (Maximalwert)']);
                set(handles.StatusAntwort2_staticText,'String',regeltext);
            end            
        end 
    end
    pause(2);
    endetext=(['Maximalwert erreicht: Druck am Sensor: ',num2str(Sensordruck),' bar, Haltezeit bis der Druck = 0 gesetzt wird: ',num2str(wartezeit2), ' Sekunden']);
    set(handles.StatusAntwort2_staticText,'String',endetext);   
    w = wartezeit2;
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusC.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Maximalwert erreicht: Druck am Sensor (nach Regelung, vor Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    %Schleife, um während der Wartezeit die Statusleiste zu
    %aktualisieren und Restdauer anzuzeigen
    while w>0 && V~=0
        pause(1)
        w=w-1;
        endetext=(['Maximalwert erreicht: Druck am Sensor: ',num2str(Sensordruck),' bar, Haltezeit bis der Druck = 0 gesetzt wird: ',num2str(w), ' Sekunden']);
        set(handles.StatusAntwort2_staticText,'String',endetext); 
    end
    %Einlesen des Drucks am Sensor um diesen nach der Wartezeit erneut zu
    %prüfen
    start (handles.ai);
    s = getdata (handles.ai);
    Sensoreingang = mean(s);
    stop (handles.ai);
    Sensordruck = Sensoreingang*0.049;
    %Schreiben der Werte in eine Textdatei
    %Textdatei öffnen
    fid = fopen('IntervallmodusC.txt','at'); 
    %Erstellen einer Textvariablen
    Textausgabe = (['Maximalwert erreicht: Druck am Sensor (nach Regelung, nach Wartezeit): ',num2str(Sensordruck), ' bar - ',datestr(now),]);
    %Schreiben der Variablen in die Textdatei
    fprintf(fid,'\n %s',Textausgabe);
    %Textausgabe beenden
    fclose(fid);
    V=0; %#ok<NASGU>
    Vangepasst=0;
    %Druck von Null ausgeben, um den Versuch zu beenden
    stop(handles.ao);
    putdata(handles.ao,Vangepasst);               
    start(handles.ao);
    stop(handles.ao);
    endetext=('Versuch beendet');
    set(handles.StatusAntwort2_staticText,'String',endetext); 

%Abfrage für den Fall, das die gewünschte Spannung = 0 ist        
elseif V == 0
stop(handles.ao);
putdata(handles.ao,V);
start(handles.ao);
nulltext=(['Druck am Sensor: ',num2str(V), ' bar']);
set(handles.StatusAntwort2_staticText,'String',nulltext);        
end         

%[Handles] Struktur aktualisieren
guidata(hObject, handles);



function Hoehe_editText_Callback(hObject, eventdata, handles)


% --- Executes during object creation, after setting all properties.
function Hoehe_editText_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end