<?xml version="1.0" encoding="utf-8"?>
<feed xml:lang="en" xmlns="http://www.w3.org/2005/Atom"><title>Recent posts to ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/" rel="alternate"/><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/feed.atom" rel="self"/><id>https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/</id><updated>2020-02-28T17:25:42.907000Z</updated><subtitle>Recent posts to ProMod-Pro von Deltalogic</subtitle><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#77ff" rel="alternate"/><published>2020-02-28T17:25:42.907000Z</published><updated>2020-02-28T17:25:42.907000Z</updated><author><name>Michael Hulsch</name><uri>https://forge.codesys.com/u/michael-hulsch/</uri></author><id>https://forge.codesys.comec9d5a8bb1aa549a3edb1304d7bec3f4a237115c</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Ralph Holz hat geschrieben:&lt;/strong&gt;&lt;br/&gt;
Hallo Herr Hulsch,&lt;br/&gt;
Meinem Code Brauchen Sie übrigens nicht die Wortadresse der Symbolischen Variable zu übergeben sonder er bezieht sich immer auf Wort 0 des Speicherbereichs - d.h. nur wenn Sie auf Merker zugreifen wollten müssen %IW0 in %MW0 änderen, ansonsten greifen Sie diese Adresse niemals an.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;´&lt;/p&gt;
&lt;p&gt;Hallo auch mal,&lt;/p&gt;
&lt;p&gt;jetzt hab ich die Logik auch kapiert &lt;/p&gt;
&lt;p&gt;Alles klar, danke!&lt;/p&gt;
&lt;p&gt;Gruß&lt;/p&gt;
&lt;p&gt;Michael Hulsch&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#74b9" rel="alternate"/><published>2020-02-28T17:25:34.793000Z</published><updated>2020-02-28T17:25:34.793000Z</updated><author><name>Ralph Holz</name><uri>https://forge.codesys.com/u/ralph-holz/</uri></author><id>https://forge.codesys.come3b691345492a4a5abad0e65b4ac129000fb3e81</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;Hallo Herr Hulsch,&lt;/p&gt;
&lt;p&gt;ja ich hatte auch so meine Probleme mit der Bezeichnung BITADR und hätte hier auch etwas anderes erwartet.&lt;/p&gt;
&lt;p&gt;Meinem Code Brauchen Sie übrigens nicht die Wortadresse der Symbolischen Variable zu übergeben sonder er bezieht sich immer auf Wort 0 des Speicherbereichs - d.h. nur wenn Sie auf Merker zugreifen wollten müssen %IW0 in %MW0 änderen, ansonsten greifen Sie diese Adresse niemals an.&lt;/p&gt;
&lt;p&gt;Es liese sich daraus also relativ leicht eine universelle Funktion machen die als als Parameter nur die BITADR und den Wert übergeben bekommt den der Eingang annehmen soll. Die würde dann folgendermassen aufgerufen:&lt;/p&gt;
&lt;p&gt;SetInput(BITADR(xxx),TRUE) oder natürlich auch FALSE.&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#35f1" rel="alternate"/><published>2020-02-28T17:25:31.851000Z</published><updated>2020-02-28T17:25:31.851000Z</updated><author><name>Michael Hulsch</name><uri>https://forge.codesys.com/u/michael-hulsch/</uri></author><id>https://forge.codesys.com60a00e6ca91d90ec2539df250865d3c98142cb97</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Ralph Holz hat geschrieben:&lt;/strong&gt;&lt;br/&gt;
Hallo Herr Hulsch,&lt;br/&gt;
..&lt;br/&gt;
Meine Methode hat allerdings einen andere Ursache. Die Ein- und AugangsVariablen dürfen in meiner Simulation frei umverdrahtet werden.  Also in dem geposteten Beispielcode dürfen Sie für %IX24.3 jede beliebige Eingangsadresse verwenden und die dazugehörige Simulation funktioniert weiterhin korrekt. &lt;br/&gt;
Grüße&lt;br/&gt;
Ralph&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Hallo auch noch mal,&lt;/p&gt;
&lt;p&gt;da sie ja trotzdem die Adresse des Eingangswortes benötigen relativiert sich der Vorteil allerdings ziemlich. Was ist wenn ihr namentlich bekannter Eingang, zu dem sie eine Simulation schreiben möchten, auf verschieden Eingangsworten, also zum Beispiel auf verschiedenen Busteilnehmern liegen könnte? &lt;/p&gt;
&lt;p&gt;Für mich hätte die Funktion BITADR Sinn gemacht, wenn ich damit die "richtige" Adresse gehabt hätte, bzw. mir in irgend einer Form auch noch die "allgemeine" Wordadresse hätte ableiten können, alleine vom Bezeichner her.&lt;/p&gt;
&lt;p&gt;Also:&lt;/p&gt;
&lt;p&gt;ptrWordAdresse := ADR (bEinEingangsBoolean)&lt;/p&gt;
&lt;p&gt;ptrBitAdresse := BITADR (bEinEingangsBoolean)&lt;/p&gt;
&lt;p&gt;Verstehen sie was ich meine?&lt;/p&gt;
&lt;p&gt;Mit freundlichem Gruß&lt;/p&gt;
&lt;p&gt;Michael Hulsch&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#0c90" rel="alternate"/><published>2020-02-28T17:25:23.676000Z</published><updated>2020-02-28T17:25:23.676000Z</updated><author><name>Ralph Holz</name><uri>https://forge.codesys.com/u/ralph-holz/</uri></author><id>https://forge.codesys.comfd22b43bc8f0be5c34b0adee25f4d3a7b91cbdb5</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Michael Hulsch hat geschrieben:&lt;/strong&gt;&lt;br/&gt;
Hallo Herr Holz,&lt;br/&gt;
...&lt;br/&gt;
Was spricht gegen die einfache, direkte Lösung auf den Pointer mittels Bitoperator zuzugreifen?&lt;br/&gt;
...&lt;br/&gt;
 ptrToInput := ADR(%IW*)&lt;br/&gt;
 ptrToInput^.0 ... 15 := bSimulationswert;&lt;br/&gt;
...&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Hallo Herr Hulsch,&lt;/p&gt;
&lt;p&gt;jetzt habe ich wieder etwas gelernt man darf auch hinter dereferenzierten Pointern ".0 ... 15" schreiben. Man traut sich manchmal das Einfache nicht!&lt;/p&gt;
&lt;p&gt;Meine Methode hat allerdings einen andere Ursache. Die Ein- und AugangsVariablen dürfen in meiner Simulation frei umverdrahtet werden.  Also in dem geposteten Beispielcode dürfen Sie für %IX24.3 jede beliebige Eingangsadresse verwenden und die dazugehörige Simulation funktioniert weiterhin korrekt. &lt;/p&gt;
&lt;p&gt;Grüße&lt;/p&gt;
&lt;p&gt;Ralph&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#0166" rel="alternate"/><published>2020-02-28T17:25:20.745000Z</published><updated>2020-02-28T17:25:20.745000Z</updated><author><name>Michael Hulsch</name><uri>https://forge.codesys.com/u/michael-hulsch/</uri></author><id>https://forge.codesys.com47a2ef68c872aab6b58c89802456cd94bd147f88</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Ralph Holz hat geschrieben:&lt;/strong&gt;&lt;br/&gt;
Ich hatte genau das gleiche Problem bei einer Simulation auf Bit-Eingäge zu schreiben. Es lies sich mit den beiden Adressoperatoren (ADR + BITADR) und ein bischen Mathematik und Boolscher Logik lösen.&lt;br/&gt;
.&lt;br/&gt;
.&lt;br/&gt;
Grüße&lt;br/&gt;
Ralph&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Hallo Herr Holz,&lt;/p&gt;
&lt;p&gt;ihre Lösung sieht interessant aus, ist mir allerdings ein wenig zu kompliziert.&lt;/p&gt;
&lt;p&gt;Was spricht gegen die einfache, direkte Lösung auf den Pointer mittels Bitoperator zuzugreifen?&lt;/p&gt;
&lt;p&gt;Deklaration&lt;/p&gt;
&lt;p&gt;VAR&lt;/p&gt;
&lt;p&gt;ptrToInput : POINTER TO WORD;&lt;/p&gt;
&lt;p&gt;END_VAR&lt;/p&gt;
&lt;p&gt;Code:&lt;/p&gt;
&lt;p&gt;ptrToInput := ADR(%IW*)&lt;/p&gt;
&lt;p&gt;ptrToInput^.0 ... 15 := bSimulationswert;&lt;/p&gt;
&lt;p&gt;Grüße&lt;/p&gt;
&lt;p&gt;Michael Hulsch&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#d16e" rel="alternate"/><published>2020-02-28T17:25:12.873000Z</published><updated>2020-02-28T17:25:12.873000Z</updated><author><name>Ralph Holz</name><uri>https://forge.codesys.com/u/ralph-holz/</uri></author><id>https://forge.codesys.com205597838eacc52c77150a2592d2cd91dba6e342</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;Ich hatte genau das gleiche Problem bei einer Simulation auf Bit-Eingäge zu schreiben. Es lies sich mit den beiden Adressoperatoren (ADR + BITADR) und ein bischen Mathematik und Boolscher Logik lösen.&lt;/p&gt;
&lt;p&gt;Deklaration:&lt;/p&gt;
&lt;p&gt;VAR&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;ptAdr&lt;/span&gt;: &lt;span class="nv"&gt;POINTER&lt;/span&gt; &lt;span class="nv"&gt;TO&lt;/span&gt; &lt;span class="nv"&gt;WORD&lt;/span&gt;&lt;span class="c1"&gt;;&lt;/span&gt;

