BASCOM array auf einmal füllen

[Maximilian (Gast)]

Guten Tag!

Ist es möglich ein array auf einmal mit Werten zu füllen?

Ich habe ein array das 20 bytes enthält und das soll mit bestimmten 
bytes gefüllt werden, die fest vorgegeben sind (je nach Programmteil 
aber unterschiedliche Werte haben). Danach sollen einzelnen bytes des 
arrays verändert werden.

Ich könnte es zwar so lösen, das ich für jedes byte des arrays die 
Zuweisung in eine Zeile schreibe:
werte(1) = &H00
werte(2) = &H01
werte(3) = &H02
usw.

aber der code wird dadurch sehr unübersichtlich und lang. Kann man sowas 
auch mit einem Befehl machen?

Also so z.B.

dim werte(10) as byte
dim a as byte
dim b as byte

'hier sollte das array mit 10 bytes gefüllt werden, die bekannt sind, aber wie
werte(?) = &H00 , &H01 , &H02 , &H03 , ...

werte(3) = a
werte(2) = b

Gruss,
Maximilian

[niemand (Gast)]

Wenn die Werte aufsteigend sind, kannst du das auch mit einer Schleife 
machen.

[MWS (Gast)]

Vorgabewerte in Data Statements rein und dann mit Restore und Read in 
einer Schleife dem Array zuweisen.

Eine andere Möglichkeit wäre, wenn die Werte des Arrays im Code nur 
gelesen, also nicht verändert werden, statt dem Array gleich Data zu 
verwenden, mit Lookup(Index, Label) geht dies ähnlich einem Array.

[Maximilian (Gast)]

Die Werte sind nicht aufsteigend. Deshalb geht keine Schleife.

Die Werte sind im Code fest vorgegeben. Es existieren ca. 20 
verschiedene Vorgabe-Werte für das array (also 20x 10 Bytes). Wenn die 
Werte in das array geschrieben sind, werden anschliessend noch einzelne 
Bytes des arrays verändert (durch Werte von Variablen ersetzt).

Wenn ich das mit lookup tabellen mache, dann müsste ich ja auch wieder 
10x einen "lookup" machen damit ich die 10 Bytes zusammen habe.

[Karl H. (kbuchegg)]

Maximilian wrote:

> Wenn ich das mit lookup tabellen mache, dann müsste ich ja auch wieder
> 10x einen "lookup" machen damit ich die 10 Bytes zusammen habe.

Tja. Das Leben ist hart.
Aber: Die Schleife ist schon erfunden. Es reicht wenn du nur einen 
Lookup machst, den aber in einer Schleife 10 mal.

[Wolfgang S. (wsm)]

Das Array und eine String-Variable mit Overlay an der gleichen Stelle im 
RAM festlegen.

Dann der Stringvariablen einen String zuweisen, der steht danach im 
Array.

Gruß

Wolfgang

[Arne G. (kywalda)]

Man könnte dafür auch eine SUB deklarieren:

declare sub fillarray(byval a1 as byte, byval a2 as byte, ... )

do
irgendwas

call fillarray(&H00, &H01, hier_kann_auch_ne_variable_stehen, ...)

loop

end


sub fillarray(byval a1 as byte, byval a2 as byte, ... )
werte(1) = a1
werte(2) = a2
werte(3) = a3
...
end sub

Das lohnt natürlich nur, wenn man das Array häufiger neu füllen will.

lg,
arne

[Holm T. (Gast)]

Ich hole das mal aus der Versenkung weil ein Kumpel mir erzählt hat, das 
er das mit den Arrays als Charactergenerator für eine 7-Seg Anzeige 
nicht verstanden hat.
Ich habe Ihm das mit initialisierten Feldern in C erzählt und dann mit 
der darzustellenden Zahl als Index für das Feld und der Feldinhalt ist 
dann die Bitkombination. Der Kumpel kennt nur ein Bisschen BASCOM und 
ich habe jetzt mal geguckt wie man Felder bei BASCOM 
initialisiert....scheinbar gar nicht.
Das geht offensichtlich nur mit dieser Data Restore und Read 
Geschichte...

ist das so?

Gruß,

Holm, der nicht wirklich vor hat sich in BASCOM einzuarbeiten..

[joe (Gast)]

Siehe oben:

dim werte(10) as Byte

[Holm T. (Gast)]

Das definiert mir ein Feld "werte" das 10 Elemente vom Typ "byte" 
enthält.

...und wo ist die Initialisierung nach der ich fragte?

Also das Equivalent für z.B.

uint16_t character_table[] PROGMEM =
{
    SegA|SegB|SegC|SegD|SegE|SegF|SegK|SegR,        // 0    0x00
    SegB|SegC|SegK,                                 // 1    0x01
    SegA|SegB|SegD|SegE|SegG|Seg                    // 2    0x02
};

Sorry, so einfach wars dann nicht joe, Du hättest wenigstens meine Frage 
durchlesen sollen.

Gruß,

Holm

