copymemoryRésolu

Question

Bonjour je cherche à utiliser L'API "kernell32" qui semple très classique pour beaucoup de monde!
Mais pas encore pour moi. je l'ai vue utilisée par "Renfield" ds son excellent programme de coloration syntaxique de code; et citée par "Jack" en commentaire des trucs et astuces  de "retaks666" sur  les conversions élémentaires!
Mais voila j'ai essayé le code proposé par Jack et ça bug! j'ai passé l'APM sur le web à télécharger API-guide3.7 et autre utilitaire très bien fait, et à essayer leur exemple. C'est bon jusqu'au moment ou je crois avoir compris et que je modifie et la terminé ça plante!
Bon voila l'exemple qui plante, j'essaie de copier un integer par CopyMemory.
Je fais 2 déclarations une par ByVal une par ByRef, il ya une différence mais surtout par rapport au résultat attendu:

Option Explicit
'Déclaration N°1
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" _
(ByRef pDst As Any, ByRef pSrc As Any, ByVal ByteLen As Long)
'Déclaration N°2
Private Declare Sub CopiMemory Lib "kernel32" Alias "RtlMoveMemory" _
(pDst As Any, pSrc As Any, ByVal ByteLen As Long)




Private Sub integer1_Click()
' essais de copy memory
'***********************************************************************************
'Integer to integer
Dim A, B  As Integer
Dim C, D As Variant
    A =  CInt(2 ^ 7)
    B = CInt(0)
    C = VarPtr(A) 'Pour voir!
    CopyMemory B, A, 2
    D = VarPtr(B) 'Pour voir!
        Text1.Text = CStr(B)


'************************************************************************************
    MsgBox "Essais déclaration n°1"
    
 'Retourne A=128; B=2?; C= 1307668; D= 1307666 
    


End Sub


Private Sub Integer2_Click()
Dim A, B  As Integer
Dim C, D, E As Variant
    A  = 2 ^ 7
    C = VarPtr(A) 'Pour voir!
    D = VarPtr(B) 'Pour voir!


    CopiMemory VarPtr(B), (VarPtr(A) - 1), 4
   E = VarPtr(B) 'Pour voir!
        Text1.Text = CStr(B)


'************************************************************************************
    MsgBox "Essais déclaration n°2"
    'Retourne A=128; B=0?; C= 1307668; D= 1307666


End Sub

Ou est l'erreur?
Au final j'ai besoin de convertir un Réel Virgule flottante IEEE sur 4 bytes reçu par une liaison série en bytes Recep(4) en Double en une opération aussi rapide que possible. Je procède step by step mais je débute et sui bloquer. Qui peut m'aider SVP merci!

Gobillot · Accepted Answer

les 2 déclarations sont identiques
les variables sont mal typées
Varptr() n'est pas nécessaire ici
un flottant sur 4 bytes c'est du Single, rien à voir avec du Double
pas de Variant avec CopyMemory

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)

Private Sub Command1_Click()
    Dim A  As Integer
    Dim B  As Integer

    A = 128
    
    CopyMemory B, A, 2
    MsgBox B
    CopyMemory ByVal VarPtr(B), ByVal VarPtr(A), 2
    MsgBox B
    
End Sub

Daniel

jmfmarques · Answer

Je crois tout simplement que tu devrais commencer par apprendre certains fondamentaux :

- Kernel32 n'est pas une "API" mais une librairie de l'API de Windows. Cette librairie contient plusieurs fonctions, dont la fonction CopyMemory
-VarPtr ne te retourne pas la valeur d'une variable mais son "adresse"
Ton "erreur" est donc, avant toute autre, d'essayer de mettre la charrue avant les boeufs , et en plus d'y aller à tâtons.


Il y a certainement énormément de choses, plus à ta portée du moment, auxquelles je te conseille de t'intéresser pour l'instant.

Turnoff · Answer

Bonsoir et merci pour votre aide.<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /??>


jmfmarques: 
1) Merci pour la mise au point sur le vocabulaire.
2)VarPtr me retourne bien ,comme je l'espérais l'adresse de la variable Passage de paramètre (By Reference) et non (By Value).
3) J'essaie de mettre boeuf et charrue d'accord. Pour cela comme je m'en suis mal expliqué j'ai d'abord copiés  et fait tourner des exemples, puis avant d'essayer de résoudre mon problème final qui est de convertir un nombre en virgule flottante IEEE sur 4 bytes reçu par liaison série.  J’ai essayé prudemment de faire des choses évidentes comme A=B par copymemory et d’utiliser le mode « Debug » et la fenêtre « watch » pour voir pas à pas comment évoluent les variables. En surveillant ce qui se passe en mémoire. On peut appeler ça à tatons, j’appelle cela step by step, c’est bien d’accord c’est bien de l’apprentissage.


Gobillot



1)      Merci, ton code qui fonctionne, cela m’a énormément soulagé !




2)      
J’ai alors voulu savoir pourquoi le mien ne tournait pas (têtu non ?). J’ai donc fait évoluer ton code vers le mien (Sub integer1_Click()).  Et ce n’est que lorsque j’ai changé les déclarations :



   Dim A  As Integer
    Dim B  As Integer





En : 
Dim A, B  As Integer









            
Que cela c’est mis à me sortir B=2!!



            Pour la deuxième subroutine, c’est vrai les « -1 » et les »+4 » qui traînent sont je l’accorde très idiots, mais je regardais la mémoire avec « winhex » et je voulais voir ce qui changeait, j’ai posté trop vite…sans virer la bricole. !


Désolé pour ton dernier conseil « jmfmarques » je persévère. Mais pour gagner un peu de temps l’un de vous  saurait-t-il finalement convertir rapidement  une valeur reçu par une liaison série sur 4bytes (extraite d’une trame plus longe) variable au format virgule flottante IEEE  en  un format exploitable. D’après le livre que j’ai sous les yeux, il décrive un « double » comme une valeur en virgule flottante sur 32 bits ( c’est bien 4bytes ?) Pour le « Single » il indique valeur en virgule flottante sur 16 bits (Livre B. Overland. Visual Basic le guide du développeur p356 édition OEM) Et c’est faux d’après l’aide de VB et comme me l’indique Gobillot sur 4 bytes en virgule flottante c’est bien un SINGLE §


Quel est le bon livre pour apprendre a utiliser correctement "Les librairie de l'API de Windows"?
Donc un grand merci ! Et patience!

Gobillot · Answer

Salut,
supposons que tu reçois tes 4 caractères (qui représentent bien un Single et dans le bon sens) dans un tableau de bits,
ce qui est le cas le plus préférable
un simple CopyMemory des 4 caractères dans un Single et c'est bon

    Dim B(3) As Byte
    Dim srce As Single
    Dim dest As Single
    
' pour l'exemple
    srce = 123.4567
    CopyMemory B(0), srce, 4    'le tableau B() contient un Single
    
    CopyMemory dest, B(0), 4
    MsgBox dest
    

si c'est dans une chaîne, il faut prendre en compte que c'est en unicode, donc 2 caractères suffit.
    Dim A    As String
    Dim srce As Single
    Dim dest As Single

' pour l'exemple
    srce = 123.4567
    A = Space$(2)
    CopyMemory ByVal StrPtr(A), srce, 4    'la chaîne A contient un Single

    
    CopyMemory dest, ByVal StrPtr(A), 4
    MsgBox dest

pour ton bouquin, ben je connais pas le flottant en 16 bits, seulement le 32 (Single) le 64 (Double) et le 80 (Interne)
va voir dans la section livres ça te donnera des conseils
personnellement j'en ai aucun (à part mon vieux turbo basic qui date un peu quand même)

Daniel

Turnoff · Answer

Merci beaucoup Daniel!Tes réponses sont très concises et correspondes pleinement à mes besoins. Effectivement je bute, car je déclarais mal mes variables. Notament B(3) que je déclarais B(4), j'avais oublié qu'un tableau à pour indice de son premier élément (0) Ton premier exemple est clair, pour moi. L'autre erreur que je commettais était d’écrire : CopyMemory dest, B,4 Sans mettre B(0) ! le second exemple devrait l'être clair, cependant si je cherche à comprendre plutôt qu'a copier: 1)Pourrais tu me préciser pourquoi tu utilise ByVal StrPtr(A) plutôt que A comme argument cette fois-ci. 2) Quelle est la règle? Comment l'utiliser avec d'autres type? 3) Quand utiliser et pourquoi pas, ByRef ? Je me doute que cela doit faire double emploi avec VarPtr ou StrPtr. Initialement, j’ai cherché à faire tourner une méthode donnée en commentaire par « Jack » sur un sujet proposé par retak666 ( voir CONVERSION-BYTE-STRING-HEXADECIMAL_28355.apx) voir ci dessous: jack le 23/12/2004 03:03:01 Salut retaks666 ************************************************ Oui, c'est la solution la plus évidente. Une autre méthode, beaucoup plus rapide lorsque les quantités de données sont importantes, est la suivante. Elle utilise une API qui permet de faire une copie de l'emplacement mémoire d'une variable vers l'emplacement de la seconde variable. Il faut donc (et obligatoirement) que les variables soient dimensionnées avant d'être utilisées. - Dans la partie déclaration de ta form ou ton module : Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" ( _ pDst As Any, _ pSrc As Any, _ ByVal ByteLen As Long) - La fonction de convertion String to Bytes : Public Function maStringToBytes(ByVal sSource As String, _ ByRef bTablo() As Byte) Dim r As Long, sDesti() As Byte r = Len(sSource) ' Longueur des données CopyMemory ByVal sDesti, ByVal sSource, r ' Transfert bTablo = sDesti ' Renvoi l'info End Function - La fonction de convertion Bytes to String : Public Function maBytesToString(ByRef bTablo() As Byte) As String Dim r As Long, sDesti As String r = UBound(bTablo) - LBound(bTablo) ' Longueur des données CopyMemory ByVal sDesti, ByVal bTablo, r ' Transfert maBytesToString = sDesti ' Renvoi l'info End Function Quand j’essaie le second exemple ça plante à bTablo -> Type mismatch ? Il utilise toujours ByRef même avec les String, jongle avec ByRef bTablo ds la déclaration de la seconde fonction ?!??? Pourquoi? J’en demande sans doute beaucoup, ce n’est pas loin de te faire faire un Tuto non ? MERCI pour toute ton aide, qui m’a beaucoup servi, hélas je ne sui pas prêt de pouvoir te rendre la pareille… gérald

Gobillot · Answer

hum !!! trucs et astuces
méfie toi des chaînes, c'est spécial, je te conseillle d'abord de rester en numérique
le Byref c'est par défaut, donc Byref ou rien c'est pareil
toute chaîne passée dans une APi est clonée en chaîne non Unicode (que ce soit Byref ou Byval)
donc si j'envois (A) dans un pointeur, je n'aurais pas l'adresse de (A) mais l'adresse d'une copie de (A)
quand on n'a pas à modifier la variable on peut la passer en ByVal puisque c'est la valeur qui nous intéresse
mais on pourrait tout aussi bien la passer en ByRef (mais avec le danger de pouvoir la modifier)
l'adresse d'une chaîne c'est déjà un pointeur, d'où le ByVal qui indique que ce n'est pas l'adresse qui nous intéresse mais le contenu de cette adresse qui pointe sur StrPtr()
quand on met Strptr() on obtient un pointeur (une variable temporaire en Long) qui contient l'adresse de la vrai chaîne en unicode, d'où le ByVal encore nécessaire parce que c'est le contenu du pointeur qui nous intéresse
je pense bien que tout ceci ne sera pas très clair pour toi, surtout pour les chaînes, il faut procéder par étapes et ne pas mettre la charrue avant les boeufs, comment sont organisées les variables en mémoire, comment réagissent les Api avec les variables et autres chaînes, que signifie exactement ByVal et Byref, les spécialistes ne sont même pas toujours d'accord.
d'ailleurs pour le ByVal bTablo par exemple, je suis pas trés d'accord, est ce que ça renverrait un pointeur sur Tablo(0) ???
en fait ça renvoit type mismatch, bon maintenant plantage ... c'est vrai que CopyMemory ne permet aucune erreur,
autant mettre Tablo(0) on n'a directement l'adresse du premier élément.

pour un tableau de Byte on n'a pas besoin d'Unicode, d'où l'astuce ici qui utilise le clonage automatique
(il n'y a pas de clonage quand on utilise un Long Varptr ou Strptr)

    Dim A As String
    Dim p As Long
    
    A = "abcd"
    CopyMemory p, ByVal A, 4
    MsgBox Hex$(p)   ' --> on retrouve la chaîne clonée en non Unicode 64636261  (=dcba)

Daniel

Gobillot · Answer

re,
si c'est pour étudier, ok mais pourquoi commencer par CopyMemory
si c'est pour utiliser les fonctions ci-dessus, il y a plus simple et sans Api

    Dim A    As String
    Dim B(3) As Byte
    Dim C()  As Byte
    
    B(0) = Asc("A")
    B(1) = Asc("B")
    B(2) = Asc("C")
    B(3) = Asc("D")
    
'Function maStringToBytes
    A = StrConv(B, vbUnicode)
    MsgBox A
    
'Function maBytesToString
    C = StrConv(A, vbFromUnicode)
    MsgBox Chr$(C(0))
    MsgBox Chr$(C(1))
    MsgBox Chr$(C(2))
    MsgBox Chr$(C(3))

Daniel

Gobillot · Answer

je corrige quand même ta fonction, il y avait 3 erreurs dedans

Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)

