CONST als Array anzulegen?

    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!

    • CONST als Array anzulegen?

      Hallo,

      ist es möglich eine

      CONST als Array anzulegen?

      Also in etwas sowas =

      Quellcode

      1. Const Taste(1,1)=&B10001111_00101110_10110000

      Ich will die Daten nicht im Ram halten müssen

      Der Umweg ist jetzt das EEprom

      Quellcode

      1. Dim Dummy as Eram byte
      2. Dim Ee_leer as Eram byte
      3. Dim Taste(10,2) As ERAM Dword
      4. Dim Steck as byte
      5. Dim Aus_Ein as byte
      6. If Ee_leer <> 127 then
      7. Ee_leer = 127
      8. Taste(1,1)= &B10001111_00101110_10110000 'T1ein aus dem internet
      9. Taste(1,2)= &B10001100_10000101_10010000 'T1aus
      10. Taste(2,1)= &B10001111_00101110_10110100 'T2ein aus dem internet
      11. Taste(2,2)= &B10000101_11001001_00100100 'T2 aus
      12. Taste(3,1)= &B10000101_11001001_00101110 'Test3ein erzeugt aus t4 mit denken
      13. Taste(3,2)= &B10001111_00101110_10111110 'Test3aus
      14. Taste(4,1)= &B10000101_11001001_00100010 'T4ein aus dem internet
      15. Taste(4,2)= &B10001111_00101110_10110010 'T4aus
      16. Taste(5,1)= &B00001111_00110100_00110000 'TAein
      17. Taste(5,2)= &B00001010_10101010_00010000 'TAaus
      18. Taste(6,1)= &B00001001_01100111_01110100 'TBein
      19. Taste(6,2)= &B00000110_01111100_00100100 'TBaus
      20. Taste(7,1)= &B00001011_00001011_10111100 'TCein
      21. Taste(7,2)= &B00000110_01111100_00101100 'TCaus
      22. Taste(8,1)= &B00000101_11010001_10010010 'TDein
      23. Taste(8,2)= &B00000001_00101110_01000010 'TDaus
      24. Taste(9,1)= &B10010001_10011011_10110000 'T11ein
      25. Taste(9,2)= &B10011001_11011100_00100000 'T11aus
      26. Taste(10,1)= &B00000000_00000000_00000000 'Dummy
      27. Taste(10,2)= &B11111111_11111111_11111111 'Dummy
      28. Endif
      29. '****** MAIN LOOP ******
      30. DO
      31. x
      32. x
      33. CALL SwitchOnOff(Taste(steck,Aus_Ein))
      34. x
      35. x
      36. END
      37. '****** END MAIN *******
      Alles anzeigen
    • djmsc schrieb:

      Warum nimmst du dafür keine Daten-Tabelle
      Du meinst in etwa so ?

      Quellcode

      1. TasteEinDaten:
      2. Data &B10001111_00101110_10110000 'T1ein
      3. x
      4. x
      5. TasteAusDaten:
      6. Data &B10001100_10000101_10010000
      7. x
      8. und
      9. xyz = Lookup (steck , Label)
      10. bzw.
      11. CALL SwitchOnOff(Lookup (steck , Label))
      Alles anzeigen
      Dazu müsste aber, um „zweidimensional“ zu bleiben


      var = LOOKUP( value, label)

      an der „Label“ stelle eine Variable (Zeiger) zulassen

      „zweidimensional“ könnten man sicher umgehen bzw. anders lösen

      Ich sehe im Moment den Vorteil noch nicht, aber sicher machbar
    • Mit 2 (oder mehr) 'Koordinaten' kann man genauso mit einer Tabelle arbeiten. Eine Koordinate wird mit einem Faktor multipliziert und zum Ergebnis die 2. Koordinate addiert. Der Faktor ist dabei die Anzahl der möglichen Werte der 2. Koordinate. Als Beispiel ziehe ich mal eine data-Tabelle eines Zeichensatzes her. (Ascii-Wert des Buchstabens) x (Anzahl der bytes pro Buchstabe)=Einsprung in die Tabelle, die bytes für den Buchstaben sind dann die folgenden bytes in der Tabelle.
      Das die data-Tabelle mit dem Index 0 beginnt, setze ich als bekannt voraus, entsprechend muss die Berechnung ausgeführt werden.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Der Bascom-Präprozessor unterstützt leider keine Arrays, da muss man händisch indexieren, zB:
      Const Bla1_1 = "bla"
      Const Bla1_2 = "blabla"
      Const Bla2_1 = "blub"
      Const Bla2_2 = "blablub"
      usw.

      Die Daten in einer Data-Tabelle abzulegen ist aber funktional nicht ganz das selbe, da hier die Daten erst vom Flash in den RAM (Variable) geladen und dann weiter verwendet werden, im Gegensatz zur Const die beim kompilieren direkt in die jeweiligen Daten übersetzt wird
    • HansHans schrieb:

      @tschoeatsch

      Auch ein guter Ansatz ! Danke
      Dann muss aber die Datentabelle genau gefüllt sein und darf keine
      Leerfelder enthalten, sonst stimmen die Adressen in der „zweiten“ Dimension nicht mehr.
      Wo ist das Problem? Bei einem array werden auch für alle möglichen Plätze Speicherplätze vorgehalten. Gut, bei einer data-Tabelle müssen ungenutzte Daten auch mit daten belegt werden.

      @zaubara verstehe das jetzt nicht. Die const sind doch genauso im flash, wie die datas auch. Ich sehe keinen Unterschied.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Die Const-Werte sind dem Compiler bekannt, die Data-Werte werden zur Laufzeit geladen.
      Zum Beispiel wenn ich eine gewisse Sequenz über ein Port-Register ausgeben will, kann ich schreiben:

      BASCOM-Quellcode

      1. Const Sequenz1 = 11
      2. Const Sequenz2 = 22
      3. Const Sequenz3 = 33
      4. Porta = Sequenz1
      5. Porta = Sequenz2
      6. Porta = Sequenz3


      Für den Compiler steht dann im Prinzip da:

      BASCOM-Quellcode

      1. Porta = 11
      2. Porta = 22
      3. Porta = 33

      Im Gegensatz zu Data:

      BASCOM-Quellcode

      1. Dim Sequenzdaten As Byte
      2. Dim Index As Byte
      3. Restore Sequenz
      4. For Index = 0 To 2
      5. Read Sequenzdaten
      6. Porta = Sequenzdaten
      7. Next
      8. End
      9. Sequenz:
      10. Data 11, 22, 33
      Alles anzeigen
      Hier weiß der Compiler nicht was in der Sequenz steht, die lädt erst der Controller wenn er das Programm ausführt in eine Variable um sie dann am Port auszugeben

      Landet im Endeffekt beides im Flash, bei Const wird das allerdings grob gesagt in LDI/OUT übersetzt (die Konstante steht direkt im Opcode), während die Data-Variante in LPM/STS und LDS/OUT übersetzt wird und die Daten extra in einem Flashbereich abgelegt sind.

      Ergo erzeugt die Data-Variante größeren/langsameren Code. Kann ja auch egal sein, aber es ist eben nicht das selbe.