Habs selber gefunden, hat aber streng genommen mit Arrays und DIM nichts 
zu tun, die Syntax ist wohl was BASCOM-spezifisches:

http://www.rn-wissen.de/index.php/Bascom_Tabellen
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)


..womit das geklärt wäre..

Gruß,

Holm

[Falk B. (falk)]

Etwa so. Ist zwar ein Würg-Around und bei weitem nicht so komfortabel 
und mächtig wie ein C-Präprozessor, aber allemal besser als der BASCOM 
Standardansatz mit DATA-Zeilen, wo man praktisch nur einen Datensatz 
hat!

Der Trick ist, dass man in Strings direkt Bytes definieren kann, wenn 
man sie

- in geschweiften Klammern
- immer mit drei Stellen
- im Bereich 000-255

angibt. Sozusagen die BASCOM-Escape Sequenz. Naja.

[Falk B. (falk)]

Hmm, ganz schön verquer, einen Tabellenzugriff über eine Funktion ;-)

[Holm T. (Gast)]

Ja, einfach nur von hinten durch die Brust ins Auge.

Ich predige dem armen Kerl ja schon immer das er sich mit C befassen 
soll weil er da nicht an einen Prozessor gebunden ist..aber momentan ist 
das für ihn alles nur Hokuspokus...

Gruß,

Holm

[Dirk W. (cool-dmx)]

Hallo in die runde,

in meinen Augen ist C auch nicht der heilige Gral ich komme damit z.b. 
garnicht klar(zu krüptisch und unübersichtlich). Aber das Thema möchte 
ich hier jetzt nicht ausweiten.

Nur soviel, mit Bascom geht schon so einiges.
Wie in jeder Programiersprache ist der Erfolg und Misserfolg vom 
Programmiere abhängig.


mal als Angegung wie ich es mache würde...

'-------------------------------------------------------------------
Dim Tmp As Byte
Dim Wert(10) As Byte
.
.
.
.
For Tmp = 1 To 10
Wert(tmp) = Lookup(tmp , Byte_tabelle)
Next Tmp
.
.
.
.
Byte_Tabelle:
  Data $01 , $02 , $03 , $04 , $05 , $06 , $07 , $08, $09, $10


das geht auch mit ander Variablen


MfG Dirk (COOL-DMX.DE)

[Ohaahh (Gast)]

Dirk Wegener schrieb:
> mal als Angegung wie ich es mache würde...
> .
> .

Was für ein Schrott. Hast du das selbst mal ausprobiert? Wert(tmp) hat 
am Ende nie die Werte die in Byte_Tabelle stehen. Und dafür den thread 
nochmal aufgewärmt. Kopfschüttel.

[Dirk W. (cool-dmx)]

Ohaahh...,ich weiss zwar nicht wie du drauf bist, aber prinzipiell geht 
das so.

Und JA ich habe es ausprobiert auf ein STK200.

$regfile = "attiny2313.dat"
$crystal = 16000000
'------------------------------------
$hwstack = 32
$swstack = 8
$framesize = 24
'------------------------------------
'Variablen
Dim Tmp As Byte
Dim Tmp_ary As Byte
Dim Tmp_loop As Byte
Dim Wert(20) As Byte


Tmp_ary = 2                                                 'Tabelle 
auswählen
Tmp_loop = Lookup(tmp_ary , Byte_tabelle)

For Tmp = 1 To Tmp_loop
   Select Case Tmp_ary
     Case 0 : Wert(tmp + 1) = Lookup(tmp , Byte_tabelle1)
     Case 1 : Wert(tmp + 1) = Lookup(tmp , Byte_tabelle2)
     Case 2 : Wert(tmp + 1) = Lookup(tmp , Byte_tabelle3)
     Case 3 : Wert(tmp + 1) = Lookup(tmp , Byte_tabelle4)
   End Select
Next Tmp
'------------------------------------
Config Portb = &B11111111                                   'Port's 
Configurieren
Portb = 0
'####################################################################### 
########
' Hauptschleife
'####################################################################### 
########

Do
   For Tmp = 1 To Tmp_loop
      Waitms 100
      Portb = Wert(tmp)
   Next Tmp
Loop

'####################################################################### 
########
Byte_tabelle:
  Data 16 , 14 , 14 , 16
'-------------------------
Byte_tabelle1:
  Data 00 , 01 , 02 , 03 , 04 , 05 , 06 , 07 , 08 , 09 , 10 , 11 , 12 , 
13 , 14 , 15
Byte_tabelle2:
  Data 01 , 02 , 04 , 08 , 16 , 32 , 64 , 128 , 64 , 32 , 16 , 08 , 04 , 
02
Byte_tabelle3:
  Data 127 , 191 , 223 , 239 , 247 , 251 , 253 , 254 , 253 , 251 , 247 , 
239 , 223 , 191
Byte_tabelle4:
  Data 00 , 128 , 192 , 224 , 240 , 248 , 252 , 254 , 255 , 254 , 252 , 
248 , 240 , 224 , 192 , 128
'####################################################################### 
########