Private Sub Command1_Click()
    Dim a As String
    Dim B(3) As Byte
    
    B(0) = 65
    B(1) = 66
    B(2) = 67
    B(3) = 68
    
    a = maBytesToString(B)
    MsgBox a
    
End Sub

Public Function maBytesToString(bTablo() As Byte) As String

    Dim r As Long, sDesti As String

    r = UBound(bTablo) - LBound(bTablo) + 1

    sDesti = Space$(r)
    CopyMemory ByVal sDesti, bTablo(0), r

    maBytesToString = sDesti

End Function

Daniel

Turnoff · Answer

Bonjour, la chance du débutant c’est de tomber sur un bon maître… Tu m’as beaucoup appris, je sais,j’en ignore beaucoup, et maintenant je dois travailler tout ça. Je tâtonne et me disperse, mais puisque tu es de bonne volonté peut-être sauras-tu me mettre sur les bons rails. Mon problème initial (Pour ma petite éolienne, que je veux surveiller): Echantillonner toutes les secondes des mesures faites par un appareil distant. La liaison est du type série au protocole Modbus. La trame reçue comporte la donnée sur 4 octets . La réception de la trame et l’extraction des 4 octets dans un tableau Recopie(3) ne me pose pas de problème. Par contre, certaines valeurs sont transmise au format « Virgule flottante IEEE » d’après le constructeur ce format serait le suivant : IMPOSSIBLE DE COPIER UNE IMAGE JPG? donc je tape Octet 1 Octet 2 Msb ; b7 ; b6 ,b5, b4,b3,b2,LSB** Msb ; b7 ; b6 ,b5, b4,b3,b2,LSB ** Signe; >--------Exposant---------------------< ß------Mantisse Octet 3 Octet 4 Msb ; b7 ; b6 ,b5, b4,b3,b2,LSB** Msb ; b7 ; b6 ,b5, b4,b3,b2,LSB ** ----------Mantisse-------------------------------------------------------------à Le premier bit (MsB) de l’octet 1 est le signe, 0=Positif. Le premier bit (MsB) de l’octet 2 fait parti de l’exposant.! La mantisse est extraite des octets 2,3 et4 en plaçant tjrs 1 à la place du MSB de l’octet2 qui va à l’exposant. Arrivé là, mes compétences atteignent leur limite. Je me précipite sur le site de Vb-France et passe pas mal de temps à chercher une voie. Je tombe sur CONVERSION-BYTE-STRING-HEXADECIMAL_28355.apx), avec le commentaire de jack sur l’utilisation de copyMemory, dont je t’ais parlé précédemment. Comme la rapidité est importante car j’ai plus de 10 mesures à faire avec une liaison à 9600bauds ; et qu’il ne faut pas trop de décalage entre la première acquisition et la dernière. J’ai essayé la proposition de jack, comme cela plantait, je suis redescendu progressivement à une copie d’’un « integer », le moral aussi est descendu… tu connais la suite (le moral remonte)… J'espère quele type "single" est au même format que celui de ma valeur IEEE? Puis je t'envoyer la copie jpg à ton mail perso stp? NB : D’après les horaires de tes consultations, lève tôt ou couche tard ? C’est l’horaire nécessaire pour être bon ? Encore merci... Gérald

Gobillot · Answer

Salut,
en informatique oui ce serait plutôt des couche tard, pas une question d'horaire mais surtout de temps passé et le soir on a plus de temps.
si ton Single est bien à la norme IEEE 754 il y a pas de raison que ça marche pas
ça à l'air de correspondre 1/8/23  1 pour le signe, 8 pour l'exposant et 23 pour la mantisse
donc tu prends tes 4 octets de b(0) à b(3) et tu les copie dans un Single:
     CopyMemory dest, B(0), 4
