Discussion :

[Aquadrox]

Bonjour tout le monde, étant nouveau je vais tout d'abord me présenter, je suis actuellement en stage de fin d'etudes en Irlande dans une société de designing de matériel medical.
Je suis chargé de cloner un système et transcrire toutes ses sources C en Labview, jusque là tout va bien ! Mais voilà, je dois utiliser une fonction qui n'est disponible que en DLL, extraire le code, le traduire en C, et enfin en labview. J'ai deja extrait le code, mais le problème réside dans le fait que nous n'avons eu à tout casser que 10 cours d'assembleur en première année... Donc je suis devant un mur, pourriez-vous m'aider à le traduire en C??

Merci d'avance si vous pouvez, je vous joins la source Assembleur.
Je ne sais pas quelles information supplementaires je dois vous joindre (j'ai bien lus le post-it d'avant poste!).
Voila ce que j'ai au cas où:

Machine==> i386®
Linker Version==> 6.0
Magic==> PE 32

Merci d'avance

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
 PeakD:
 
 
                push    ecx
                mov     ecx,[esp+08h]
                push    ebp
                push    esi
                push    edi
                mov     eax,[ecx+0Ch]
                mov     dword ptr [esp+0Ch],00000000h
                cmp     eax,00000003h
                jl      L10001520
                cmp     eax,40000000h
                jg      L10001520
                mov     eax,[esp+20h]
                mov     edi,[esp+18h]
                mov     dword ptr [eax],00000000h
                mov     dl,[ecx+24h]
                test    dl,01h
                jz      L1000150F
                mov     esi,[ecx+0Ch]
                mov     eax,[esp+1Ch]
                push    ebx
                mov     dword ptr [esp+1Ch],FFFFB1DFh
                mov     eax,[eax]
                lea     ebp,[esi+esi*4]
                shl     ebp,03h
                lea     ebx,[ebp+2Bh]
                and     ebx,FFFFFFF8h
                test    eax,eax
                jz      L10001415
                lea     ecx,[ebx+04h]
                push    ecx
                push    eax
                call    SUB_L100162EA
                add     esp,00000008h
                test    eax,eax
                jnz     L1000143A
                mov     edx,[esp+20h]
                shr     ebx,03h
                mov     eax,[edx]
                mov     ecx,[eax]
                xor     eax,eax
                mov     [ecx],ebx
                jmp     L1000145B
 L10001415:
                lea     edx,[ebx+04h]
                push    edx
                call    SUB_L100162CC
                mov     ecx,[esp+24h]
                add     esp,00000004h
                test    eax,eax
                mov     [ecx],eax
                jz      L1000143A
                mov     edx,ecx
                shr     ebx,03h
                mov     eax,[edx]
                mov     ecx,[eax]
                xor     eax,eax
                mov     [ecx],ebx
                jmp     L1000145B
 L1000143A:
                mov     edx,[esp+20h]
                mov     eax,[edx]
                test    eax,eax
                jz      L10001457
                push    eax
                call    SUB_L100162AE
                mov     eax,[esp+24h]
                add     esp,00000004h
                mov     dword ptr [eax],00000000h
 L10001457:
                mov     eax,[esp+1Ch]
 L1000145B:
                mov     ecx,[esp+24h]
                pop     ebx
                test    eax,eax
                mov     [ecx],eax
                jnz     L1000152A
                mov     edx,[esp+1Ch]
                mov     [edi],esi
                lea     ecx,[esi+esi*2]
                mov     eax,[edx]
                mov     eax,[eax]
                add     eax,00000004h
                add     ebp,eax
                lea     edx,[eax+ecx*8]
                mov     ecx,esi
                shl     ecx,05h
                add     ecx,eax
                mov     [edi+24h],ebp
                mov     [edi+20h],ecx
                add     ebp,00000018h
                xor     ecx,ecx
                mov     [edi+1Ch],edx
                mov     [edi+18h],ebp
                shl     esi,03h
 L1000149A:
                mov     edx,[edi+18h]
                add     ecx,00000004h
                mov     [edx+ecx-04h],eax
                add     eax,esi
                cmp     ecx,0000000Ch
                jl      L1000149A
 L100014AB:
                mov     edx,[esp+14h]
                push    edi
                push    edx
                call    SUB_L100015B0
                mov     ecx,[esp+28h]
                add     esp,00000008h
                test    eax,eax
                mov     [ecx],eax
                jnz     L1000152A
                mov     eax,[esp+14h]
                mov     esi,[eax+20h]
                add     eax,00000014h
                push    esi
                push    eax
                call    SUB_L10001580
                add     esp,00000008h
                mov     [esp+0Ch],eax
                test    eax,eax
                jnz     L1000152A
                mov     edx,[esp+14h]
                push    esi
                add     edx,00000018h
                push    edx
                call    SUB_L10001580
                add     esp,00000008h
                mov     [esp+0Ch],eax
                test    eax,eax
                jnz     L1000152A
                mov     eax,[esp+14h]
                push    esi
                add     eax,0000001Ch
                push    eax
                call    SUB_L10001580
                add     esp,00000008h
                mov     [esp+0Ch],eax
                jmp     L1000152A
 L1000150F:
                mov     ecx,[esp+1Ch]
                cmp     dword ptr [ecx],00000000h
                jnz     L100014AB
                mov     dword ptr [eax],FFFFB1A0h
                jmp     L1000152A
 L10001520:
                mov     ecx,[esp+20h]
                mov     dword ptr [ecx],FFFFB1A3h
 L1000152A:
                mov     edx,[esp+14h]
                pop     edi
                pop     esi
                pop     ebp
                test    byte ptr [edx+24h],04h
                jnz     L10001548
                mov     eax,[esp+14h]
                cmp     dword ptr [eax],00000000h
                jnz     L10001548
                mov     eax,[esp+00h]
                test    eax,eax
                jz      L1000157D
 L10001548:
                mov     ecx,[esp+14h]
                cmp     dword ptr [ecx],FFFFB1DFh
                jnz     L1000155C
                mov     dword ptr [esp+00h],00000002h
 L1000155C:
                mov     edx,[esp+10h]
                mov     eax,[edx]
                test    eax,eax
                jz      L10001579
                push    eax
                call    SUB_L100162AE
                mov     eax,[esp+14h]
                add     esp,00000004h
                mov     dword ptr [eax],00000000h
 L10001579:
                mov     eax,[esp+00h]
 L1000157D:
                pop     ecx
                retn

