Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 1 von 4 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 37

Thema: Beckhoff TwinCat ADS OCX und VB.net

  1. #1
    Registriert seit
    20.04.2007
    Beiträge
    81
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo,

    ich möchte in dem bei VS 2005 enthaltenem Visual Basic eine Softwäre für einen Beckhoff Industrie PC entwickeln. Dabei war eine Möglichkeit unter VB6 mit TwinCat eine dauerhafte Verbindung zwischen einer Variable und VB herzustellen das

    CALL adsocx1.adsreadintegerconnect(blabla)

    dies funktioniert zwar bei VB.net ebenfalls, allerdings wird die Variable nur einmal Aktualisiert und dann bleibt der Wert für alle Ewigkeit bestehen, auch wenn sich der Wert in TwinCat SystemManager ändert.

    Hat dafür jemand eine Lösung

    die "Connectete" Variable wird mittels eines Timers alle 50ms an zB
    me.lblTest.Text = var1 übergeben

    Aber wie gesagt die var1, welche Connected wurde wird nur bei Form Load geschrieben und dann nie wieder.

    MFG
    Parallax
    Zitieren Zitieren Beckhoff TwinCat ADS OCX und VB.net  

  2. #2
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Das OCX-Ding ist veraltet. Bei jeder TwinCat-Demo ist auch ein .Net2.0 Interface dabei. Ich poste hier mal ein paar Klassen, die ich so verbrochen habe:

    In Arbeit

  3. #3
    Registriert seit
    20.04.2007
    Beiträge
    81
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Danke für die Info....

    nun allerdings noch eine paar kleine bitten

    also....

    so etwas ähnliches hab ich mir schon gedacht, allerdings kann ich auf Beckhoff.de keine neue version von dem OCX teil finden geschweige den wie man dass einbindet


    könntest du mir bitte einen Link geben, damit ich mir das neuste ziehen kann...

    zweites Problem:


    also ich hab ein Form...
    dieses Form enthält eine Klasse, nämlich
    Public Class frmMain

    wo genau muss ich da nun was hinschreiben und was genau bedeutet das was ich da schreibe...^^

    könntest du mir bitte anhand eines Beispiels erklären wir ich eine Integervariable (ich benutze in der regel die Addresse nach folgendem Schema: 61741,0,2,usw...) connectet und dann diesen wert in einer variable überträgt...


    vielen dank für die anstrengung

    mfg
    Parallax

  4. #4
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Also OCX ist out und .Net-Interface wird von Beckhoff geliefert. Hier ein Bsp.

    Ankopplung Klasse Teil 1:

    Code:
    Public Delegate Sub EventChangedVar(ByVal sender As Object, ByVal e As PLCVariableChangedEventArg)
    Public Delegate Sub AsyncChangeEvent(ByRef v As System.Collections.Generic.List(Of PLCVarPoolElement))
    
    Public Class PLCBase
    
        Private PLCThread As Thread
        Private prioA_thread As Thread
        Private prioB_thread As Thread
        Private prioC_thread As Thread
        Private RunThreads As Boolean
    
        Private timeA As Integer = 500
        Private timeB As Integer = 2000
        Private timeC As Integer = 4000
        Private timePLC As Integer = 500
    
        Private tcADS As TcAdsClient
        Private ADSAdress As String
        Private ADSPort As Integer
        Private ADSTimeout As Integer = 100
        Private ADSConnectState As ADSConnectState
        Private ADSState As TwinCAT.Ads.AdsState
    
        Private State As String
    
        Private VarDic As System.Collections.Generic.Dictionary(Of String, PLCVarPoolElement)
    
        Public Event OnPLCVarChange As PLCVarChangeHandler
        Public Event OnPLCConnectMsg As PLCConnectMsgHandler
    
        Private lock As New Object()
    
    
    
        Public Sub New(ByVal ADSAdress As String, ByVal ADSPort As Integer)
            MyBase.New()
            Me.ADSAdress = ADSAdress
            Me.ADSPort = ADSPort
            VarDic = New System.Collections.Generic.Dictionary(Of String, PLCVarPoolElement)
        End Sub
    
        Public Sub New(ByVal ADSAdress As String, ByVal ADSPort As Integer, ByVal Timeout As Integer)
            MyBase.New()
            Me.ADSAdress = ADSAdress
            Me.ADSPort = ADSPort
            Me.ADSTimeout = Timeout
            VarDic = New System.Collections.Generic.Dictionary(Of String, PLCVarPoolElement)
        End Sub
    
        Public Sub AddPLCVar(ByVal name As String, ByVal path As String, ByVal type As PLCType, ByVal timeclass As PLCTimeClass, Optional ByVal size As Integer = 1)
            VarDic.Add(name, New PLCVarPoolElement(name, path, type, timeclass, size))
        End Sub
    
    
        Protected Sub GetPLCVars()
            For Each element As PLCVarPoolElement In Me.VarDic.Values
                Dim var As PLCVariable
                Select Case element.PLCType
                    Case PLCType.PLCArrayInteger
                        var = New PLCVarArrayInteger(Me, element.PLCPath, element.PLCSize, element.PLCTimeClass)
                    Case PLCType.PLCArrayUInteger
                        var = New PLCVarArrayUInteger(Me, element.PLCPath, element.PLCSize, element.PLCTimeClass)
                    Case PLCType.PLCBoolean
                        var = New PLCVarBoolean(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCDate
                        var = New PLCVarDate(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCDInteger
                        var = New PLCVarDInteger(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCUDInteger
                        var = New PLCVarUDInteger(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCInteger
                        var = New PLCVarInteger(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCUInteger
                        var = New PLCVarUInteger(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCDouble
                        var = New PLCVarDouble(Me, element.PLCPath, element.PLCTimeClass)
                    Case PLCType.PLCString
                        var = New PLCVarString(Me, element.PLCPath, element.PLCSize, element.PLCTimeClass)
                    Case Else
                        'var = Nothing
                        Throw New PLCException("PLC type is not implementet!")
                End Select
                element.PLCVariable = var
            Next
        End Sub
    
        Private Sub DropPLCVars()
            For Each element As PLCVarPoolElement In Me.VarDic.Values
                Try
                    If Not (element.PLCVariable Is Nothing) Then
                        element.PLCVariable.Dispose()
                        element.PLCVariable = Nothing
                    End If
                Catch ex As Exception
                End Try
            Next
        End Sub
    
    
        Protected Sub Connect()
            Me.tcADS = New TcAdsClient()
            Me.tcADS.Synchronize = True
            Me.tcADS.Connect(Me.ADSAdress, Me.ADSPort)
            Me.tcADS.Timeout = ADSTimeout
            AddHandler tcADS.AdsStateChanged, AddressOf AdsStateChangedEventHandler
        End Sub
    
        Protected Sub Disconnect()
            Try
                If Not (Me.tcADS Is Nothing) Then
                    SyncLock Me.tcADS
                        Me.tcADS.Dispose()
                        Me.tcADS = Nothing
                    End SyncLock
                End If
            Catch ex As TwinCAT.Ads.AdsException
    
            End Try
        End Sub
    
        Private Sub SendConnectMsg(ByVal msg As String)
            RaiseEvent OnPLCConnectMsg(Me, New PLCConnectMessageEventArg(msg))
        End Sub
    
    
        Private Sub PLCVarsRead(ByVal type As PLCTimeClass)
    
    
            Dim vars As System.Collections.Generic.List(Of PLCVarPoolElement) = New System.Collections.Generic.List(Of PLCVarPoolElement)
            SyncLock lock
    
                For Each element As PLCVarPoolElement In VarDic.Values
                    If element.PLCTimeClass = type Then
                        Try
                            element.PLCVariable.Read()
                            If element.PLCVariable.Changed() Then
                                vars.Add(element)
                            End If
                        Catch ex As Exception
                            MsgBox(ex.Message.ToString)
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCleanUp
                            Return
                        End Try
                    End If
                Next
            End SyncLock
            If vars.Count > 0 Then
                RaiseEvent OnPLCVarChange(Me, New PLCVariableChangedEventArg(vars))
            End If
        End Sub
    
        Private Sub PLCVarsRead2(ByVal type As PLCTimeClass)
    
    
            Dim vars As System.Collections.Generic.List(Of PLCVarPoolElement) = New System.Collections.Generic.List(Of PLCVarPoolElement)
            SyncLock lock
    
                For Each element As PLCVarPoolElement In VarDic.Values
                    If element.PLCTimeClass = type Then
                        Try
                            element.PLCVariable.Read()
                            vars.Add(element)
                        Catch ex As Exception
                            MsgBox(ex.Message.ToString)
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCleanUp
                            Return
                        End Try
                    End If
                Next
            End SyncLock
            If vars.Count > 0 Then
                RaiseEvent OnPLCVarChange(Me, New PLCVariableChangedEventArg(vars))
            End If
        End Sub
    
    
        Private Sub ADSCleanUp()
            DropPLCVars()
            Disconnect()
        End Sub
    Geändert von drfunfrock (09.04.2008 um 15:42 Uhr)
    Zitieren Zitieren Teil1  

  5. #5
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Ankopplung Teil2

    Code:
        Private Sub ConnectStateMachine()
            While True
                Select Case Me.ADSConnectState
                    Case BECKADS2.ADSConnectState.ADSInitialize
                        SendConnectMsg("Initialize " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Me.ADSConnectState = BECKADS2.ADSConnectState.ADSTryConnectToPLC
                        If Not RunThreads Then
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                        End If
    
                    Case BECKADS2.ADSConnectState.ADSTryConnectToPLC
                        SendConnectMsg("Connecting " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Try
                            Connect()
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSWaitOnRun
                        Catch ex As TwinCAT.Ads.AdsException
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSTryConnectToPLC
                        End Try
                        If (Not RunThreads) Then
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                        End If
    
                    Case BECKADS2.ADSConnectState.ADSWaitOnRun
                        SendConnectMsg("Check for PLC-state RUN at " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Try
                            If Me.ADSClient.ReadState().AdsState = TwinCAT.Ads.AdsState.Run Then
                                Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCheckPLCProgram
                            End If
                        Catch ex As TwinCAT.Ads.AdsException
                            Disconnect()
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSTryConnectToPLC
                        End Try
                        If (Not RunThreads) Then
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                        End If
    
                    Case BECKADS2.ADSConnectState.ADSCheckPLCProgram
                        SendConnectMsg("Check for PLC-program at " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Try
                            Dim plc_version As New PLCVarString(Me, ".VERSION", 1)
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnectFields
                            plc_version.Dispose()
                        Catch ex As TwinCAT.Ads.AdsException
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCheckPLCProgram
                        End Try
                        If (Not RunThreads) Then
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                        End If
    
                    Case BECKADS2.ADSConnectState.ADSConnectFields
                        SendConnectMsg("Connecting PLC vars at " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Try
                            Me.GetPLCVars()
                            Dim plc_version As New PLCVarString(Me, ".VERSION", 50)
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnectFields
                            plc_version.Dispose()
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnected
    
                        Catch ex As TwinCAT.Ads.AdsException
                            Me.DropPLCVars()
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCheckPLCProgram
                        End Try
                        If (Not RunThreads) Then
                            Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                        End If
    
                    Case BECKADS2.ADSConnectState.ADSConnected
                        SendConnectMsg("Connected at " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        SyncLock Me.lock
                            If Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnected Then
                                Try
                                    If Me.ADSClient.ReadState().AdsState <> TwinCAT.Ads.AdsState.Run Then
                                        Me.ADSConnectState = BECKADS2.ADSConnectState.ADSWaitOnRun
                                        Me.DropPLCVars()
                                    End If
                                Catch ex As TwinCAT.Ads.AdsException
                                    Me.ADSConnectState = BECKADS2.ADSConnectState.ADSCleanUp
                                End Try
                            End If
                            If (Not RunThreads) Then
                                Me.ADSConnectState = BECKADS2.ADSConnectState.ADSExit
                            End If
                        End SyncLock
    
                    Case BECKADS2.ADSConnectState.ADSCleanUp
                        SendConnectMsg("Clean up " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Me.ADSCleanUp()
                        Me.ADSConnectState = BECKADS2.ADSConnectState.ADSTryConnectToPLC
    
                    Case BECKADS2.ADSConnectState.ADSExit
                        SendConnectMsg("Closed " + Me.ADSAdress.ToString + ":" + Me.ADSPort.ToString)
                        Me.ADSCleanUp()
                        Exit While
                End Select
                Thread.Sleep(timePLC)
            End While
        End Sub
        Private Sub thread_a()
            While RunThreads
                If Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnected Then
                    Me.PLCVarsRead(PLCTimeClass.A)
                End If
                Thread.Sleep(timeA)
            End While
        End Sub
    
        Private Sub thread_b()
            While RunThreads
                If Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnected Then
                    Me.PLCVarsRead(PLCTimeClass.B)
                End If
                Thread.Sleep(timeB)
            End While
        End Sub
    
        Private Sub thread_c()
            While RunThreads
                If Me.ADSConnectState = BECKADS2.ADSConnectState.ADSConnected Then
                    Me.PLCVarsRead(PLCTimeClass.C)
                End If
                Thread.Sleep(timeC)
            End While
        End Sub
    
        Public Sub AdsStateChangedEventHandler(ByVal sender As Object, ByVal e As TwinCAT.Ads.AdsStateChangedEventArgs)
            Me.ADSState = e.State.AdsState
            Select Case Me.ADSState
                Case ADSState.Config
                Case ADSState.Error
                Case ADSState.Init
                Case ADSState.Invalid
                Case ADSState.LoadConfig
                Case ADSState.PowerFailure
                Case ADSState.PowerGood
                Case ADSState.Reconfig
                Case ADSState.Reset
                Case ADSState.Resume
                Case ADSState.Run
                Case ADSState.SaveConfig
                Case ADSState.Shutdown
                Case ADSState.Start
                Case ADSState.Stop
                Case ADSState.Suspend
            End Select
        End Sub
    
        Public Sub StartThreads()
            RunThreads = True
            Me.PLCThread = New Thread(AddressOf ConnectStateMachine)
            Me.PLCThread.Priority = ThreadPriority.Normal
            Me.PLCThread.IsBackground = True
            Me.PLCThread.Start()
    
            Me.prioA_thread = New Thread(AddressOf thread_a)
            Me.prioA_thread.Priority = ThreadPriority.BelowNormal
            Me.prioA_thread.IsBackground = True
            Me.prioA_thread.Start()
    
            Me.prioB_thread = New Thread(AddressOf thread_b)
            Me.prioB_thread.Priority = ThreadPriority.Lowest
            Me.prioB_thread.IsBackground = True
            Me.prioB_thread.Start()
    
            Me.prioC_thread = New Thread(AddressOf thread_c)
            Me.prioC_thread.Priority = ThreadPriority.Lowest
            Me.prioC_thread.IsBackground = True
            Me.prioC_thread.Start()
    
        End Sub
    
        Public Sub StopThreads()
            RunThreads = False
            Me.prioA_thread.Join()
            Me.prioB_thread.Join()
            Me.prioC_thread.Join()
            Me.PLCThread.Join()
        End Sub
    
    
        Public Sub SetTimes(ByVal timeA As Integer, ByVal timeB As Integer, ByVal timeC As Integer, ByVal timePLC As Integer)
            Me.timeA = timeA
            Me.timeB = timeB
            Me.timeC = timeC
            Me.timePLC = timePLC
        End Sub
    
    #Region "Properties"
        Public Property Adress() As String
            Get
                Return ADSAdress
            End Get
            Set(ByVal Value As String)
                ADSAdress = Value
            End Set
        End Property
    
        Public Property Port() As Integer
            Get
                Return ADSPort
            End Get
            Set(ByVal Value As Integer)
                ADSPort = Value
            End Set
        End Property
    
        Public ReadOnly Property ADSClient() As TcAdsClient
            Get
                Return Me.tcADS
            End Get
        End Property
    
        Public Property Timeout() As Integer
            Get
                Return ADSTimeout
            End Get
            Set(ByVal Value As Integer)
                ADSTimeout = Value
            End Set
        End Property
    
        Public ReadOnly Property ConnectState() As ADSConnectState
            Get
                Return Me.ADSConnectState
            End Get
        End Property
    
        Public ReadOnly Property PLCVar(ByVal name As String) As PLCVariable
            Get
                Return Me.VarDic.Item(name).PLCVariable
            End Get
        End Property
    
        Private ReadOnly Property PoolElements() As System.Collections.Generic.Dictionary(Of String, PLCVarPoolElement)
            Get
                Return Me.VarDic
            End Get
        End Property
    
        Public ReadOnly Property IsRunning() As Boolean
            Get
                Return Me.RunThreads
            End Get
        End Property
    
    #End Region
    
    End Class
    Zitieren Zitieren Teil2  

  6. #6
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Basisklasse zu den Variablen

    Code:
    Public Class PLCVariable
        Implements IDisposable
        Private mConnect As Boolean = False
        Protected VarPath As String
        Protected hVar As Integer = 0
        Protected adsStream As AdsStream
        Protected adsClient As TcAdsClient
        Protected VarSize As Integer
        Protected VarTimeClass As PLCTimeClass
    
    
        Public Sub New(ByRef connect As PLCBase, ByVal VarPath As String, ByVal Size As Integer, Optional ByVal timeclass As PLCTimeClass = KitronADS2.PLCTimeClass.X)
            MyBase.New()
    
            Me.adsClient = connect.ADSClient
            Me.Path = VarPath
            Me.VarSize = Size
            Me.TimeClass = timeclass
    
            Try
                Me.adsStream = New AdsStream(VarSize)
            Catch ex As Exception
                MessageBox.Show(ex.Message)
            End Try
    
            Me.Connect()
        End Sub
    
        Public Sub Connect()
            Try
                adsClient.ReadState()
                Me.hVar = adsClient.CreateVariableHandle(VarPath)
                Me.mConnect = True
            Catch ex As Exception
                Me.mConnect = False
            End Try
        End Sub
    
        Public Overridable Sub Read()
            If (Not Me.Connected) Then
                Throw New PLCException("Connection to " + Me.VarPath + " broken")
            End If
        End Sub
    
        Public Overridable Sub Write()
        End Sub
    
        Public Overridable Function Changed() As Boolean
            Return True
        End Function
    
        Public Overloads Sub Dispose() Implements IDisposable.Dispose
            Me.adsStream.Close()
            Me.adsStream.Dispose()
            Me.adsStream = Nothing
            adsClient.DeleteVariableHandle(Me.hVar)
            ' Take yourself off of the finalization queue
            ' to prevent finalization code for this object
            ' from executing a second time.
            GC.SuppressFinalize(Me)
        End Sub
    
    
        Public Property Path() As String
            Get
                Return Me.VarPath
            End Get
            Set(ByVal value As String)
                Me.VarPath = value
            End Set
        End Property
    
        Public ReadOnly Property Handle() As Integer
            Get
                Return hVar
            End Get
        End Property
    
        Public ReadOnly Property Stream() As AdsStream
            Get
                Return adsStream
            End Get
        End Property
    
        Public ReadOnly Property Size() As Integer
            Get
                Return VarSize
            End Get
        End Property
    
        Public ReadOnly Property Connected() As Boolean
            Get
                Dim succ As Boolean = True
                Try
                    Me.adsClient.ReadState()
                Catch ex As Exception
                    succ = False
                End Try
                Return succ And Me.mConnect
            End Get
        End Property
    
        Public Property TimeClass()
            Get
                Return Me.VarTimeClass
            End Get
            Set(ByVal value)
                Me.VarTimeClass = value
            End Set
        End Property
    
    End Class
    Konkrete Variablenklasse

    Code:
    Public Class PLCVarInteger
        Inherits PLCVariable
        Private value As Int16
        Private oldvalue As Int16
    
        Public Sub New(ByRef connect As PLCBase, ByVal Path As String, Optional ByVal timeclass As PLCTimeClass = PLCTimeClass.X)
            MyBase.New(connect, Path, 2, timeclass)
        End Sub
    
    
        Public Overrides Sub Read()
            Dim reader As AdsBinaryReader
            MyBase.Read()
    
            reader = New AdsBinaryReader(Me.Stream)
            Me.adsClient.Read(Me.hVar, Me.adsStream)
            Me.adsStream.Position = 0
            oldvalue = value
            Me.value = reader.ReadInt16()
            reader = Nothing
        End Sub
    
        Public Overrides Sub Write()
            Dim writer As AdsBinaryWriter
            MyBase.Write()
            writer = New AdsBinaryWriter(Me.adsStream)
            Me.adsStream.Position = 0
            writer.Write(CType(Me.value, Int16))
            Me.adsClient.Write(Me.hVar, Me.adsStream)
            writer = Nothing
        End Sub
    
        Public Overrides Function Changed() As Boolean
            Return (oldvalue <> value)
        End Function
    
        Public Property val() As Int16
            Get
                Return Me.value
            End Get
            Set(ByVal Value As Int16)
                Me.value = Value
            End Set
        End Property
    
    End Class

    Code:
    Public Delegate Sub PLCDelegateStringCallback(ByVal [text] As String)
    Public Delegate Sub PLCDelegateIntegerCallback(ByVal [integer] As Integer)
    Public Delegate Sub PLCDelegateUIntegerCallback(ByVal [uint] As UInteger)
    Public Delegate Sub PLCDelegateBooleanCallback(ByVal [boolean] As Boolean)
    Zitieren Zitieren Teil3  

  7. #7
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Das ganze ist vor 2 Jahren entstanden und ich bin nicht wirklich zufrieden, weil die Klasse von aufgerufnene Delegates mit .Net2 nicht herausbekomme. Somit muss ich im Programm immer noch folgende Konstruktion haben:


    Code:
      Public Sub VariableChanged(ByVal sender As Object, ByVal e As PLCVariableChangedEventArg)
            For Each field As PLCVarPoolElement In e.fields
                Select Case field.PLCVarName
                    Case "version"
                        Dim d As New BECKADS2.PLCDelegateStringCallback(AddressOf PLC_DispatchVersion)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarString).val})
                    Case "st01_carisin"
                        Dim d As New BECKADS2.PLCDelegateBooleanCallback(AddressOf PLC_DispatchCarIsIn)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarBoolean).val})
                    Case "st01_carinit"
                        Dim d As New BECKADS2.PLCDelegateBooleanCallback(AddressOf PLC_DispatchCarInit)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarBoolean).val})
                    Case "st01_carstatus"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchCarStatus)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarInteger).val})
                    Case "output"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchOutput)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarInteger).val})
                    Case "input"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchInput)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarInteger).val})
                    Case "st01_yield"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchST01Yield)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarDInteger).val})
                    Case "st03_yield"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchST03Yield)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarDInteger).val})
                    Case "st05_yield"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchST05Yield)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarDInteger).val})
                    Case "st07_yield"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchST07Yield)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarDInteger).val})
                    Case "st08_yield"
                        Dim d As New BECKADS2.PLCDelegateIntegerCallback(AddressOf PLC_DispatchST08Yield)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarDInteger).val})
                    Case "st01_labelcode"
                        Dim d As New BECKADS2.PLCDelegateStringCallback(AddressOf PLC_DispatchST01LabelCode)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarString).val})
                    Case "st02_i_dontsolder"
                        Dim d As New BECKADS2.PLCDelegateBooleanCallback(AddressOf PLC_DispatchSoldering)
                        Me.Invoke(d, New Object() {CType(field.PLCVariable, PLCVarBoolean).val})
    
                    Case Else
                        Me.StatusStrip.Items("errormsg").Text = "unknown PLC variable:" + field.PLCVarName
                End Select
            Next
        End Sub
    Dazu habe ich Beckhoff misstraut und selbst Events bei Änderungen implementiert und das ist Müll.


    Nun ja, die Initialisierung ist einfach:

    Code:
    Private Sub PLC_Init()
            Try
                Me.PLC_base = New BECKADS2.PLCBase(My.Settings.ADSNetID, My.Settings.ADSNetPort)
                AddHandler Me.PLC_base.OnPLCVarChange, AddressOf Me.VariableChanged
                AddHandler Me.PLC_base.OnPLCConnectMsg, AddressOf Me.StatusChanged
                AddFields()
                PLC_base.StartThreads()
            Catch ex As Exception
                MsgBox(ex.Message.ToString, MsgBoxStyle.Critical, "Critical failure in PLC_init!")
                PLC_base = Nothing
            End Try
        End Sub
    
    
        Private Sub PLC_Destroy()
            If Not (Me.PLC_base Is Nothing) Then
                PLC_base.StopThreads()
                PLC_base = Nothing
            End If
        End Sub
    
        Private Sub AddFields()
            PLC_base.AddPLCVar("version", ".Version", PLCType.PLCString, PLCTimeClass.C, 50)
            PLC_base.AddPLCVar("Var01", ".ST1.var01", PLCType.PLCBoolean, PLCTimeClass.A)
        End Sub
    Zitieren Zitieren Teil4  

  8. #8
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard

    Ach ja, die Bibliothe ist nicht vollständig, so wie ich die gepostet habe. Es ist nur als Implementierungsbeispiel gedacht.

  9. #9
    Registriert seit
    20.04.2007
    Beiträge
    81
    Danke
    2
    Erhielt 0 Danke für 0 Beiträge

    Standard

    ähm.... ja

    danke für die viele mühe nur die sache ist das ich seit ungefähr 2 monaten mit VB 2005 arbeite... daher hab ich von dem ganzen klassenzeugs und so keine ahnung... also das was mein stand ist, ist dass ich ein Steuerelement platziere, meine adresse eingeb und dann unter Form_Load einfach und bescheiden

    Call AdsOcx1.AdsReadIntegerConnect(Gruppe,Offset,Länge,Art,Time, "Var")

    schreib und dann meinen Wert hab....

    so wie deine beispiele aussehen scheint das so als kann ich diese easy und ständig funtionale methode vergessen und darf mich nun durch kiloweise klassen und dämliches VB 2005 kämpfen...

    ich frag mich warum man net einfach alles so lassen kann wie es gut war sondern nun son gewirr einführen muss....

    aber scheinbar gehts ja wohl net anders

    aber danke für die vielen beispiele die ich irgendwann 2010 mal alle verstehen werd...

    mfg
    Parallax

  10. #10
    Registriert seit
    14.08.2004
    Beiträge
    824
    Danke
    45
    Erhielt 73 Danke für 66 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Wenn du das nicht objektorientiert implementierst, dann bekommst du Probleme bei Verbindungsabrüchen und zwar ganz massive. Du musst nach einem Verbindungsabbruch, also einem Fehler in der Kommunikation ALLE Ressourcen wieder freigeben, sonst blockiert der PC sehr schnell und du darfst rebooten. Die Arbeit lohnt sich in jedem Falle.

    Meine Idee dahinter war, dass ich eine Verbindung aufbaue und alle Variablen, die ich connecte, in einer Liste sammle, damit ich bei einem Fehler alles elegant und schnell freigeben kann. So ein Fehler kann überall auftreten. Ohne Exceptions wird das zum Alptraum eines Programmierers.

Ähnliche Themen

  1. Beckhoff Twincat
    Von AdrianS im Forum CODESYS und IEC61131
    Antworten: 11
    Letzter Beitrag: 09.01.2012, 19:33
  2. Beckhoff Twincat Symbolik
    Von Anaconda55 im Forum CODESYS und IEC61131
    Antworten: 11
    Letzter Beitrag: 01.10.2008, 09:35
  3. Begriffsdefinition Beckhoff TwinCat
    Von MSB im Forum CODESYS und IEC61131
    Antworten: 4
    Letzter Beitrag: 27.03.2008, 20:21
  4. Zykluszeitproblem mit Beckhoff/Twincat
    Von andimann im Forum CODESYS und IEC61131
    Antworten: 3
    Letzter Beitrag: 09.01.2008, 15:55
  5. ? -> TwinCAT mit Beckhoff NOV/DP-RAM
    Von Kurt im Forum Sonstige Steuerungen
    Antworten: 1
    Letzter Beitrag: 29.09.2005, 13:27

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •