Bonjour à tous!
Je suis étudiants en informatique, et j'apprends actuellement le langage ASM 80x86, j'aurais aimer avoir votre avis sur la manière de coder une fonction "sleep"... qui me permettrait d'attendre "x" seconde avant de continuer la suite de mon programme.
 
Savez-vous comment je peux faire ça? je n'y arrive vraiment pas, j'ai chercher sur Google pas mal de temps, et je reste bloquer.
 
Merci par avance!
Krays

contexte/os/finalité ?

l'os est windows(XP/Vista), je code sous MASM, et le but est de crée un affichage "animé" (les lettres apparaisse au fur et a mesure sur l'ecran).
 
Merci par avance

donc il faut utiliser le sleep de l'os:
 
http://msdn2.microsoft.com/en-us/l [...] S.85).aspx

heu je suis dsl, mais je ne sais pas trés bien comment integrer ça a mon projet?
 
peux tu me dire comment ça marche? et comment faire pour l'integrer dans mon code masm ?  je copie colle la fonction, et je l'appelle via un call? ou dois-je inclure une librairie annexe lors de la compil et faire un call far ptr?

tu fais bien un binaire win32 ? (et pas DOS parceque sous vista ça tranchera).
 
il a bien une tête de ce genre ton code ?
http://asmzone.ifrance.com/asmzone [...] urs/c1.htm
 
bon bin tu inclus le .inc et .lib qui va bien et tu call le sleep.

non,
 
voila mon code actuel :  
 
 
 

oui, ca passe par un call, du type:
push 5000  
call Sleep  
pour une attente de 5 secs.
 
Pour les includes, ca doit être gere par la ligne avec masm32rt.inc qui devrait figurer en debut de ton code, non? Ou alors tu fais tout explicitement:
 
    .486                                    ; create 32 bit code  
    .model flat, stdcall                    ; 32 bit memory model  
    option casemap :none                    ; case sensitive  
   
    include \masm32\include\windows.inc     ; always first  
    include \masm32\macros\macros.asm       ; MASM support macros  
 
  ; -----------------------------------------------------------------  
  ; include files that have MASM format prototypes for function calls  
  ; -----------------------------------------------------------------  
    include \masm32\include\masm32.inc  
    include \masm32\include\gdi32.inc  
    include \masm32\include\user32.inc  
    include \masm32\include\kernel32.inc  
 
  ; ------------------------------------------------  
  ; Library files that have definitions for function  
  ; exports and tested reliable prebuilt code.  
  ; ------------------------------------------------  
    includelib \masm32\lib\masm32.lib  
    includelib \masm32\lib\gdi32.lib  
    includelib \masm32\lib\user32.lib  
    includelib \masm32\lib\kernel32.lib  
 
(virer les includes et libs inutiles)
 
 
EDIT: je viens de voit ton code, c'est de l'assembleur tout ce qu'il y a de basique, mais c'est du DOS (appels a int 21h), donc sans garantie de fonctionnement sans problemes sous windows.
A+,

pour info j'utilise la Version 6.11 de masm, je compile sous DOS, et tu as dans mon poste ci dessu l'integralité du code que j'utilise...
sous dos je tape :
 
