Aus RN-Wissen.de
Wechseln zu: Navigation, Suche
Balkonkraftwerk Speicher und Wechselrichter Tests und Tutorials

(Bascom Tabellen)
(Bascom Tabellen)
Zeile 1: Zeile 1:
 
== Bascom Tabellen ==
 
== Bascom Tabellen ==
 
{{Baustelle|PicNick}}
 
{{Baustelle|PicNick}}
 +
An sich sind Tabellen in Bascom recht einfach anzuwenden. Man schreib 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
 
<pre>
 
<pre>
$regfile = "m32def.dat"
+
const Max_x = 6
$crystal = 8000000
+
const Max_y = 14
$baud = 9600
+
const Max_z = Max_x * Max_y    ' 6 * 14 = 84
$hwstack = 32
+
$hwstack = 64
+
$framesize = 32
+
' ---------------------------------------------
+
' Pixel Timer                ' 1 mS each pixel
+
' ---------------------------------------------
+
Config Timer0 = Timer , Prescale = 64
+
Const Tim_preload = 131
+
Dim Timerload As Byte
+
  Timerload = Tim_preload
+
  
  On Timer0 Isr_tim0
+
DIM Tabelle(Max_z) as word     
  Timer0 = Timerload
+
DIM tab_index as byte          ' der berechnetet eindimensionale index
' ---------------------------------------------
+
DIM tab_x as byte
' Sync Interrupt
+
DIM tab_y as byte
' ---------------------------------------------
+
DIM help as byte              ' Ein Hilfsfeld zum rechnen
Config Int0 = Falling
+
  On Int0 Isr_int0
+
  
' ---------------------------------------------
+
' wir wollen das element 4 , 7 adressieren  (cave: 1 - max_x und 1 - max_y, s.o)
' Patterm dimension
+
tab_x = 4
' ---------------------------------------------
+
tab_y = 7
Const Pat_rows = 7
+
Const Pat_cols = 5
+
'----------------------------------------------
+
Const Buf_chars = 16
+
Const Col_chars = Pat_cols * Buf_chars
+
' ---------------------------------------------
+
'    0      Left          Top  255
+
'    |.......|characters|...>.....
+
' ---------------------------------------------
+
Const Col_left = 12
+
Const Col_top = 120
+
' ---------------------------------------------
+
'
+
' ---------------------------------------------
+
Dim Char_buffer As String * Buf_chars
+
  
Dim Charpntr As Word
+
  help = tab_x - 1
Dim Charcount As Byte
+
  help = help * Max_y
Dim Pataddr As Word
+
  tab_index = help + 1
Dim Pattern As Word
+
  tab_index = tab_index + tab_y
Dim Patcol As Byte
+
  tab_index = tab_index - 1
  
Dim Tim_flag As Byte
+
  Tabelle(tab_index) = wert
Dim Show_flag As Byte
+
Dim Work_flag As Byte
+
  
 +
</pre>
 +
Wenn man einmal eine Funktion tab_index = f (x, y) definiert und schreibt, ist das nicht mehr so schlimm.
  
Dim Charval As Byte
+
===Tabellen im Programmspeicher===
Dim Charidx As Byte
+
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
Dim Line_ctl As Byte
+
Dim Charout As Byte
+
    Enable Int0
+
    Enable Timer0
+
    Start Timer0
+
    Enable Interrupts
+
  
     Pattern = Loadlabel(char_pattern)
+
Beim Anlegen der Tabelle müssen natürlich die Werte gleich reingeschrieben werden, zur Laufzeit geht da nix mehr. 
 +
<pre>
 +
Byte_Tabelle:
 +
  DATA     &H00, &H01, 23, ...........
 +
Integer_Tabelle:
 +
  DATA    &H00%, &H01%, 23%, -23%, ...........  ' da gehen dann auch negative Zahlen
 +
Long_Tabelle:
 +
  DATA    0&, 3840&, 23&, -23&, ........... 
 +
Single_Tabelle:
 +
  DATA    0.44!, 3840!, 23.67!, -23!, ........... 
 +
</pre>
 +
Klarerweise geht nur lesen, z.B.
 +
Hier ist auf die richtige definition von "Wert" zu achten, die muß zu der Tabelle passen
 +
DIM Wert as Byte
 +
Wert = LOOKUP (12, Byte_tabelle)
  
' ---------------------------------------------
+
DIM Wert as Integer 
'              Set Input
+
  Wert = LOOKUP (12, Integer_tabelle)
' ---------------------------------------------
+
  Char_buffer = "0123456789ABCDEF"
+
  
' ---------------------------------------------
+
''' Vorsicht: das erste Byte wird hier mit "0" angesprochen'''
'             Initial conditions
+
' ---------------------------------------------
+
  Patcol = 0
+
  Line_ctl = 0
+
  Work_flag = 0
+
  
  Do
+
Natürlich lassen sich auch mehrdimensionale Tabellen simulieren, genau wie bei den SRAM /EPROM Tabellen
      If Tim_flag = 1 Then
+
        Tim_flag = 0
+
        If Show_flag = 1 Then
+
            Print Bin(charout)
+
        End If
+
        Incr Line_ctl
+
        If Line_ctl = Col_left Then
+
            Work_flag = 1
+
            Charpntr = Varptr(char_buffer)
+
            Charcount = Buf_chars
+
        End If
+
        If Work_flag = 1 Then
+
            If Patcol = 0 Then
+
' read character & find pattern
+
              Patcol = 1
