Teil 1: VBA Visual Basic for Applications (VBA) von Microsoft ist eine aus dem von Microsoft entwickelten Basic-Dialekt Visual Basic (VB) abgeleitete ereignisorientierte Skriptsprache

Fortran Input File Fortran u.ä. Programme sind sequentieller Programme. Man gibt das Programm ein, startet und wartet auf das Ergebnis. Meist werden dann die Eingabedaten von einer Datei gelesen (Input File) und Ausgabedaten auf eine andere Datei geschrieben (Output File). Für die Bearbeitung großer Datenmengen, insbesondere auf Großrechnern, ist das nach wie vor der Normalfall. Output File

VBA ist ein ereignisorientiertes Programm. Ereignisorientierte Programme "warten" nach dem Start auf Mitteilungen des Anwenders. Der Nutzer steuert interaktiv (durch Klicken) den Programmablauf. Ereignisorientierte Programme besitzen dadurch eine andere Struktur als sequentielle Programme: anstelle einer Liste von Befehlen, die dem geplanten Ablauf entsprechend geordnet sind, hat man hier eine Sammlung von Objekten, Prozeduren und Funktionen.

Objekte in VBA Objekte stellen einen abstrakten Begriff dar. Sie sind eine Zusammenfassung aus Daten und den Funktionen. Das bedeutet, Objekte sind alle Teile, die man in Excel sehen kann, z.B. die Arbeitsmappe, das Tabellenblatt und die Zelle als kleinste Einheit in Excel. Aus die Objekte kann man zugreifen, man kann sie programmieren und steuern. Objekte können auch bestimmte Eigenschaften haben.

Eigenschaften: dahinter verbergen sich die Merkmale eines Objektes. Z Eigenschaften: dahinter verbergen sich die Merkmale eines Objektes. Z.B. die Formatierung einer Zelle. Machen wir z.B. ein leeres Excel Arbeitsblatt auf und drücken Sie Alt + F11 oder installieren einen Command-Buttom und klicken darauf. In beiden Fällen kommen wir in die VBA-Entwicklungsumgebung. Wir klicken die Tabelle 1 an und wollen einmal eine Eigenschaft dieses Arbeitsblattes auswählen. Geben Sie z.B. in das Feld Scroll Area und geben dort $A$1 : $D$20 ein, so ist nur der entsprechende Bereich adressierbar.

Was verbirgt sich hinter dem Ausdruck Methode? Methode: Was kann man mit den Objekten machen? Für eine Arbeitsmappe z.B. Öffnen, Drucken, Speichern, Schließen, etc. Beipiel: Dem Bereich "A1:B2" in einem Tabellenblatt soll ein symbolischer Name, d.h. eine Variable, zugewiesen werden, um die weitere Programmierung zu vereinfachen: Private Sub CommandButton1_Click() Dim Auswahl As Range Set Auswahl = Tabelle1.Range("A1:B2") Auswahl.Select Auswahl.Interior.ColorIndex = 8 Jetzt können wir z.B. die definierte Tabelle auslesen. TextBox1 = Auswahl(1, 1) TextBox2 = Auswahl(1, 2) TextBox3 = Auswahl(2, 1) TextBox4 = Auswahl(2, 2) End Sub Auf den Range Befehl kommen wir noch

Private Sub CommandButton1_Click() Dim Auswahl As Range Set Auswahl = Tabelle1.Range("A1:B2") Auswahl.Select Oder wir können z.B. die definierte Tabelle auslesen. TextBox1 = Auswahl(1, 1) TextBox2 = Auswahl(1, 2) TextBox3 = Auswahl(2, 1) TextBox4 = Auswahl(2, 2) End Sub vereinbart das Objekt Auswahl vom Typ Range, das geeignet ist, einen Tabellenbereich aufzunehmen. weist dem Objekt „Auswahl“ den Bereich "A1:B2" des Tabellenblattes mit dem Namen Tabelle1 zu. Methode. Der Bereich wird mit einer speziellen Anweisung (Methode) die nur in Verbindung mit dem Objekt anwendbar ist. Auswahl.Select