masm monfichier.asm
link monfichier baseio     (baseio etant un obj que j'utilise dans mon code)
 
c'est tous... je n'est fais aucun include (dailleur mon dossier masm ne contient pas de masm32rt.inc)
 
Merci par avance pour vos réponse

pour info (bis), je n'est pas masm32.... ma version est imposer par notre professeur.

n'est t'il pas possible avec les instruction de base de l'assembleur 80x86 de  crée une fonction qui me permette de temporiser une action ? n'y en as t'il pas de pré-existante?

Masm 6.11, ca me rappelle des choses, ca doit dater de Windows 3.1, au pire de win 95, non?
Donc en fait, tu es sous un archaique DOS comme environnement, ou bien dans une console DOS de windows? et en ce cas, quelle version de windows?
A+,

bha ecoute, la je tourne sous windows vista... mon programme compile parfaitement... j'utilise la commande cmd pour afficher la console... aprés je compile et j'execute parfaitement... donc bon...

Ca veut pas dire que tout ce qui marchait en dos est garanti de fonctionner.
Autrefois, en DOS, pour ce type de pb, on aurait utilise ceci:

( http://heim.ifi.uio.no/~stanisls/helppc/int_table.html )
Je me souviens l'avoir fait, il y a longtemps.
Mais rien ne garantit que Windows supporte encore ce type de choses.
Si les int 21 que tu fais marchent encore, c'est parce que les ingés de windows ont fait en sorte que ca reste a peu pres encore utilisable, bien que tout soit émulé.  
 
Si ca colle pas, au pire, tu fais une boucle bloquante en appellant DOS Get Time (une int 21), et tu testes que une seconde s'est ecoulée.

 
A+,

j'ai esseyer de coder ça, sa compile, mais sa fait une boucle infinie apparament, tu aurais une solution ?  

Ca boucle a l'infini?

Ca m'a pas l'air mauvais, il faudrait afficher dh apres chaque interruption, pour verifier que c'est bien gere par windows.
A+,

Sinon, tu as l'interruption 15, mais est elle elle aussi correctement geree par windows maintenant, c'est a tester.

 
Et tu peux t'inspirer de ce type de code

A+,

y'a plus de DOS sous Vista, donc tu peux rayer Vista de ta liste d'os supportés.
 
(sinon dans l'espace d'adressage du bios, il y a des tables normalisées où tu dois trouver un entier qui est incrémenté tous les 1/18.2ième de seconde, qui peut donc juste être atteint par un mov)

Comme il a mis ca:

il y a apparement encore du support, mais je suppose que tout ne marche pas. Apparement, l'interruption 21 donnant l'heure marche (il a l'air d'afficher au moins une fois l'heure) c'est pourquoi a la base, je pensais qu'une boucle testant l'heure collerait, et je suis perplexe sur le fait que ca lui fait une boucle infinie.
A+,

après réflexion c'est le support WIN16 qui est tombé. donc peut-être qu'il y a effectivement un peu de support DOS
 
En fait Vista 32 semble encore avoir du support, Vista 64 non.

Ils ont quand même fait un émulateur pour les appels BIOS : http://x86asm.net/articles/calling [...] index.html

Le MASM 6.11, c'est du 16 bits plein pots (6.11d est la derniere version de MASM a le faire d'ailleurs)  donc son support sur des WinXXX est loin d'être garanti.
A+,

Sous Windows 3.1 jusqu'à Windows XP, il y a 3 formats d'exécutable, communément nommés : MZ, NE, PE.
Sous Windows Vista 64, c'est le NE qui passe à la trappe.
Les programmes DOS (mode console) sont au format MZ, qui continue d'exister sous Windows 64.
Edit : D'ailleurs, les programmes PE ont habituellement un stub (sorte de header) qui est au format MZ. Donc ce n'est pas demain la veille que le MZ sera abandonné.

Certes, mais c'est le support des diverses interruptions datant de l'époque du DOS sur lesquelles je ne parierais pas, en particulier la 4A.
A+,

bah les PE qui ont un stub MZ, c'est justement pour dire que l'exe peut pas marcher sous dos.
 
et comme dit gilou, le format de l'éxécutable ne fait pas le larron

bonjour, je peux aider ?
 

 
ah non, de l'assembleur 16 bits en mode réel.... merci et au revoir

Voila j'ai trouver une solution pour crée un timer en 80x86, merci a tous d'avoir participer a cette discutions :

au pire, fais lui perdre du temps
 
call Pause
 
Pause    movlw 0xff
            movwf compte1
 
dec  decfsz compte1,1
       goto dec
 
       return
 
c un decompte de 255 à 0, et le temps de cette pause va varié en fonction de la vitesse du processeur, au pire calcule ca vitesse et mets le nombre de pause que tu a de besoin     ex:  2Ghz ->  (2exp9)exp-1 = 5pico sec  par decompte complet (500exp-12). Alors pour 1 sec d'attente -> 1/ 5exp-12 = 200 milliard de fois.
 
Tk c le code asm basé sur les pic de la serie 16f8x de microchip... remarque c surment pas evident d'utiliser cette technique en informatique, après tout les pic roule en moyen en 4 et 20 Mhz seulement...

apprendre à programmer en ASM 16 bits de nos jours est pratiquement aussi utile que d'apprendre le latin.