+
              Charval = Inp(charpntr)
+
              Charidx = Lookdown(charval , Char_table , 16)
+
              If Charidx < 255 Then
+
                  Decr Charidx
+
                  Pataddr = Charidx * Pat_cols
+
                  Pataddr = Pataddr + Pattern
+
                  Show_flag = 1
+
              Else
+
                  Show_flag = 0
+
              End If
+
            End If
+
' prepare character pattern------------------------------------------
+
            If Show_flag = 1 Then
+
              Charout = Cpeek(pataddr)                    ' writout pattern
+
              Incr Pataddr
+
            Else
+
              Charout = 0
+
            End If
+
' set next pattern column------------------------------------------
+
            Incr Patcol
+
            If Patcol > 5 Then
+
              Patcol = 0
+
              Print
+
' step next character --------------------------------------------
+
              Incr Charpntr
+
              Decr Charcount
+
              If Charcount = 0 Then
+
' all done
+
                  Work_flag = 0
+
              End If
+
            End If
+
 
+
      End If
+
  End If
+
Loop
+
 
+
End
+
'------------------------------------------------
+
Isr_tim0:
+
  Timer0 = Timerload
+
  Tim_flag = 1
+
  Return
+
'------------------------------------------------
+
 
+
Isr_int0:
+
  Select Case Line_ctl
+
  Case Is < Col_top:
+
      Incr Timerload
+
  Case Is > Col_top:
+
      Decr Timerload
+
  End Select
+
  Line_ctl = 0
+
  Return
+
'------------------------------------------------
+
 
+
Char_table:
+
'-------"0"-"1"-"2"-"3"-"4"-"5"-"6"-"7"-"8"-"9"
+
  Data 48 , 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , 57
+
'-------"A"--"B"--"C"--"D"--"E"--"F"
+
  Data 65 , 66 , 67 , 68 , 69 , 70
+
 
+
 
+
Char_pattern:
+
' "0" -------------------------------------------
+
Data &B01111100
+
Data &B10000010
+
Data &B10000010
+
Data &B01111100
+
Data &B00000000
+
' "1" -------------------------------------------
+
Data &B00000000
+
Data &B00000100
+
Data &B00000010
+
Data &B11111110
+
Data &B00000000
+
' "2" -------------------------------------------
+
Data &B11000100
+
Data &B10100010
+
Data &B10010010
+
Data &B10001100
+
Data &B00000000
+
' "3" -------------------------------------------
+
Data &B01000100
+
Data &B10000010
+
Data &B10010010
+
Data &B01101100
+
Data &B00000000
+
' "4" -------------------------------------------
+
Data &B00011100
+
Data &B00010010
+
Data &B11111111
+
Data &B00010000
+
Data &B00000000
+
' "5" -------------------------------------------
+
Data &B10111110
+
Data &B10010010
+
Data &B10010010
+
Data &B01100010
+
Data &B00000000
+
' "6" -------------------------------------------
+
Data &B01111100
+
Data &B10010010
+
Data &B10010010
+
Data &B01100100
+
Data &B00000000
+
' "7" -------------------------------------------
+
Data &B00000100
+
Data &B00010010
+
Data &B00010010
+
Data &B11111110
+
Data &B00000000
+
' "8" -------------------------------------------
+
Data &B01101100
+
Data &B10010010
+
Data &B10010010
+
Data &B01101100
+
Data &B00000000
+
' "9" -------------------------------------------
+
Data &B00001100
+
Data &B00110010
+
Data &B01010010
+
Data &B10001100
+
Data &B00000000
+
' "A" -------------------------------------------
+
Data &B11111100
+
Data &B00010010
+
Data &B00010010
+
Data &B11111000
+
Data &B00000000
+
' "B" -------------------------------------------
+
Data &B11111110
+
Data &B10010010
+
Data &B10010010
+
Data &B01101100
+
Data &B00000000
+
' "C" -------------------------------------------
+
Data &B01111100
+
Data &B10000010
+
Data &B10000010
+
Data &B01000100
+
Data &B00000000
+
' "D" -------------------------------------------
+
Data &B10000010
+
Data &B11111110
+
Data &B10000010
+
Data &B01111100
+
Data &B00000000
+
' "E" -------------------------------------------
+
Data &B11111110
+
Data &B10010010
+
Data &B10010010
+
Data &B10000010
+
Data &B00000000
+
' "F" -------------------------------------------
+
Data &B11111110
+
Data &B00010010
+
Data &B00010010
+
Data &B00000010
+
Data &B00000000
+
</pre>
+
  
 
==Autor==
 
==Autor==

Version vom 18. Januar 2006, 21:31 Uhr

Bascom Tabellen

Baustelle.gif An diesem Artikel arbeitet gerade Mitglied PicNick.

Am besten momentan noch keine gravierenden Ergänzungen / Änderungen vornehmen.

Dieser Hinweis verschwindet wenn der Autor soweit ist. Sollte dieser Hinweis länger als drei Tage auf einer Seite sein, bitte beim Autor PicNick per PM / Mail oder Forum nachfragen ob er vergessen wurde.

An sich sind Tabellen in Bascom recht einfach anzuwenden. Man schreib 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 berechnetet 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     &H00, &H01, 23, ...........
Integer_Tabelle:
  DATA     &H00%, &H01%, 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, z.B. Hier ist auf die richtige definition von "Wert" zu achten, die muß zu der Tabelle passen

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 "0" angesprochen

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

Autor

Siehe auch


LiFePO4 Speicher Test