Ansteuerung von Arduino Uno mit Visual Basic

[redround]

C und VB sind komplett andere Sprachen, denen auch ein komplett anderer Ansatz zugrunde liegt.

Ich poste hier mal einen Ausschnitt aus dem Code, den ich zuletzt verwendet habe:
Imports System.IO.Ports

Imports System.IO.Ports

Public Class Controller
    Private myPort As SerialPort

#Region "implementation of singelton pattern"
    Private Shared myInstance As Controller
    Public Shared ReadOnly Property Instance() As Controller
        Get
            If myInstance Is Nothing Then
                myInstance = New Controller
            End If
            Return myInstance
        End Get
    End Property
#End Region

    Public Sub New()
        myPort = New SerialPort
        With myPort
            .PortName = "COM7"
            .BaudRate = 9600
            .DataBits = 8
            .Parity = Parity.None
            .StopBits = StopBits.One
            .Handshake = Handshake.None
        End With
    End Sub

    Public Sub setPort(ByVal pPort As String)
        If myPort.IsOpen Then
            myPort.Close()
        End If

        myPort.PortName = pPort

        myPort.Open()
    End Sub

    Private Function getPort() As SerialPort
        If myPort.IsOpen = False Then
            myPort.Open()
        End If

        Return myPort
    End Function

   #Region "Zeit-Funktionen"
    Public Function setTime(ByVal pTime As Date) As String
        Dim port As SerialPort

        port = getPort()
        port.Write("*b" & Chr(pTime.Hour + 50) & Chr(pTime.Minute + 50) & Chr(pTime.Second + 50) & "#")

        Return getTime()
    End Function

    Public Function getTime() As String
        Dim ret As Integer
        Dim t As String = ""
        Dim port As SerialPort

        port = getPort()

        t = port.ReadExisting
        t = ""

        port.Write("*a#")

        ' Prefix der Antwort auslesen
        ret = port.ReadChar()
        If ret <> Asc("*") Then
            Debug.Print("Zeichen: " & Chr(ret))
        End If

        ' Nächstes Byte = Stunde
        ret = port.ReadChar()
        ret = ret - 50 ' Offset abziehen
        t = ret.ToString("00")

        ' Nächstes Byte = Minute
        ret = port.ReadChar()
        ret = ret - 50 ' Offset abziehen
        t = t & ":" & ret.ToString("00")

        ' Nächstes Byte = Sekunde
        ret = port.ReadChar()
        ret = ret - 50 ' Offset abziehen
        t = t & ":" & ret.ToString("00")

        Return t
    End Function

#End Region
End Class

Allerdigs setzt das schon ein wenig Kenntniss in VB voraus. Der Code definiert eine eigene Klasse für die Kommunikation mit dem COM-Port (bei mir defaultmäßig COM7). Die Implementierung als Singelton vereinfacht die spätere Verwendung der Klasse, da man dann nicht immer erst mühsam ein Objekt anlegen muss. Darüber hinaus sollte es auch nur eine einizige Objekt-Instanz geben, die mit der Schnittstelle kommuniziert .. .und auch das wird über das Singelton-Pattern gelöst.

Die new() Prozedur ist der sog. Konstruktor der Klasse. Dieser wird immer aufgerufen, wenn eine Objekt-Instanz aus der Klasse erzeugt wird. In diesem Konstruktor wird der Serielle Port initialisiert. Die hier verwendeten Werte sind mehr oder minder Standard.

Falls der Mikrocontroller mal nicht an COM7 sondern wo anders hängt, kann man das Programm mit Hilfe der setPort Methode auf einen anderen Port konfigurieren.

getPort liefert bei Bedarf das Port-Objekt

setTime zeigt Dir, wie Du eine Zeichenfolge an den Controller schicken kannst. Das Protokoll für die Kommunikation mit dem Controller muss man sich selbst überlegen. Ich hatte für mich festgelegt, dass *b am Beginn einer Zeichenfolge, die ich an den Controller schicke diesem mitteilt, dass die Uhrzeit gesetzt werden soll. Danach werden dann die Stunden, Minuten und Sekunden übertragen. Um Bytes in der Übertragung zu sparen hatte ich mich entschlossen, Charakter-Zeichen zu übertragen. Um dabei nicht in den Bereich der Steuerzeugen zu landen habe ich einen Offset von 50 addiert. Bei meiner Protokoll-Definition hatte ich noch festgelegt, dass jede Zeichenfolge durch das Senden eines Raute-Zeichens abgeschlossen wird. Das sind aber alles vollkommen willkürliche Festlegungen und Du musst für Deine Fälle halt selbst definieren, welche Daten wie ausgetauscht werden sollen.

Die getTime Methode zeigt dann, wie man aus der seriellen Schnittstelle lesen kann. Sollte noch irgendwelcher Müll im Eingangspuffer stehen, lese ich den erst mit ReadExisting aus und schmeiße ihn weg Danach schicke ich die Zeichenfolge "*a#" an den Controller. Das war gemäß meiner Definition die Aufforderung für den Controller, seine Uhrzeit zu übermitteln. Als Antwort schickt mir der Controller dann wieder drei Text-Zeichen, die ebenso wie bei setTime mit einem Offset von 50 versehen sind, um wieder aus dem Bereich der Steuerzeichen zu kommen. Um auf den korrekten Wert zu kommen muss man zuerst den ASCII Wert des Zeichens ermitteln und davon dann 50 abziehen. Der so ermittelte Wert des ersten Zeichens sind die Stunden, der des zweiten sind die Minuten und der des dritten die Sekunden.

Auch wenn der Code auf den ersten Blick recht lang wirkt - die einzelnen Prozeduren sind eigentlich verhältnismäßig kurz und sollten auch ohne große Inline-Kommentare schnell verdeutlichen, wie sie funktionieren. Die größte Schwierigkeit ist bei genauem Betrachten auch weniger die eigenliche Kommunikation zwischen Controller und PC sondern das Festlegen eines geeigneten Protokolls.

Im Prinzip geht es also nur darum, das Port-Objekt zuerst zu initialisieren und dann mit den geeigneten Read / Write Methoden mit dem Controller zu kommunizieren. Welche Methoden zur Verfügung stehen siehst Du hier: http://msdn.microsoft.com/de-de/libr...(v=vs.85).aspx Mehr braucht man für den Datentransfer auf PC Seite eigentlich nicht.