Komischer (Compiler) Fehler bei WORD-Variablen

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Komischer (Compiler) Fehler bei WORD-Variablen

      Moin, Moin Zusammen,

      für eine Impulsmessung verwende ich den TIMER1 zusammen mit einem ICP. Und dann rechne ich mit den Zählerständen des Input Capture Register (ICP) weiter.
      Dazu verwende ich folgende Definitionen:

      Quellcode

      1. Dim CaptArray(11) As Word
      2. Dim tempICR1 As Word ' Messpuffer ICP-ISR
      3. Dim wTmp As Word
      4. '### wirft Fehlermeldung ###
      5. wTmp = 10 - 65532
      6. '### funktioniert ##########
      7. tempICR1 = 10
      8. wTmp = 65532
      9. CaptArray(1) = tempICR1 - wTmp
      Alles anzeigen

      Die Fehlermeldung lautet:

      Quellcode

      1. Error : 51 Line : 109 value doesn't fit into WORD , in File : C:\Projekte 2019\_IR-Receiver\ATTiny44 IR-Receiver -1.1.bas
      Gut möglich das der Compiler mit dem "- 65532" nicht klar kommt, aber der Zahlenbereich ist ja ist WORD definiert...
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • Der Compiler mag offenbar keine Zuweisung von negativen Zahlen in dafür nicht vorgesehene Variablen.
      Der Meckert auch bei W=-10 wenn W eine Wordvariable ist.
      So wie es aussieht, rechnet der Compiler das Zuweisungsergebnis welches aus zwei Konstanten besteht aus und kann dann eben das so negative Ergebnis nicht zuweisen.
      Was anderes ist der Fall, dass das Ergebnis aus entsprechenden Variablen und Konstanten besteht. Dann kommt es zu den entsprechenden Unter- oder Überläufen und das Ergebnis kann auch fehlerfrei zugewiesen werden,
      z.B.:
      W=10
      W=W-65532
    • Ist alles nicht ganz leicht zu durchschauen. Ich denke, es hängt mit der internen Umsetzung zusammen.
      das
      Dim A As Word
      Dim B As Word
      B = 65000
      A = 10 - B
      gibt keinen Fehler,
      das
      Dim A As Word
      Dim B As Word
      B = 10
      A = B - 65000
      auch nicht,
      das
      Dim A As Word
      Dim B As Word
      B = 10
      A = 10 - 65000
      gibt den Fehler, also das Rechnen mit 2 Konstanten.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Michael schrieb:

      Den Fehler dem Compiler zuzuschreiben ist immer leicht gesagt.
      Aber alle Verrenkungen des Programmiererhirns kann der Compiler nicht vorraussehen.
      Nee, der Wertebereich der Variablen ist definiert - keine Vorzeichen.

      Denn folgender Ausdruck wirft kein Fehler, trotz des Kommas:

      Quellcode

      1. Dim wTmp As WORD
      2. wTmp = 10/1.01



      Wenn es Unschärfen gibt, dann gehört das ins Manual des Compilers.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • monkye schrieb:

      Wenn es Unschärfen gibt, dann gehört das ins Manual des Compilers.
      Meines Wissens steht im Manual des Compilers der Wertebereich einer Word Variable.
      Es ist aber allgemein bekannt, dass Word von 0 bis 2^16-1 geht.
      Der Compiler nimmt vermutlich die aktuelle Variable als Rechenpartner, ohne temporäre Variable, spart Speicher.
      Beim Compilieren stellt er fest, dass der Wert nicht in den Wertebereich passt und meckert zu recht.
      Ich sehe da kein Problem und eine Lösung kennst du ja jetzt.
      Wenn es andersherum wäre, würde es sicher auch jemanden geben, der daran Anstoss nimmt.
    • monkye schrieb:

      wTmp = 10/1.01
      das passt ja auch in ein word.
      ein -10/1.01 wäre negativ > Fehler, genauso wie ein 10/-1.01, auch Fehler. Wenn du -10/100 rechnest, gibt's keinen Fehler, weil die Nachkommas weg fallen und eine negative 0 gibt's nicht.
      Das sind ja alles Konstanten, und das Ergebnis wird beim compilieren gleich gerechnet. Rechnet man mit Variablen, dann wird es zur Laufzeit gerechnet, und dann kann ja keine Fehlermeldung mehr abgesondert werden.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Mit der Angabe "1.01" ist eine Fließkommazahl gemeint - da mault der Compiler auch nicht.

      Und "-" ist der Operator, hier Subtraktion. Verstanden hätte ich es bei (was der Compiler aber nicht kann):

      Quellcode

      1. Dim wTmp As WORD
      2. wTmp = 10 - (-65532)
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • du kannst zur Laufzeit ein single in ein word übergeben. Es werden die Nachkommas einfach abgeschnitten. Du kannst zur Laufzeit eine Division mit word und single machen. Alles ok. Nur wenn du eine reine Konstantenrechnung hast, wird die halt schon beim Kompilieren durchgeführt und wenn die nicht in die Variable passt, wird gemeckert. Gut, man könnte sich drüber streiten, ob ein Hinweis genügen würde und trotzdem kompiliert wird. Aber für mich ist die Vorgehensweise des Kompilers eigentlich klar.
      Const C = 10 / 1.01
      A = C
      ergibt keinen Fehler, eine positive single wird einem word zugewiesen
      Const C = -10 / 1.01
      A = C
      ergibt Fehler, weil eine negative single einem Word zugewiesen werden soll
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo,
      ich habe Mark angeschrieben und das Problem erörtert.

      Zunächst die richtige Handhabung:
      Const Test =(10 - 65532) + &H10000


      Zu Erklärung:
      Eine WORD Variable erlaubt keine Behandlung negativer Zahlen. Aus diesem Grund ergibt die Zuweisung einen Fehler.
      Über den Umweg der Zuweisungen durch Variablen, erscheint diese Fehlermeldung zwar nicht, dennoch ist eine solche Zuweisung "nicht richtig".

      Er versteht den Sinn einer solchen Zuweisung nicht und schlägt vor, wenn man dies unbedingt möchte, obigen Lösungsansatz zu verwenden.
      Code first, think later - Natural programmer :D
    • six1 schrieb:

      Hallo,
      ich habe Mark angeschrieben und das Problem erörtert.
      ....
      Er versteht den Sinn einer solchen Zuweisung nicht und schlägt vor, wenn man dies unbedingt möchte, obigen Lösungsansatz zu verwenden.
      Es ist gängige Praxis - nicht nur in "C" - dass bei Anwendung der Integer-Mathematik Differenzen problemlos gebildet werden können, wenn die beteiligten Variablen den gleichen Typ haben.
      In meinem Fall lasse ich einen 16Bit-Timer laufen und lese mit Pin Change Interrupt oder Input Capture die aktuellen Werte ein, dass geht in einer ISR dann sehr schnell. Die Dauer kann durch Differenzbildung ermittelt werden, ohne das der Timer immer neu angestoßen werden muss. Damit sind 50kHz bei 8MHz Takt problemlos zu messen. Für IR Remote Control langt das locker.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • monkye schrieb:

      wenn die beteiligten Variablen den gleichen Typ haben.
      Du verwendest aber Konstanten im ersten Beispiel und keine Variablen.
      Beim Einsatz von Variablen funktioniert es ohne Fehlermeldung.

      Ich stehe hier zwischen zwei Stühlen... wenn du die Hintergründe genauer wissen möchtest, wende dich bitte an den Support bei MCS.

      Ich kann diesen "Fehler" in Pascal auch nicht nachvollziehen und sehe es im Grunde auch nicht als Fehler an.
      Code first, think later - Natural programmer :D
    • Eigendlich ist die Fehlermeldung kein Fehler: Bei 10-11 weiß der Compiler das es falsch sein wird, bei 10-a nicht. Auch wenn die Überläufe meißt wie gewünscht enden 10-65... =14 so ist es doch mit Vorsicht zu genießen oder besser ganz zu lassen. Denn ob die Operation dann nicht den danebenliegenden Speicher falsch füllt oder irgendein Register/Flag einen Wert bekommt der normalerweise nicht vorkommt kann kaum vorhergesagt werden. Und die daraus resultierenden Fehler sind kaum aufzuspüren.
    • monkye schrieb:

      In meinem Fall lasse ich einen 16Bit-Timer laufen und lese mit Pin Change Interrupt oder Input Capture die aktuellen Werte ein, dass geht in einer ISR dann sehr schnell. Die Dauer kann durch Differenzbildung ermittelt werden, ohne das der Timer immer neu angestoßen werden muss.
      Das verwende ich auch oft und gern.
      Wie wäre es wenn der Compiler eine Warnung ausgibt und bei positiver Quittierung durch den Anwender weiterarbeitet?
    • Besten Dank an alle Beitragschreiber.

      Es ging mir nicht um Rechthaberei, sondern weil ich es einfach anders erwartet habe.

      Den Workaround habe ich ja bereits eingesetzt bevor ich hier in der Runde fragte. Es macht für mich immer Sinn zu fragen - und vielleicht hat ein Anderer nochmal das gleiche Thema.
      Aus datenschutzrechtlichen Gründen befindet sich die Kontaktdaten auf der Rückseite dieses Beitrages.
    • Mandarin15 schrieb:

      monkye schrieb:

      In meinem Fall lasse ich einen 16Bit-Timer laufen und lese mit Pin Change Interrupt oder Input Capture die aktuellen Werte ein, dass geht in einer ISR dann sehr schnell. Die Dauer kann durch Differenzbildung ermittelt werden, ohne das der Timer immer neu angestoßen werden muss.
      Das verwende ich auch oft und gern.Wie wäre es wenn der Compiler eine Warnung ausgibt und bei positiver Quittierung durch den Anwender weiterarbeitet?
      Das ist ja auch üblich, mit dem Überlaufen, dadurch wird ja auch zB ein interrupt erkannt. Da es hier ja nur einen Fehler gibt, wenn man nur mit Konstanten rechnet, die, weil sie eben Konstanten sind, genauso auch vorher verrechnet werden könnten und nur das Ergebnis einzutragen wäre, ist eine Meldung sinnvoll.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------