SLD/SRD für 64 Bit?

Hawkster · 12 Dezember 2009

Hallo allesamt,

habe derzeit das Problem das ich gern 64 Bit nach links bzw. Rechts schieben würde.
Problem ist nun, habe nen Mega-Baustein geschrieben, welcher das Bit für Bit in einer Schleife eingebettet macht... aber der richtig übel Zykluszeit frisst

Hat jemand ne gute Idee wie ich einen 64-Bit-Schiebe-Befehl mit wenig Zykluszeitbelastung realisieren kann!?

Mit freundlichen Grüßen,
Hawkster

gravieren · 12 Dezember 2009

Hi

Was hast du vor.
Welchen Hintergrund hat es, nach rechts oder links zu schieben.

Thomas_v2.1 · 12 Dezember 2009

Mal ein Beispiel wie man es ohne Schleife machen kann.

Wenn mehr als 32 Bits geschoben werden sollen müsste man das noch etwas erweitern (in zwei Schritte aufteilen, einmal mit 32 bits und dann nochmal mit dem Rest).

Code:

FUNCTION "SLDD" : VOID

VAR_INPUT
  IN_dwLOW : DWORD ;    
  IN_dwHIGH : DWORD ;    
  N : INT ;    //Anzahl
END_VAR
VAR_OUTPUT
  OUT_dwLOW : DWORD ;    
  OUT_dwHIGH : DWORD ;    
END_VAR
VAR_TEMP
  dwMask : DWORD ;    
  dwUebertrag : DWORD ;    
  dwTemp : DWORD ;    
END_VAR
BEGIN
NETWORK
TITLE =

// Bitmaske bilden 2^N
      L     #N; 
      L     DW#16#FFFFFFFF; 
      SLD   ; // Bitmaske um n Stellen nach links schieben
      T     #dwMask; 

// Low DWORD bearbeiten
      L     #N; 
      L     #IN_dwLOW; 
      RLD   ; 
      T     #dwTemp; 
// Reingeschobene Bits auf Null setzen
      L     #dwMask; 
      UD    ; 
      T     #OUT_dwLOW; 

// Übertragsbits aufräumen
      L     #dwMask; 
      INVD  ; 
      L     #dwTemp; 
      UD    ; 
      T     #dwTemp; 

// High DWORD bearbeiten
      L     #N; 
      L     #IN_dwHIGH; 
      SLD   ; 
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp; 
      OD    ; 
      T     #OUT_dwHIGH; 
END_FUNCTION

Hawkster · 12 Dezember 2009

Also, Grund ist einfach..,

ich habe ein Array 1..64 und dazu 2 dw's, nun muss ich die high-Pegel in den bitmustern suchen, und anhand des jeweiligen bit's den entsprechenden Array-Index herauskopieren...

Regis13 · 13 Dezember 2009

hier eine kleine einfache lösung, die ich mehrfach ausprobiert habe:

L 1
L DB1.DBD0 //HighDW schieben
SLD
T DB1.DBD0

U DB1.DBX 4.7 // ist das höchste Bit des LowDW=1
S DB1.DBX 3.0 // setze das niedrigste Bit des HighDW

L 1
L DB1.DBD4 //LowDW schieben
SLD
T DB1.DBD4

Pizza · 13 Dezember 2009

einmal rotieren bitte

Nimm doch die Rotierbefehle.

Für ein Schieberegister größer als 32 Bit gibts hier ein Beispiel.
Alles ander findest Du in der Onlinehilfe

Hawkster · 31 Dezember 2009

Vielen dank an Thomas, hab auf deiner Lösung aufgebaut und das ganze halt auf 64 Bit erweitert.

Hier meine Lösung

Netzwerk zum Rechts schieben:

Code:

      NOP   0
//#############################################################
//### Aufbau der Konstilationen
//#############################################################        
      U(    
      L     #Rechts
      L     32
      >=I  
      )    
      SPB   Y_RS
      SPA   N_RS

//==> Es werden mehr als 32 Bit geschoben
Y_RS: NOP   0
      L     32
      T     #Schiebe_1

      L     #Rechts
      L     32
      -I    
      T     #Schiebe_2

      SPA   E_RS

//==> Es werden maximal 32 Bit geschoben
N_RS: NOP   0
      L     #Rechts
      T     #Schiebe_1

      L     0
      T     #Schiebe_2
      SPA   E_RS

E_RS: NOP   0

//#############################################################
//### Schiebe 0-32
//#############################################################
// Bitmaske bilden 2^N
      L     #Schiebe_1
      L     DW#16#FFFFFFFF
      SRD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_2_2
      RRD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_2_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_1_2
      SRD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_1_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

//#############################################################
//### Schiebe 33-64
//#############################################################
// Bitmaske bilden 2^N
      L     #Schiebe_2
      L     DW#16#FFFFFFFF
      SRD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_2_2
      RRD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_2_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_1_2
      SRD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_1_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

Netzwerk zum Links schieben:

Code:

      NOP   0
//#############################################################
//### Aufbau der Konstilationen
//#############################################################        
      U(    
      L     #Links
      L     32
      >=I  
      )    
      SPB   Y_LS
      SPA   N_LS

//==> Es werden mehr als 32 Bit geschoben
Y_LS: NOP   0
      L     32
      T     #Schiebe_1

      L     #Links
      L     32
      -I    
      T     #Schiebe_2

      SPA   E_LS

//==> Es werden maximal 32 Bit geschoben
N_LS: NOP   0
      L     #Links
      T     #Schiebe_1

      L     0
      T     #Schiebe_2
      SPA   E_LS

E_LS: NOP   0

//#############################################################
//### Schiebe 0-32
//#############################################################        
// Bitmaske bilden 2^N
      L     #Schiebe_1
      L     DW#16#FFFFFFFF
      SLD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_1_2
      RLD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_1_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_2_2
      SLD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_2_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

//#############################################################
//### Schiebe 33-64
//#############################################################        
// Bitmaske bilden 2^N
      L     #Schiebe_2
      L     DW#16#FFFFFFFF
      SLD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_1_2
      RLD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_1_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_2_2
      SLD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_2_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

SLD/SRD für 64 Bit?

Hawkster

Level-1

gravieren

Level-1

Thomas_v2.1

Level-3

Hawkster

Level-1

Regis13

Level-2

Pizza

Level-2

Hawkster

Level-1

Similar threads

Wir schützen deine Privatsphäre