Jetzt wollen wir z.B. die Farbe des Hintergrundes des Tabellenblattes ändern Eigenschaft. Die Farbe des Hintergrundes ist z.B. eine Eigenschaft. Die Farbe ändern wir z.B. mit: Auswahl.Interior.ColorIndex = 8 Das Wort Interior bezeichnet das Innere,d.h. den Hintergrund, des Zellbereiches. Der Hintergrund selbst wiederum ist ein Objekt. ColorIndex ist der Name eines der möglichen Attribute, bzw. eine Eigenschaft des Objektes Interior. Der Wert der Eigenschaft ist 8, das entspricht der Farbe Zyan. Tabelle1.Range("A1:B2").Interior.ColorIndex = 8 Aufgabe: Erstellen Sie eine Bildlaufleiste, mit der Sie die Farbe des Datenberichs kontinuierlich von 1 bis 10 ändern können.

So genug des „Geplänkels“ lassen Sie uns mit einem richtigen Beispiel beginnen Wir wollen eine Ampel programieren!

Makros: Ampellichter an- und ausschalten Als erstes wollen wir die einzelnen Lichter der Ampel an- und ausschalten. Zunächst wird Excel gestartet. Wir zeichnen eine Ampel aus drei Kreisen und einem Rechteck und erstellen eine Tabelle für den Zustand der Lichter. Aufzeichnung beginnen. Das Einschalten des roten Lichtes und die farbliche Markierung von dem Eintrag Rot „an" werden aufgezeichnet. Makro-Recorder starten. Extras -> Makro -> Aufzeichnen ... Folgende Maske erscheint, der Name des Makros wird angegeben, hier "rot_an":

Damit erzeugen wir eine „Prozedur“, sie beginnt mit dem Wort „Sub“ Jetzt kann man dieses Makro direkt in an eine Befehlsschaltfläche ankoppeln: Damit erzeugen wir eine „Prozedur“, sie beginnt mit dem Wort „Sub“ Private Sub CommandButton4_Click() rot_an End Sub Das Gleiche machen Sie nun bitte mit rot aus Wir kommen gleich auf den allgemeinen Begriff der Prozedur zurück

Kreis "Ellipse" auswählen Text "an" in die ausgewählte Was steht denn da nun eigendlich in dem Makro zum Schalten der roten Ampel? ActiveSheet.Shapes("Oval 2").Select Selection.ShapeRange.Fill.ForeColor.SchemeColor = 10 Selection.ShapeRange.Fill.Visible = msoTrue Selection.ShapeRange.Fill.Solid Range("G4").Select ActiveCell.FormulaR1C1 = "an" Selection.Font.Bold = True Selection.Font.ColorIndex = 3 End Sub Kreis "Ellipse" auswählen Füllfarbe rot Füllung sichtbar Füllung monochrom Zelle G4 auswählen Text "an" in die ausgewählte Zelle eintragen Textfarbe rot und fett Das hätten wir auch mit realisieren können

Damit Sie an möglichst viele Erfolgserlebnisse kommen, machen Sie sich Makros für Gelb an und Gelb aus, Grün an und Grün aus und binden Sie diese an die jeweiligen Steuerelemente an oder kopieren Sie sich den Quellcode des Makros rot an und verändern die Bezugsobjekte so , dass Sie auch grün und gelb schalten können Es gibt nun 6 Makros. Oder Sie haben aus dem einen Makro weitere 5 Prozeduren gemacht, die wie gewünscht agieren. Sub gelb_an etc.

Eine Ampelschaltung besteht aus definierten Lichtkombinationen. Dazu müssen Lichter an- und ausgeschaltet werden: Jetzt wollen wir die Ampel von Halt hin zu Fahrt steuern Private Sub CommandButton2_Click() rot_an For i = 1 To 1000000 j = i ^ 2 Next i gelb_an rot_aus gruen_an gelb_aus Hier wird eine „Pause“ programmiert. Aber was bedeutet eigendlich For i= ..... Next i

Schleifen mit Schleifenindex Schleifen mit Schleifenindex. Die For - Next - Schleife For i = start To ende Step Inkrement <Anweisung> Next i Beispiel: Skalarprodukt Private Sub CommandButton1_Click() Dim a(2), b(2) a(1) = Cells(2, 1) a(2) = Cells(3, 1) b(1) = Cells(2, 2) b(2) = Cells(3, 2) TextBox1 = "Vektor a: " & a(1) & " " & a(2) TextBox2 = "Vektor a: " & b(1) & " " & b(2) sp = 0 For i = 1 To 2 sp = sp + (a(i) * b(i)) Next i MsgBox "Das Skalarprodukt beträgt " & sp End Sub Dazu kommen wir gleich Einfachste Art der Ausgabe

