Bascom Tabellen: Unterschied zwischen den Versionen

Aktuelle Version vom 22. Januar 2006, 16:55 Uhr

Bascom Tabellen

An sich sind Tabellen in Bascom recht einfach anzuwenden.

Tabellen im SRAM / ERAM / XRAM

Man schreibt einfach bei einer Feld-dimensionierung eine Zahl dazu, und schon gibt es dieses Feld mehrfach

DIM tabelle(24) as byte
DIM strings(8) as string * 18

Um ein Element zu adressieren, wird einfach nur zusätzlich zum Feldnamen der Index angegeben

strings(4) = "viertes Element"
strings(7) = "siebtes Element"

Damit lassen sich auch sehr effiziente Schleifen bauen

dim indexwert as byte
for indexwert = 1 to 8 
  print strings(indexwert)
next

Dabei ist zu beachten, daß Basic allgemein und daher auch Bascom die Elemente mit "1" beginnend adressiert und nicht mit "0", wie z.B C. Die Angabe "BASE", um das zu ändern, gibt's bei Bascom nicht, also soll es halt so sein. Man darf das halt bei irgendwelchen Rechnungen nie vergessen.

mehrdimensionale Tabellen

So direkt hat das der Bascom nicht drauf. Aber man kann sich natürlich helfen.

Beispiel

Es wird eine 2 dimensionale Tabelle von Words benötigt, sagen wir 6 x 14. Man definiert also

const Max_x = 6
const Max_y = 14
const Max_z = Max_x * Max_y    ' 6 * 14 = 84

 DIM Tabelle(Max_z) as word      
 DIM tab_index as byte          ' der berechnete eindimensionale Index
 DIM tab_x as byte
 DIM tab_y as byte
 DIM help as byte              ' Ein Hilfsfeld zum Rechnen 

' wir wollen das element 4 , 7 adressieren   (cave: 1 - max_x und 1 - max_y, s.o)
 tab_x = 4
 tab_y = 7

   help = tab_x - 1
   help = help * Max_y 
   tab_index = help + 1
   tab_index = tab_index + tab_y
   tab_index = tab_index - 1

   Tabelle(tab_index) = wert

Wenn man einmal eine Funktion tab_index = f (x, y) definiert und schreibt, ist das nicht mehr so schlimm.

Tabellen im Programmspeicher

Auch die gibt es, nur funktioniert die Sache da etwas anders. Der Zugriff mittels "RESTORE" und "READ" ist natürlich wie gewohnt möglich, nur ist so kein direkter Zugriff in vernünftiger Zeit zu machen

Beim Anlegen der Tabelle müssen natürlich die Werte gleich reingeschrieben werden, zur Laufzeit geht da nix mehr.

Byte_Tabelle:
  DATA     $00, $01, 23, ...........
Integer_Tabelle:
  DATA     0%, 1%, 23%, -23%, ...........  ' da gehen dann auch negative Zahlen
Long_Tabelle:
  DATA     0&, 3840&, 23&, -23&, ...........  
Single_Tabelle:
  DATA     0.44!, 3840!, 23.67!, -23!, ...........  

Klarerweise geht nur lesen, dabei ist auf die richtige Definition von "Wert" zu achten, und die muß zu der Tabelle passen, z.B.:

DIM Wert as Byte 
Wert = LOOKUP (12, Byte_tabelle)

DIM Wert as Integer  
Wert = LOOKUP (12, Integer_tabelle)

Vorsicht: das erste Byte wird hier mit der Nummer = 0 angesprochen Bitte keine Anfragen, ich kann das auch nicht erklären !

Natürlich lassen sich auch mehrdimensionale Tabellen simulieren, genau wie bei den SRAM /EPROM Tabellen

Eine interessante Umkehrung: mit dem Befehl "LOOKDOWN" kann ein Wert in einer solchen Tabelle auch gesucht werden, mit dem Index als Ergebnis.

DIM Indexnr as byte
DIM Wert as Integer  
Wert = 23
indexnr = LOOKDOWN (Wert, Integer_tabelle, 5)

Hier muß die Anzahl der Elemente angegeben werden, im Beispiel ist das 5

Vorsicht: das erste Element wird hier als Indexnr = 1 bezeichnet Bitte keine Anfragen, ich kann das auch nicht erklären !

Ist der gesuchte Wert nicht enthalten, wird 255 bzw (-1) zurückgegeben.

Anwendungen von Programmspeichertabellen

Einige Überlegungen über Tabellenzugriffe wurden ja schon dargestellt.

Beispiel 7-Segment-Anzeige

Hier brauchen wir für jedes Zeichen nur ein Byte. 7 Bits davon sind für die Display-Segmente a-g. Solange nur die Zahlen 0-9 und A-F dargestellt werden sollen, wird ein einfacher indizierter Zugriff wohl genügen, da ja alle Zeichen vorhanden sind.

Segmente:
'---------abcdefg.
  DATA  &B11111100    ' 0 
  DATA  &B01100000    ' 1 
'... usw. .....
  DATA  &B10011110    ' F

In dieser Tabelle von 16 Bytes kann das darzustellende Zeichen direkt als Zugriffsindex verwendet werden. Wenn z.B. die Segment auf das PORTB auszugeben sind, geht das also sehr einfach:

DIM Zeichen as Byte
    Zeichen = 3     ' zum Beispiel 
    PORTB = LOOKUP(Zeichen, Segmente)

Wenn ein Byte hexadezimal, also beide Nibbles, dargestellt werden soll, sind natürlich zwei Anzeigen erforderlich

DIM Zeichen as Byte
DIM Temp as Byte
    Zeichen = &H85     ' zum Beispiel 0x85
