# Byte in 8 bit teilen



## d3nnis.c (14 Januar 2010)

Hallo, kennt jemand eine einfache Methode aus eine Byte 8 einzelne Bit's zu erstellen!
Ohne 
L db20.db2.0
t bit_o 
oder so etwas!!

Dennis


----------



## Blockmove (14 Januar 2010)

Irgendwie versteh ich deine Frage nicht.
Wieso greifst du nicht ganz einfach auf das entsprechende Bit zu?

U DB20.DBX2.0
= Ax.y

Gruß
Dieter


----------



## crash (14 Januar 2010)

was soll das werden?
willst du die Bits einzeln ansprechen?
dann so...

```
U  DB20.DBX2.0
```


----------



## d3nnis.c (14 Januar 2010)

natürlich könnte ich dass so machen, aber so bald sich etwas verschieben würde, stimmen die Zuordnungen nicht mehr, da ich Symbolnamen vor Abzulte Adresse eingestellt habe. Bei der Adressierung!!

hatte ich oben verschrieben meinte

A db20.dbx2.0
=Bit_0


----------



## jackjones (14 Januar 2010)

```
AUF DB20

L DB2.0
t #temp_bit1

L DB2.1
t #temp_bit2

L DB2.2
t #temp_bit3
```

Ich würde aber mit AUF den DB öffnen und dann direkt zuweisen!

Am Anfang des BAusteins:


```
AUF DB20

u m0.0
u db20.1 
=a0.0
```


Oder in nen Register Laden....
Aber wieso ist mir nun Schleierhaft? Willst du nen FB mehrfach aufrufen? Multiinstanz? Und Ihm als IN den DB vorgeben?

Dann so:

AUF [#in_int]


----------



## Paule (14 Januar 2010)

d3nnis.c schrieb:


> da ich Symbolnamen vor Abzulte Adresse eingestellt habe. Bei der Adressierung!!


Und warum machst Du so was? 


d3nnis.c schrieb:


> aber so bald sich etwas verschieben würde, stimmen die Zuordnungen nicht mehr,


Eben!

Darum Symbolisch!


----------



## OHGN (14 Januar 2010)

@Paule:
Ich glaube Du hast *d3nnis.c *missverstanden.
Er will ja eben nicht absolut auf die Bitadressen zugreifen weil er sein Byte symbolisch adressiert hat. Beim nachträglichen Einfügen weiterer Variablen würde der absolute Bitzugriff nicht mehr passen.

@d3nnis.c:
Hier bleibt dir definitiv nichts anderes übrig als mit indirekter Adressierung zu arbeiten:

```
L  P#DeinByte
LAR1

U      [AR1,P#0.0]
=      DeinBit0

U      [AR1,P#0.1]
=      DeinBit1
......
usw. usf.
```
@jackjones: Hast Du  Deinen Code schon mal getestet? :icon_rolleyes:
.


----------



## jackjones (14 Januar 2010)

Neeee habe ich nicht! Bin ja auch zuhause, und kümmere mich nun um's Bier :s10:

Man könnte aber das t in ein = umwandeln ;p


----------



## Bernard (14 Januar 2010)

*kümmere mich nun um's Bie*

Prost !!!!!!!!!!!!!!!!!!!!


----------



## Blockmove (14 Januar 2010)

jackjones schrieb:


> ```
> AUF DB20
> 
> u m0.0
> ...



Oh Mann wie ich dieses AUF DB hasse.
Wir haben 2010 und eine S7 und nicht 1985 und S5!

Ausserdem heisst es db*x*20.1

Gruß
Dieter


----------



## Paule (14 Januar 2010)

OHGN schrieb:


> Er will ja eben nicht absolut auf die Bitadressen zugreifen weil er sein Byte symbolisch adressiert hat.


Ah, jetzt ist der Groschen gefallen. 
Ja das geht leider nur bei Merkern das ich die gleiche Adresse als Byte wie auch als Bit Symbolisch benennen kann.
Da muss man bei den DB's schon manchmal überlegen wie man es am besten Strukturiert: Int; Byte; Bool; Array of Bool; u.s.w.)


----------



## vierlagig (14 Januar 2010)

OHGN schrieb:


> Hier bleibt dir definitiv nichts anderes übrig als mit indirekter Adressierung zu arbeiten
> .



ob das so stimmt?
schließlich kann man auch bytes mit UW verknüpfen


----------



## OHGN (14 Januar 2010)

vierlagig schrieb:


> ob das so stimmt?
> schließlich kann man auch bytes mit UW verknüpfen


Wo er recht hat, hat er (fast immer) recht. 

Mein Vorschlag aus Post #7 ist ohnehin nicht so ganz brauchbar, weil dieser nur auf lokale Variablen anwendbar ist. Dem Threadersteller geht es aber offensichtlich um den Bitzugriff auf symbolische Global-Datenbausteinvariablen.

Anlehnend an Koll. *vierlagig*s Idee:

```
L  1
L  "deinDB".deinByte
UW
==I
=  deinBit0

L  2
L  "deinDB".deinByte
UW
==I
=  deinBit1

L  4
L  "deinDB".deinByte
UW
==I
=  deinBit2
............
............
usw. usf.
```


----------



## d3nnis.c (15 Januar 2010)

Ich werde es jetzt wohl so lösen, ich erstelle mir einen Hilfs Db(DBsymbol),
in diesem Db werde ich dann die einzelnen Bits erstellen!

Dann werde ich 

L Byte1
T DBsymbol.dbb0 

L Byte2
T DBsymbol.dbb2 

L Byte3
T DBsymbol.dbb3

dann kann ich mit den Symbolnamen aus dem DBSymbol arbeiten!!
Scheint mir die einfachste Methode zu sein!
Aber trotzdem Danke
Dennis


----------



## Bernard (15 Januar 2010)

Habe mir für solche Funktionen kleine parametrierbare FC`s in SCL gebaut,und in einer Libary abgelgt,somit habe ich die Funktionalität überall verfügbar.
Durch Kleine Änderungen in der SCL Quelle kann man dann auch Wort bzw. Doppelwort Filter bauen.




SCL Quelle 
Eingangsgröße:byte
Ausgangsgröße:Array[1..8] of bool


```
FUNCTION Byte_nach_bit_array :void
VAR_INPUT
   Einbyte:BYTE; // Eingangsbyte
END_VAR

VAR_OUTPUT
    Aus_bool_8_array:ARRAY[1..8] Of BOOL;
END_VAR

VAR_TEMP
    Einbyte_intern:BYTE; // Eingangsbyte
    Einbyte_at AT Einbyte_intern:ARRAY [1..8] OF BOOL;
    schleife:INT;
END_VAR
Einbyte_intern:=Einbyte;
   schleife:=1     ; 
    FOR schleife := 1 TO 8 BY 1 DO
      Aus_bool_8_array[schleife]:=Einbyte_at[schleife];
    END_FOR;
OK:=true;
 END_FUNCTION
```


----------



## Perfektionist (15 Januar 2010)

so hatte ich das schonmal in der Vergangenheit vorgeschlagen:


Perfektionist schrieb:


> mein Programmvorschlag:
> 
> L #IN
> SLW 12 // Bit 4 in A1 schieben
> ...


----------



## Paule (15 Januar 2010)

Bernard schrieb:


> Habe mir für solche Funktionen kleine parametrierbare FC`s in SCL gebaut,und in einer Libary abgelgt,somit habe ich die Funktionalität überall verfügbar.


Also Bernard,
Deine Funktion gefällt mir am besten, Voraussetzung ist natürlich man hat SCL. 
Ich brauche das jetzt nicht, aber nachdem hier sonst keiner mal ein Danke drückt, bekommst eins von mir.


----------



## OHGN (18 Januar 2010)

Paule schrieb:


> .....
> Ich brauche das jetzt nicht, aber nachdem hier sonst keiner mal ein Danke drückt, bekommst eins von mir.


Und da mir, für alle die nicht über SCL verfügen, die Lösung von *Perfektionist* am besten gefällt, werde ich mal das entsprechende 'Danke' drücken.


----------



## wolder (18 Januar 2010)

Hi Bernard,

eine Frage hab ich zu deinem Code.
Ich bin in SCL zwar noch nicht so fit, aber:

```
schleife:=1 ;
```
kannst du dir doch eigentlich sparen, oder?!

mit

```
FOR schleife := 1 TO 8 BY 1 DO
```
fängt die scheife doch automatisch bei 1 an, oder ist das in scl anders als in anderen Hochsprachen?

Gruß wolder


----------



## Bernard (18 Januar 2010)

*Betr. Schleifenvorbelegung*

Hallo Wolder.
SCL ist zwar eine Hochsprache,doch der Code läuft auf einer SPS.Meine Schleifenvariable liegt im temporären Bereich,ist also nach verlassen des Bausteines in einem nicht definierten Zustand.Aus diesem Grund präge ich temporäre Indexgrössen mit einem Anfangswert ein.
Versuche es doch einmal ohne Vorbelegung,kann ja sein das die FOR Anweisung selbst vorbelegt.


Viele Grüße Bernard


----------



## Chefmech (19 Januar 2010)

Bernard schrieb:


> Hallo Wolder.
> SCL ist zwar eine Hochsprache,doch der Code läuft auf einer SPS.Meine Schleifenvariable liegt im temporären Bereich,ist also nach verlassen des Bausteines in einem nicht definierten Zustand.Aus diesem Grund präge ich temporäre Indexgrössen mit einem Anfangswert ein.
> Versuche es doch einmal ohne Vorbelegung,kann ja sein das die FOR Anweisung selbst vorbelegt.
> 
> ...



SCL macht das schon richtig und initialisiert bei Schleifenbeginn. 
Trotzdem ist es sicher nie falsch eine Temp-Variable zu initialisieren.


----------



## Paule (19 Januar 2010)

Chefmech schrieb:


> SCL macht das schon richtig und initialisiert bei Schleifenbeginn.
> Trotzdem ist es sicher nie falsch eine Temp-Variable zu initialisieren.


Interessant!
Ist das jetzt fundiertes wissen?
Wenn ja warum dann initialisieren?


----------



## Chefmech (19 Januar 2010)

Weil sich das für einen guten Programmierer so gehört.

Jeder SCL programmierer hat sich schon mal was verbockt, mit einer nicht initialisierten Temp-Variablen (besonders bei Temp-Strings).

Also gehört das zu einem guten Programmier-styl, jede Tempvar am Anfang eines Bausteines zu initialisieren.


----------



## Paule (19 Januar 2010)

Chefmech schrieb:


> Weil sich das für einen guten Programmierer so gehört.


Bist Du ein guter Programmierer? Klasse können nicht viele von sich behaupten.



Chefmech schrieb:


> Jeder SCL programmierer hat sich schon mal was verbockt,


Echt?
Erschreckend. Du kennst alle SCL Programmierer? Kennst Du mich? 



Chefmech schrieb:


> Also gehört das zu einem guten Programmier-styl, jede Tempvar am Anfang eines Bausteines zu initialisieren.


Du schreibst man muss es nicht tun, warum soll ich es jetzt tun?
Damit ich gut bin? Oder damit ich mehr Programmcode habe?

Klar bist Du jetzt sauer auf mich aber dafür kannst Deinen Hundertsten Beitrag als Antwort schreiben.
Ist doch auch was wert oder?

Und nur damit Du beruhigt bist, ich initialisiere jede Variabel.


----------

