Concaténer un poids fort et faible pour former un Long

**Toto_le_héros38** · 24/12/2010, 16h01

Bonjour,

J'ai 2 valeurs des 5 caractères, ces deux valeurs représentent un LONG de 10 caractères.

J'ai réalisé le code suivant en VB :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Dim Resultat As Long
Dim lpFort As Long, lpFaible As Long
Dim var1 As Integer, var2 As Integer
 
lpFort = var1 << 16
lpFaible = var2 And &HFFFF
Resultat = lpFort Or lpFaible

Il fonctionne mais j'ai besoin de coder la même chose en VBA.
Je ne trouve pas l''instruction de décalage "<< 16"

Pouvez-vous m'aider
Merci

**Qwazerty** · 24/12/2010, 16h45

Salut
Pense a mettre une balise code en sélectionnant ton code et en cliquant sur le bouton # dans la barre d’édition.

Regarde du coté des fonctions shl et shr.

[Edit]
Zut je confonds avec Delphi :s
Trouvé sur le net :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
'***********************************************************
'                    SHL
'  Makes Shift Left N times in a Long Unsigned A
'************************************************************
Function Shl(A As Long, N As Byte) As Long
Dim Erro As Integer
 
Shl = 0
If N >= 32 Then Exit Function ' SHL with N bits >=32 is always 0
 
' Auxiliary Array Initialization
On Error Resume Next
If UBound(CutLeft) = 0 Then N = N
Erro = Err.Number
On Error GoTo 0
If Erro <> 0 Then IniShift
 
If A And OneBitOn(N) <> 0 Then ' Bit (32-N) Is On? (32 is the most significant bit)
  '
  ' a) Turn off the first N+1 bits
  ' b) Multiply by 2^N
  ' c) Turn on the sign bit (the most significant bit)
  '
   A = ((A And CutLeft(N + 1)) * OneBitOn(31 - N)) Or &H80000000
Else
 '
 ' a) Turn off the first N bits
 ' b) Multiply by 2^N
 '
   A = A And CutLeft(N) * OneBitOn(31 - N)
End If
Shl = A
End Function
'***********************************************************
'                   SHR
'  Make Shift Right N times in a Unsigned Long A
'************************************************************
Function Shr(A As Long, N As Byte) As Long
Dim Erro As Integer
Dim I As Integer
Shr = 0
If N >= 32 Then Exit Function  ' SHR with N bits >=32 is always 0
 
' Auxiliary Array Initialization
On Error Resume Next
If UBound(CutLeft) = 0 Then N = N
Erro = Err.Number
On Error GoTo 0
If Erro <> 0 Then IniShift
 
If A < 0 Then  ' If Bit 32 From "Unsigned" Long is On
 
   ' a) Turn off Bit 32 (Most Significant Bit)
   ' b) Make Integer Division by 2^N
   ' c) Turn on Bit 32-N (N+1o. Bit from Left)
 
   A = ((A And &H7FFFFFFF) \ OneBitOn(31 - N)) Or OneBitOn(N)
Else
   ' a) Just Make Integer Division by 2^N
   A = A \ OneBitOn(31 - N)
End If
Shr = A
End Function

[/Edit]

++
Qwaz

**pgz** · 24/12/2010, 18h23

Bonjour.

Envoyé par Toto_le_héros38

J'ai 2 valeurs des 5 caractères, c'est deux valeurs représentes un LONG de 10 caractères.

C'est certainement assez simple, mais je ne comprends pas le pb. Peux-tu être plus explicite? Un petit exemple, peut-être.

Cordialement,

PGZ

**Toto_le_héros38** · 28/12/2010, 20h45

Bonjour PGZ,

Voici 2 valeurs qui me sont descendues d'un automate programmable (12857 et -7842) ces 2 valeurs représente le poids fort et faible de la valeur suivante : 1236132190.
Dans l'application en VB6, j'utilise le code montré précédemment.
Mais je fais également un export en Excel et il me faut réécrire ce même code en VBA.
L'instruction de décalage "<< 16" n'est pas comprise par le VBA d'Excel.

J'espère avoir été plus claire

Merci par avance pour tes lumières

**pgz** · 28/12/2010, 23h32

Bonsoir.

Je ne m'y retrouve pas avec tes chiffres, mais ce que tu as essayé de faire devrait s'écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
lpFort = (var1 And (2^16-1))* 2^16
lpFaible = var2 And (2^16-1)
Resultat = lpFort + lpFaible

Ou qqc dans ce goût là.

PGZ

**AlainTech** · 01/01/2011, 15h45

Quand j'applique l'interprétation de ton code aux nombres décimaux 12857 (&H3239) et -7842 (&HE15E si on ne garde que les 4 derniers octets) , j'obtiens &H3239E15E soit le nombre décimal 842654046.

Es-tu certain de tes données?
Comment peux-tu être certain d'obtenir un nombre (décimal?) de 10 chiffres?

**Toto_le_héros38** · 08/01/2011, 18h25

Bonjour,

Merci à tous pour votre aide

, avec vos différentes réponses voici la solution à mon problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Sub macro1()
 
Dim Resultat As Long
Dim lpFort As Long, lpFaible As Long
 
lpFaible = Ranger("A3")                'A3 = -7842
lpFaible = lpFaible And 65535
 
lpFort = shr(Ranger("A4"), 16)       'A4 = 18861
 
Resultat = lpFort Or lpFaible          '=> 1236132190
 
End Sub
 
 
Public Function shr(ByVal Value As Long, Shift Value As Byte) As Long
    shr = Value
    If Shift > 0 Then
         shr = Int (shr * (2 ^ Shift))
    End If
End Function

Bonne soirée

@+

**pgz** · 08/01/2011, 19h15

Bonsoir.

Cette fois nous trouvons le même résultat. Le poids fort était 18861 et non pas 12857.

Cordialement,

PGZ

**MattChess** · 15/07/2011, 00h25

Union typée en Excel VBA

Voici une solution possible sans puissance de 2, ni multiplication / division, ni shift dans Excel VBA toute version.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Option Explicit
Type Long32Type
    value As Long
End Type
Type Long2x16Type
    value16 As Integer
    value32 As Integer
End Type
Function IntToLong(ByVal msw As Integer, ByVal lsw As Integer) As Long
Dim long2x16 As Long2x16Type, long32 As Long32Type
    long2x16.value16 = lsw
    long2x16.value32 = msw
    LSet long32 = long2x16
    IntToLong = long32.value
End Function

Notez l'affectation via LSet entre deux variables de types déclarés par l'utilisateur alignés sur un Long.

Dans la fenêtre d'Exécution immédiate (Ctrl+G) du VBE d'Excel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part