InputBox: Mit der MsgBox können wir nun Daten sehr einfach ausgeben, Gibt es auch eine einfache Funktion Daten abzufragen und in das Programm zu bekommen? InputBox: Private Sub CommandButton2_Click() a = InputBox("a eingeben") Cells(20, 1) = a End Sub

Beispiel For ... Next: Farbtabelle ausgeben Private Sub CommandButton1_Click() For bfarbe = 1 To 10 Cells(bfarbe, 1) = bfarbe Cells(bfarbe, 2).Interior.ColorIndex = bfarbe Next bfarbe End Sub

Private Sub CommandButton2_Click() For i = 1 To 36 Step 2 For j = 1 To 36 Step 2 Cells(i, j).Interior.ColorIndex = Rnd * 10 Next j Next i End Sub

Wenn wir nun die For ... Next Schleife haben können wir uns auch Verzweigungen ansehen IF - Then - ElseIf If <Bedingung1> Then <Anweisung1> 'Bedingung1 erfüllt elseif <Bedingung2> <Anweisung2> 'Bedingung2 erfüllt. else <Anweisung3> 'keine Bedingung erfüllt. End If

Jetzt Beispiel: Teilchen in Box

Private Sub CommandButton1_Click() Rem Lesen der x- Geschwindigkeit vx = Cells(4, 1) Rem Lesen der y- Geschwindigkeit vy = Cells(5, 1) Rem Setzen des Anfangspunktes x1 = 2 y1 = 2 For i = 1 To 500 x2 = x1 + vx y2 = y1 + vy y1 = y2 x1 = x2 Cells(1, 1) = x1 Cells(2, 1) = y1 If x1 > 3.9 Then vx = vx * -1 If y1 > 3.9 Then vy = vy * -1 If x1 < 0.1 Then vx = vx * -1 If y1 < 0.1 Then vy = vy * -1 Application.ScreenUpdating = True Next i End Sub Es funktioniert, sieht aber nicht so „schön“ aus

Private Sub CommandButton2_Click() Rem Lesen der x- Geschwindigkeit vx = Cells(4, 1) Rem Lesen der y- Geschwindigkeit vy = Cells(5, 1) Rem Setzen des Anfangspunktes x1 = 2 y1 = 2 Application.Calculation = xlCalculationManual For i = 1 To 500 x2 = x1 + vx y2 = y1 + vy y1 = y2 x1 = x2 Cells(1, 1) = x1 Cells(2, 1) = y1 If x1 > 3.9 Then vx = vx * -1 If y1 > 3.9 Then vy = vy * -1 If x1 < 0.1 Then vx = vx * -1 If y1 < 0.1 Then vy = vy * -1 Worksheets("Tabelle1").Calculate Next i Application.Calculation = xlCalculationAutomatic End Sub

„Schön“ sind auch Select Case Verzweigungen Select - Case Select Case a Case 1 b = 20 : c = 30 Case 2 b = 21 : c = 31 Case Else b = 0 : c = 0 End Select Private Sub CommandButton1_Click() a = Cells(1, 1) Dim Text As String Select Case a Case 1 Text = "Fall a" Case 2 Text = "Fall b" Case 3 Text = "Fall c" End Select MsgBox Text End Sub