' hier muß auf die linke Anzeige geschaltet werden
    Temp = Zeichen
    Shift temp, right, 4  ' das obere Nibble muß nach unten, also 0x85 --> 0x08
    PORTB = LOOKUP(temp, Segmente)
' jetzt auf die rechte Anzeige schalten
    Temp = Zeichen AND &H0F    ' das obere Nibble wird gelöscht, also 0x85 --> 0x05
    PORTB = LOOKUP(temp, Segmente)

Beispiel Dot-Matrix-Anzeige

Hier sind erstmal einige Überlegungen notwendig.

• Für eine 7x5 Anzeige braucht man offensichtlich für jedes Zeichen bei platzsparender Anordnung 5 Byte. Bei um 90^o gedrehter Speicherung wären sogar 7 Byte erforderlich, und nur 5 Bits wären jeweils in Verwendung. Das wäre doch recht ungünstig. Wenn aber die Zeit für eine Drehung bei der Ausgabe nicht zur Verfügung steht, bleibt wohl nichts anderes übrig.

Ein beliebiges Zeichen könnte als etwa so aussehen:

Patterntab:
.....
  DATA  &B01111100    ' column 0 für "0" 
  DATA  &B10000010    ' column 1 für "0" 
  DATA  &B10010010    ' column 2 für "0" 
  DATA  &B10000010    ' column 3 für "0" 
  DATA  &B01111100    ' column 4 für "0" 
.....

Vor dem Zugriff muß ein Index mit 5 multipliziert werden, um den Beginn des richtigen Zeichens zu treffen.

• Wenn wir vom ASCII-Zeichensatz alle druckbaren Zeichen in der Tabelle führen wollen (und können), ist die Tabelle ja immerhin geschlossen, nur für die ersten 32 Steuerzeichen muß uns was einfallen. Dazu können wir vom aktuellen Zeichen-Wert einfach diese Zahl 32 abziehen.

DIM Zeichen as Byte
DIM Temp as word
    Zeichen = 48      ' zum Beispiel  Ascii-"0" = 0x30 = d'48'

    Temp = Zeichen - 32
    Temp = Temp * 5                        ' das geht auch flotter, das ist aber nicht das Thema
    PORTB = LOOKUP(Temp, Patterntab)       ' die erste Spalte
    incr Temp
    PORTB = LOOKUP(Temp, Patterntab)       ' die zweite Spalte
  .......usw. bis zur fünften Spalte

Noch eine Anmerkung: ob man das Display der 5 Pattern als Schleife ausführen kann und wie, hängt von den sonstigen technischen Erfordernissen ab, daher soll hier nicht weiter darauf eingegangen werden. Es gibt auch unterschiedliche Lösungen für Leerstellen zwischen den einzelnen Zeichen, wenn sie notwendig sind (z.B. bei Graphikdisplays, wo ja alle Pixel dicht aneinander liegen).

• Haben wir aber nicht vor, tatsächlich alle Zeichen darzustellen, wäre diese Methode recht platzfressend, denn wir müßten ja trotzdem die ganzen 95 (druckbare Zeichen) * 5 = 475 Byte definieren. Besonders schlimm wird es, wenn auch einige Sonderzeichen (Umlaute) dazukommen sollen, die ja irgendwo zwischen 128 und 255 liegen.

Hier kann es zweckmäßig sein, eine Art Mapping-Tabelle dazwischenzuschalten. Sie soll helfen, vom Input-Zeichen zum tatsächlichen Pattern-Index zu finden.

Nehmen wir an, wir wollten wiederum nur die Zahlen 0 - 9 und A - F darstellen. Wir legen dies Zeichen nun einfach geschlossen hintereinander an

Patterntab:
  DATA  &B01111100, &B10000010, &B10010010, &B10000010, &B01111100     ' column 0-4 für "0" 
.....
  DATA  &B11111110, &B00010010, &B00010010, &B00000010, &B00000010     ' column 0-4 für "F" 

Und nun ein zweite Tabelle, wo wir die gewünschten Zeichen in dieser Reihenfolge haben, mit ihrem normalen Ascii-Code

Mapping:
'-------"0"--"1"--"2"--"3"--"4"--"5"--"6"--"7"--"8"--"9"--"A"--"B"--"C"--"D"--"E"--"F"
  DATA  $30, $31, $32, $33, $34, $35, $36, $37, $38, $39, $41, $42, $43, $44, $45, $46 

Eine weiter Anmerkung:

 DATA  "0", ...

können wir nicht schreiben, denn das interpretiert Bascom als String und legt in Wirklichkeit 2 Byte an, nämlich $30 und $0 als Stringterminator.

Jetzt können wir es uns ersparen, irgendwas abzuziehen

DIM Zeichen as Byte
DIM Temp as word
DIM Index as byte

    Zeichen = 65      ' zum Beispiel  Ascii-"A" = 0x41 = d'65'

    Index = LOOKDOWN(Zeichen, Mapping, 16)    ' 16 Zeichen sind definiert
                                              ' die position in der Mapping-Tabelle gibt den 
                                              ' tatsächlichen Index in der Patterntabelle an

    Temp = Index - 1                       ' das ergebnis 1-16 ---> 0 - 15 (s.o.) 
    Temp = Temp * 5                        ' wie gehabt
    PORTB = LOOKUP(Temp, Patterntab)       ' die erste Spalte
    incr Temp
.......... usw. fünf Spalten

Dabei sollte nach LOOKDOWN der Index auf 255 (-1) abgefragt werden, denn dann ist das Zeichen nicht in der Tabelle enthalten.

Autor

• PicNick

Siehe auch

• Tabellenbeispiel für State-Machine
• Avr
• Bascom