&lt;span class="nv"&gt;dwBitOffs&lt;/span&gt;: &lt;span class="nv"&gt;DWORD&lt;/span&gt;&lt;span class="c1"&gt;;&lt;/span&gt;

&lt;span class="nv"&gt;dwWordOffs&lt;/span&gt;: &lt;span class="nv"&gt;DWORD&lt;/span&gt;&lt;span class="c1"&gt;;&lt;/span&gt;

&lt;span class="nv"&gt;usiBitNr&lt;/span&gt;: &lt;span class="nv"&gt;USINT&lt;/span&gt;&lt;span class="c1"&gt;;&lt;/span&gt;

&lt;span class="nv"&gt;xValueToSet&lt;/span&gt;: &lt;span class="nv"&gt;BOOL&lt;/span&gt;&lt;span class="c1"&gt;;&lt;/span&gt;

&lt;span class="nv"&gt;xxx&lt;/span&gt; &lt;span class="nv"&gt;AT&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="nv"&gt;IX24&lt;/span&gt;.&lt;span class="mi"&gt;3&lt;/span&gt;: &lt;span class="nv"&gt;BOOL&lt;/span&gt;&lt;span class="c1"&gt;; (*Variable to set for example*)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;


&lt;p&gt;END_VAR&lt;/p&gt;
&lt;p&gt;Code:&lt;/p&gt;
&lt;p&gt;ptAdr := ADR(%IW0); (&lt;em&gt; %IW0 --&amp;gt; xxx= Input ; %QW0 --&amp;gt; xxx= Output ; %MW0 --&amp;gt; xxx = Marker&lt;/em&gt;)&lt;/p&gt;
&lt;p&gt;dwBitOffs := BITADR(xxx);&lt;/p&gt;
&lt;p&gt;ptAdr := ptAdr + (dwBitOffs / 8);&lt;/p&gt;
&lt;p&gt;usiBitNr:= DWORD_TO_USINT(dwBitOffs MOD 16); (&lt;em&gt; 8 if Byte Adressing&lt;/em&gt;)&lt;/p&gt;
&lt;p&gt;ptAdr^:=    ptAdr^&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;        &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;NOT&lt;/span&gt; &lt;span class="n"&gt;SHL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="n"&gt;usiBitNr&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;

        &lt;span class="k"&gt;OR&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;SHL&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;BOOL_TO_WORD&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;xValueToSet&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="n"&gt;usiBitNr&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;


&lt;p&gt;Grüße&lt;/p&gt;
&lt;p&gt;Ralph&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#e50a" rel="alternate"/><published>2020-02-28T17:25:09.651000Z</published><updated>2020-02-28T17:25:09.651000Z</updated><author><name>Michael Hulsch</name><uri>https://forge.codesys.com/u/michael-hulsch/</uri></author><id>https://forge.codesys.come1cf8b246b28289d5d78c748dfc24d0a427a0baa</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Frank Hailer hat geschrieben:&lt;/strong&gt;&lt;br/&gt;
Hallo Sven&lt;br/&gt;
Das ist von der CoDeSys Version unabhängig. Es gibt auf keine Zeiger auf Bits, der kleinste Zeiger zeigt auf ein Byte. BITADR liefert nur den Bit-Offset innerhalb eines DWord's. In Deinem Beispiel bekommt der Zeiger somit eine falsche Adresse und das führt zu einem Speicherüberschreiber.&lt;br/&gt;
Grüsse, Frank Hailer&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Ich stehe gerade in etwa vor dem gleichen Problem. Die Antwort beschreibt leider nur den Zustand, aber mir fehlt die Lösung, bzw. ich sehe den Sinn nicht von BITADR.&lt;/p&gt;
&lt;p&gt;Was möchte ich erreichen: ich will Eingänge der Peripherie mit einem Programm simulieren. Am bequemsten wäre es dazu einfach auf boolesche Eingänge schreibend zuzugreifen -&amp;gt; natürlich geht es auch anders, aber es wäre der bequemste Weg.&lt;/p&gt;
&lt;p&gt;Grüße&lt;/p&gt;
&lt;p&gt;Michael Hulsch&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#7384" rel="alternate"/><published>2020-02-28T17:25:06.743000Z</published><updated>2020-02-28T17:25:06.743000Z</updated><author><name>Anonymous</name><uri>https://forge.codesys.com/u/*anonymous/</uri></author><id>https://forge.codesys.comd72706c7c3bb6df1731d85da39df4e516ca0ff5c</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;&lt;em&gt;Originally created by:&lt;/em&gt; Frank Hailer&lt;/p&gt;
&lt;p&gt;Hallo Sven&lt;/p&gt;
&lt;p&gt;Das ist von der CoDeSys Version unabhängig. Es gibt auf keine Zeiger auf Bits, der kleinste Zeiger zeigt auf ein Byte. BITADR liefert nur den Bit-Offset innerhalb eines DWord's. In Deinem Beispiel bekommt der Zeiger somit eine falsche Adresse und das führt zu einem Speicherüberschreiber.&lt;/p&gt;
&lt;p&gt;Grüsse, Frank Hailer&lt;/p&gt;&lt;/div&gt;</summary></entry><entry><title>ProMod-Pro von Deltalogic</title><link href="https://forge.codesys.com/forge/talk/Deutsch/thread/c9882be2af/?limit=25#0fe7" rel="alternate"/><published>2020-02-28T17:24:58.809000Z</published><updated>2020-02-28T17:24:58.809000Z</updated><author><name>sven1978</name><uri>https://forge.codesys.com/u/sven1978/</uri></author><id>https://forge.codesys.com2f2836a5ad1f7e523fb22a86ba36b8f8c6e78c48</id><summary type="html">&lt;div class="markdown_content"&gt;&lt;p&gt;Hallo&lt;/p&gt;
&lt;p&gt;Ich arbeite erst seit kurzem mit Codesys. Um nun ein wenig zu spielen benutze ich dafür von DeltaLogic ProMod-Pro. Jetzt habe ich aber dor Probleme mit Pointer auf Ausgänge.&lt;/p&gt;
&lt;p&gt;Kann das sein daß man mit ProMod Pro keine Pointer auf Ausgänge setzten kann ? ( Schreibener Zugriff )&lt;/p&gt;
&lt;div class="codehilite"&gt;&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;Var&lt;/span&gt;&lt;span class="err"&gt; &lt;/span&gt; &lt;span class="k"&gt;AT&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt;&lt;span class="n"&gt;IX24&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;BOOL&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;....&lt;/span&gt;
&lt;span class="n"&gt;pt&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;POINTER&lt;/span&gt; &lt;span class="k"&gt;TO&lt;/span&gt; &lt;span class="n"&gt;BOOL&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="n"&gt;pt&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;BITADR&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Var&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="n"&gt;pt&lt;/span&gt;&lt;span class="o"&gt;^&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;TRUE&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="c1"&gt;-- Fehler ? &lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;

&lt;/div&gt;</summary></entry></feed>