t'as essayé et ça donne quoi ?
ou alors t'as pas un exemple avec la valeur des 4 octets et le nombre que tu dois obtenir
peut-être tes 4 octets sont pas dans l'ordre: 
c'est B(3) qui contient le signe (toujours cette inversion big indian)
    octet 1 dans B(3)
    octet 2 dans B(2)
   
octet 3 dans B(1)
   
octet 4 dans B(0)

Daniel

Turnoff · Answer

Bonsoir je n'ai pas encore essayé, bien que ce ne soit pas l'envie qui me manque. J'arrive et je dois repartir....
Mais j'ai un exemple, je reçois :
Octet1 B(3) <- 01000010   [42h]  
Octet2 B(2) <- 01001000   [48h] 
 Octet3 B(1) <- 00000000    
Octet4 B(0) <- 00000000 
Cela devrait faire 50,00 comme je peux le lire en clair sur l'appareil avant émission.?
Je te tiendrais au courant de l'évolution générale
Merci
Gérald

Gobillot · Answer

pour moi c'est bon:

   
    Dim B(3) As Byte
    Dim dest As Single

    B(3) = &H42
    B(2) = &H48
    B(1) = 0
    B(0) = 0
    CopyMemory dest, B(0), 4
    MsgBox dest   ' = 50
    

Daniel

Gobillot · Answer

en flottant ça donne

0100 0010    0100 1000    0000 0000    0000 0000

0   10000100   10010000000000000000000

Signe:
     0 = positif

Exposant:
    128+4 = 132
    132 - 127 = 5

Mantisse:
    0.5 + 0.0625 = 0.5625
    0.5625 + 1 par défaut = 1.5625
    ha bon? le 1 par défaut permet de gagner 1 bit (valeur normalisée)

Valeur:    1.5625 * 25  1.5625 * 32 50

                   

Daniel

Gobillot · Answer

puisque je suis dans les Single, j'essaye de comprendre l'algorithme ci-dessous
rien à voir avec ton problème mais ça utilise des "CopyMemory" et des "Single"
exemple a ne pas suivre, copier un Long dans un Single ne correspond à rien et pourtant ....
pas grand nombre de personne pourrait expliquer cette méthode moi y compris
que celui qui a compris essaye d'optimiser la valeur en bleu.

    Dim n    As Long
    Dim B(3) As Byte
    Dim dest As Single
    
    dest = 9
'   CopyMemory B(0), dest, 4
'   MsgBox Hex$(B(3))
'   MsgBox Hex$(B(2))
'   MsgBox Hex$(B(1))
'   MsgBox Hex$(B(0))
    
    CopyMemory n, dest, 4
'   MsgBox n
    
    n = &H5F3759DF - n \ 2
'   MsgBox n
'   CopyMemory dest, n, 4
'   CopyMemory B(0), dest, 4
'   MsgBox Hex$(B(3))
'   MsgBox Hex$(B(2))
'   MsgBox Hex$(B(1))
'   MsgBox Hex$(B(0))
    MsgBox dest   ' --> donne la valeur (très) approximative de l'inverse de la racine de 9

Daniel

Turnoff · Answer

Bonsoir Daniel...
Je prends note pour le 50, de toute façon  pour mon PB je ne vois pas d'autre façon que de faire un "CopyMemory" Si ce n'est refaire le calcul comme tu l'as fait, et encore il faut manipuler les Bits par masque avant...pour le 1 etc...
Pour ton PB, j'ai un ami un peu matheux s'il accroche il pourrait peut être nous éclairer. J'avoue être dépassé! 
Je vais dès demain soir travailler tout ça...
Promis, je te tiens au courant...
A très bientôt et encore une fois, merci de pousser un peu. La frustation du blocage c'est dur! et se répandre sur le WeB ou parfois il y a trop d'informations c'est tout aussi démoralisant.
amicalement
gérald

Turnoff · Answer

Bonjour Daniel!
Très tardivement mais comme promis je te tiens au courant. La conversion par copymemory marche impeccablement pour la réception au format IEEE!
Merci!
Je crois que cela peut être utile à d'autres personnes.
J'ai fini le dialogue MODBUS mais maintenant je voudrais supprimer les cables de la liaison série. Je vais essayer avec WiFi ou par CPL,mais il me faut passer finalement en RS482 pour la centrale d'acquisition. Je compte mettre un PC à chaque bout...
Merci encore pour la pédagogie.
gérald

Copymemory

16 réponses

Votre réponse

Discussions similaires