Variable Vom Beispiel wieder zur Theorie: Bevor eine Variable benutzt wird, sollte sie im Deklarationsteil der Prozedur deklariert werden. Dies ist in Visual Basic für Applikationen nicht zwingend erforderlich, sollte aber, um zum Beispiel Tippfehler zu vermeiden, immer gemacht werden. Variablennamen können aus bis zu 255 Zeichen des Alphabets einschließlich Umlauten und Unterstrich bestehen. Sonderzeichen (!, @, &, $, #) und Leerzeichen sind unzulässig. Es wird nicht zwischen Groß- und Kleinbuchstaben unterschieden. Das erste Zeichen muss ein Buchstabe sein.

Damit eine Variablendeklaration immer erzwungen wird, sollte am Anfang jedes Moduls die Anweisung Option Explicit eingefügt werden. Sie können dies als Voreinstellung wählen, in dem Sie im VBA-Menü Extras/Optionen auswählen und in dem erscheinenden Dialog die Option Variablendeklaration erforderlich markieren. Explizite Variablendeklaration:

$

Sub Explizit Dim strvalue as string Strvalue =„Explizit“ Debug.Print strvalue End sub Sub Implizit Strvalue$ =„Implizit“ Debug.Print strvalue End sub

Vom Beispiel wieder zur Theorie: Prozeduren und Funktionen In VBA gibt es zwei unterschiedliche Arten von Teilprogrammen: Prozeduren und Funktionen. Sie unterscheiden sich darin, ob sie einen Wert zurückgeben oder nicht. 1) Prozeduren Eine Prozedur beginnt mit dem Schlüsselwort Sub. In unserem Ampelbeispiel haben wir ausschließlich Prozeduren verwendet. Die syntaktische Verwandtschaft mit FORTRAN fällt auf.

Erzeugen wir eine neue Prozedur Am Anfang einer Konstantendeklaration kann der Modifizierer "Public" oder der Modifizierer "Private" verwendet werden, um festzulegen, daß die Konstanten in allen Modulen bzw. nur in ihrem Modul gültig sein sollen. Deklaration im Modulkopf eines Standardmoduls als Public Die Variable gilt für alle Prozeduren der Arbeitsmappe, soweit das die Prozedur enthaltene Modul nicht als Private deklariert ist.

Public Durch das Schlüsselwort Public wird der Geltungsbereich von Variablen, Funktionen und Prozeduren auf alle Module ausgeweitet. Publec Function SProd (a() As Double, b() As Double) Privat Durch das Schlüsselwort Privat wird der Geltungsbereich von Variablen, Funktionen und Prozeduren auf einen Module beschränkt. Privat Function SProd (a() As Double, b() As Double)

Funktionen Funktionen geben einen Wert zurück. Der Wert wird einer Variablen mit dem Namen der Funktion zugewiesen. Function StatusRot() As Integer ' gibt die aktuelle Farbe des Rotlichtes zurück ActiveSheet.Shapes("Oval 2").Select StatusRot = Selection.ShapeRange.Fill.ForeColor.SchemeColor End Function

Die Funktion rufen wir nun z.B. in einer Prozedur auf: Sub TestRot() Dim Farbe As Integer Farbe = StatusRot ' Funktionsaufruf rechts vom Komma Jetzt z.B. Ausgabe in ein Textfeld End Sub Zusätzlich wurde hier der Datentyp Integer verwendet. Siehe dazu weiter unten. VBA Funktionen Es gibt eine große Menge von fertigen Funktionen in VBA. Den besten Überblick erhält man in der Online-Sprachreferenz Hilfe -> Visual Basic Sprachreferenz

Nützliche Funktionen 2.10.1 InputBox Diese Funktion öffnet ein Dialogfenster mit einem Textfeld, in das eine Zeichenfolge eingeben werden kann. Die Funktion gibt einen Wert vom Typ string zurück. Wenn der Datentyp der Variablen, die den Rückgabewert der InputBox erhält, von einem anderen Datentyp als string ist, wird eine Typumwandlung durchgeführt (siehe Beispiel). Syntax InputBox(prompt[, title] [, default] [, xpos] [, ypos]) Beispiele: Dim i As Integer i = InputBox("Geben Sie eine Ganzzahl ein") Dim str As String str = InputBox("Geben Sie eine Zeichenfolge ein") Hinweise Mit dem zweiten Parameter title wird der Text in der Titelleiste der InputBox bestimmt. Der dritte Parameter default ermöglicht einen Voreinstellungswert in das Textfeld zu schreiben.

So, nun wollen wir das bisher Gelernte doch mal für die Bauphysik anwenden: Beispiel : Instationäre Temperaturentwicklung in einem Bauteil Hierzu : Finite Differenzenmethode

Doch wie sollen wir das in einem Programm umsetzen? Was ist die erste bzw. zweite Ableitung denn? Dies ist die erste Ableitung nach der Zeit = f´(t) Dies ist die erste Ableitung nach der Zeit = f´(t) Ohne Herleitung:

Wie gehen wir nun vor: 1.) wir definieren und ein festes Gitter in x Richtung, so lang wie das Bauteil ist z.B. 20 cm lang. Dazu erstellen wir 20 Gitterpunkte, an denen die Temperatur in dem Bauteil berechnet werden soll. Der Abstand zwischen 2 Rechenpunkten hat die Länge 1 cm. x 1 2 3 4 5 6 .............................................20 Jetzt müssen wir die Anfangstemperaturverteilung in der Wand vorgeben. An der Innenwand soll eine Temperatur von 20 C herschen, die Wand selbst soll auch 20 C warm sein. T1(1) bis T1(19) = 20 Außen, d.h. T1(20) herscht eine Temperatur von -10 C.

Damit haben wir das Diagramm für die Anfangsbedingung -temperatur

Bzw. daraus T2 = T1 + DT/Dt *Dt = T1 + l/(r cp) d²T/dx² *Dt Jetzt geht es darum die Änderung der Temperaturverteilung T(xi) z.B. 1 sec nach dem Start zu berechnen. Wir wissen: Bzw. daraus T2 = T1 + DT/Dt *Dt = T1 + l/(r cp) d²T/dx² *Dt Mit: Folgt: T2(x) = T1(x) + l/(r cp) *Dt * (T1(x+1) – 2 T1(x) + T1(x-1))/Dx² T2(x) = T1(x) + l/(r cp) D t * (T1(x+1) – 2 T1(x) + T1(x-1))/ Dx² T2(x) = T1(x) + Dt * D * (T1(x+1) – 2 T1(x) + T1(x-1))

Erster Schritt: Diffusionskoeffizienten z. B Erster Schritt: Diffusionskoeffizienten z.B. in Excle berechnen und an Programm übergeben

Und nun geht es los! Rem Einlesen der Difusionskoeffizienten diff = Cells(8, 7) delta_t = Cells(9, 7) Rem hier kommt die Prognoseschleife For t = 1 To 400 Step delta_t For i = 7 To 24 (die Temperaturen gehen von 6 bis 25, dh. Die Wandtemperatur bleibt fest) Cells(i, 4) = Cells(i, 3) + delta_t * diff * (Cells((i + 1), 3) - 2 * Cells(i, 3) + Cells(i - 1, 3)) /0.0001 Next i

Nach einem Zeitschritt wurde nun die Temperaturverteilung in der Wand zum Zeitpunkt t2 berechnet. Das ist die Ausgangsverteilung für die Berechnung der Temperatur zum Zeitpunkt t3 D.h. nach jeder Berechnung müssen wir die „neue“ Temperaturverteilung über alte schreiben Rem jetzt werden die Werte T(t+ dt) an T(t) übergeben For i = 7 To 24 Cells(i, 3) = Cells(i, 4) Next i

Private Sub CommandButton1_Click() Rem wir schreiben die Anfangstemperatur in die Spalte 3 ab der Zeile 6 For i = 6 To 24 Cells(i, 3) = 20 Next i Cells(25, 3) = -10 Rem Einlesen der Difusionskoeffizienten diff = Cells(8, 7) delta_t = Cells(9, 7) Rem hier kommt die Prognoseschleife For t = 1 To 400 Step delta_t For i = 7 To 24 Cells(i, 4) = Cells(i, 3) + delta_t * diff * (Cells((i + 1), 3) - 2 * Cells(i, 3) + Cells(i - 1, 3)) / 0.0001 Rem jetzt werden die Werte T(t+ dt) an T(t) übergeben Cells(i, 3) = Cells(i, 4) Application.ScreenUpdating = True Next t End Sub

Leider ist die Lösung dieser finiten Differenzgleichung sehr abhängig von der Wahl der Diskretisierung. Das Verfahren ist nur stabil wenn: Das Neumann-Kriterium eingehalten ist, d.h. D * Dt/Dx² <0,5

Jetzt wollen wir das Ergebnis der Berechnung „auf Kommando“ einmal als File abspeichern Open: Öffnen einer Datei Open <Dateiname> For <Modus> As #<Kanal> <Modus> : Input Daten lesen Output Daten schreiben <Kanal> : Die Kanalnummer regelt den Dateizugriff. Beispiel: Open „e:\ergebnis.dat" For Output As #1 Close: Schließen einer Datei Close #<Kanal> <Kanal> : Die Kanalnummer der zu schließenden Datei. Beispiel: Close #1