[Alcatîz]

Bonjour !

N'est-t-il pas possible d'appeler cette fonction dans sa DLL depuis le programme LabVIEW ? J'imagine que c'est déjà le cas dans le programme C de départ ?

Je précise que je ne connais absolument pas LabVIEW.

[Aquadrox]

Sisi bien sur mais justement je l'ai extraite de la DLL, mon job est de la passer en Labview, si je l'avai en C ca serai simple mais en assembleur je compred rien, je suis en train de me taper tous les cours.

[Alcatîz]

En supposant qu'après énormément d'efforts tu parviennes à traduire la présente fonction en C, vas-tu faire la même chose pour toutes celles qui sont appelées par elle au sein de la DLL ?
Regarde tous les call dans le code.

[Aquadrox]

J'avais pas vu comme je vous l'ai dis je ne comprend casiment rien en assembleur, je crois que c'est mal partie, bon bah ca risque de rester en dans la DLL ca, merci qu'a meme

[Pierre Maurette]

Bonjour,
Vous savez beaucoup de choses que nous ne savons pas. Non pas en traçant ou en désassemblant la DLL mais en étudiant le source coté appel. Le nom (PeakD ?) peut déjà aider. Vous avez fatalement son prototype. Peut-être (j'espère) des commentaires. Bref, ne pourriez-vous pas tout simplement la réécrire en C ou directement en LabVIEW, non pas à partir de son code machine, mais des specs supposées ?
Vous pourriez éventuellement tracer le code de la DLL pour quelques points obscurs ponctuels. Le code semble "simple", mais malgré tout je ne pense pas que ça apporte grand'chose.
PeakD me fait intuiter qu'il n'est pas impossible que vous ayiez cette fonctionalité (à peu près) dans LabVIEW.
Si vous avez les sources du projet et pas celles de la DLL, peut-être celle-ci a-t-elle eté achetée à l'extérieur ? Ou alors, et là c'est mauvaise pioche, serait-elle fournie par un fournisseur de matériel, avec lequel elle assurerait l'interface ? Remarquez, à ce moment-là, l'utiliser "as is" serait la solution normale.
Cordialement,
Pierre Maurette

[Raphyfree]

Bonjour,

Je connais assez bien LabVIEW, et je voudrais apporter ma pierre a l'edifice.
Je pense que PeakD correspond au PeakDetector.

Dans la LabVIEW, si vous possédez au moins une version FDS (contenant les fonctions d'analyses avancées), vous trouverez dans la palette de fonction la fonction suivante "Analyse->Signal Processing ->Time Domain -> Peak Detector.vi"

Qui à mon avis effectue l'operation demandé.

Comme les autres personnes, je ne vois pas l'intérêt de convertir ce code assembleur en LabVIEW. Si la fonction est existante en DLL, on peut facilement l'appeler depuis LabVIEW. En plus, c'est tres courement utilisé par les developpeur LabVIEW.

Raphael.