Einf hrung in die Datenverarbeitung FH Mainz by benbenzhou

VIEWS: 3 PAGES: 48

									                           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




                                                                     1
                                   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




                                                  2
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.



                                             3
                                      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.
                                                       4
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.




                                                                                   5
                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)          Auf den Range Befehl
                           TextBox4 = Auswahl(2, 2)          kommen wir noch
                                    End Sub

                                                                               6
Private Sub CommandButton1_Click()             vereinbart das Objekt Auswahl vom Typ Range,
Dim Auswahl As Range                           das geeignet ist, einen Tabellenbereich
Set Auswahl = Tabelle1.Range("A1:B2")          aufzunehmen.
                                               weist dem Objekt „Auswahl“ den Bereich
                                               "A1:B2" des Tabellenblattes mit dem Namen
                                               Tabelle1 zu.


Auswahl.Select                                 Methode. Der Bereich wird mit einer speziellen
                                               Anweisung (Methode) die nur in Verbindung
                                               mit dem Objekt anwendbar ist.
                                               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


                                                                                       7
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.


                                                                               8
So genug des „Geplänkels“ lassen Sie uns mit einem richtigen Beispiel beginnen


Wir wollen eine Ampel programieren!




                                                                            9
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":




                                                                                    10
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




                                                                         11
   Was steht denn da nun eigendlich in dem Makro
   zum Schalten der roten Ampel?



ActiveSheet.Shapes("Oval 2").Select                     Kreis "Ellipse" auswählen
Selection.ShapeRange.Fill.ForeColor.SchemeColor = 10           Füllfarbe rot

Selection.ShapeRange.Fill.Visible = msoTrue                 Füllung sichtbar
Selection.ShapeRange.Fill.Solid                            Füllung monochrom
Range("G4").Select
                                                            Zelle G4 auswählen
ActiveCell.FormulaR1C1 = "an"                          Text "an" in die ausgewählte
                                                              Zelle eintragen
Range("G4").Select
Selection.Font.Bold = True                                  Zelle G4 auswählen
Selection.Font.ColorIndex = 3                              Textfarbe rot und fett
End Sub

          Das hätten wir auch mit                         realisieren können   12
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.
                                                                                   13
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                       Hier wird eine „Pause“ programmiert.
      For i = 1 To 1000000
      j=i^2                         Aber was bedeutet eigendlich
      Next i
      rot_aus                                   For i= ..... Next i
      For i = 1 To 1000000
      j=i^2
      Next i
      gruen_an
      For i = 1 To 1000000
      j=i^2
      Next i
      gelb_aus                                                             14
Schleifen mit Schleifenindex. Die For - Next - Schleife
For i = start To ende Step Inkrement
           <Anweisung>
Next i
                                                               3
                                                      
                                                              a * b
Beispiel: Skalarprodukt
                                                 c  a *b           i    i
   Private Sub CommandButton1_Click()
                                                              i 1
   Dim a(2), b(2)
   a(1) = Cells(2, 1)
   a(2) = Cells(3, 1)                            Dazu kommen wir gleich
   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          Einfachste Art der Ausgabe
   End Sub
                                                                              15
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




                                                                          16
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




                                                                               17
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
                                             18
 Wenn wir nun die For ... Next Schleife haben können wir uns auch Verzweigungen ansehen

Verzweigungen
    IF - Then - ElseIf

    If <Bedingung1> Then
          <Anweisung1>   'Bedingung1 erfüllt
    elseif <Bedingung2>
          <Anweisung2>   'Bedingung2 erfüllt.
    else
          <Anweisung3>   'keine Bedingung erfüllt.
    End If




                                                                                     19
Jetzt Beispiel: Teilchen in Box




                                  20
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
                                  Es funktioniert, sieht aber
For i = 1 To 500
                                  nicht so „schön“ aus
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
                                                                21
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
                                                   22
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
                                                        23
End Sub
  Vom Beispiel wieder zur Theorie:
     Variable
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.




                                                                                          24
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:




                                                                                      25
$




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



  Sub Implizit

  Strvalue$ =„Implizit“
  Debug.Print strvalue
  End sub




                          27
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.




                                                                                     28
 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.
                                                                                             29
30
31
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)




                                                                    32
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
                                                                                      33
 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




                                                                                       34
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.




                                                                                          35
So, nun wollen wir das bisher Gelernte
               doch mal für die Bauphysik anwenden:

Beispiel : Instationäre Temperaturentwicklung in einem Bauteil

Hierzu : Finite Differenzenmethode




                                                                 36
37
Doch wie sollen wir das in einem Programm umsetzen?
Was ist die erste bzw. zweite Ableitung denn?




        Dies ist die erste Ableitung      Dies ist die erste Ableitung
        nach der Zeit = f´(t)             nach der Zeit = f´(t)


                                                        Ohne Herleitung:

 f ´(t )  f (t  t )  f (t )  O(t )
                        t


                                                                           38
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.




                                                                                      39
Damit haben wir das Diagramm für die Anfangsbedingung




            Anfangs
            -temperatur


                                                        40
  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 + T/t *t = T1 + l/(r cp) d²T/dx² *t

                     Mit:


Folgt: T2(x) = T1(x) + l/(r cp) *t * (T1(x+1) – 2 T1(x) + T1(x-1))/x²

   T2(x) = T1(x) + l/(r cp)  t * (T1(x+1) – 2 T1(x) + T1(x-1))/ x²
   T2(x) = T1(x) + t * D * (T1(x+1) – 2 T1(x) + T1(x-1))
                                                                                       41
Erster Schritt: Diffusionskoeffizienten z.B. in Excle berechnen und an Programm
                übergeben




                                                                             42
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


                                         ( x,t )
                                                     D 
                                                          ( xx,t )  2( x,t )  ( xx,t ) 
                                                         t
                                           t                               x 2

Next i


                                                                                                       43
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




                                                                                        44
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
Next i

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

Application.ScreenUpdating = True

Next t
                                                                                                                45
End Sub
46
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
                                                                                47
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

                                                                                      48

								
To top