Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1956 connectés 

 


Dernière réponse
Sujet : plus grand que plus petit que en assembleur HELP
bonzefou au fait si a=48 alors r1=r2=0
donc faut modifier  
 
si a=1  
a-48 = 11111111111111111111111111010001  
et  
48-a = 00000000000000000000000000101111  
il suffit donc de tester le bit de poids fort :  
 
tu stocke a-48 dans r1, 48-a dans r2  
 
tu fais r1 ET 10000000000000000000000000000000  
   si zero => a>=48 goto suite du programme pour a>=48  
        tu fais r2 ET 10000000000000000000000000000000  
            si zero => a=48 goto suite du programme pour a=48  
            sinon a>48  
 
  sinon a< 48  
 
ca doit etre ca :)

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse


[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 

Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
bonzefou au fait si a=48 alors r1=r2=0
donc faut modifier  
 
si a=1  
a-48 = 11111111111111111111111111010001  
et  
48-a = 00000000000000000000000000101111  
il suffit donc de tester le bit de poids fort :  
 
tu stocke a-48 dans r1, 48-a dans r2  
 
tu fais r1 ET 10000000000000000000000000000000  
   si zero => a>=48 goto suite du programme pour a>=48  
        tu fais r2 ET 10000000000000000000000000000000  
            si zero => a=48 goto suite du programme pour a=48  
            sinon a>48  
 
  sinon a< 48  
 
ca doit etre ca :)
bonzefou ok merci je vais tester
faudrait que j arrive enfin a trouver si les nbres negatif sont bien traites comme ca
 
 :jap:  
je te tiens au courant
JPA si tu compares avec des nombres faibles (40 et 48) celà ne me semble pas trop dur :
soit a le nombre à tester:
si a=1
a-48 = 11111111111111111111111111010001
et  
48-a = 00000000000000000000000000101111
il suffit donc de tester le bit de poids fort :
 
tu stocke a-48 dans r1, 48-a dans r2
 
tu fais r1 ET 10000000000000000000000000000000
si zero => a>48 goto suite du programme pour a>48
sinon a<= 48
tu fais r2 ET 10000000000000000000000000000000
si zero => a<48 goto suite du programme pour a<48
sinon a=48
 
A tester bien sur, mais celà me semble une base de départ.
 
A+
 
NB : ce test ne marchera pas bien sur si a est supérieur à 2^31+49, mais comme tu as dit que le nombre maxi était de l'ordre de 500, celà doit être OK

 

[jfdsdjhfuetppo]--Message édité par JPA--[/jfdsdjhfuetppo]

JPA c'est quoi ton microcontroleur ?
tu as une URL où il est décrit ?
A+
bonzefou siouplait :(
bonzefou up  :cry:
bonzefou un petit up parce que je vois vraiment pas comment faire
 :)
bonzefou justement ils sont pas signes
 
les registres font 32 bits
je compare par rapport a 40 et 48  
je pense que le nombre le plus gd sera de l ordre de 500
 
merci bcp pr ton aide

 

[jfdsdjhfuetppo]--Message édité par bonzefou--[/jfdsdjhfuetppo]

zi_ril_wanou

bonzefou a écrit a écrit :

merci bcp
 
la on sait que r1 et r2 sont differents ou pas  
mais pr savoir qui est le + gd?
 
 :jap:  




+gd avec des non signés, c'est toujours délicat... (-1 > 127 en non signé)
Détail moi tout ça : quelle est la taille de tes registres ?
Quelle est la valeur maximale que tu pense y mettre ?
 
Sinon, par exemple avec des signés sur 8 bits, c'est tout bête !
Le bit de poids fort de chacun d'eux est à 0.
donc :
r1 <- val1
r2 <- val2
r3 <- r1 - r2
 
r4 <- and(r3,0x10000000)
bnz R2_greater_than_R1
 
r3 <- r2 - R1
r4 <- and(r3,0x10000000)
bnz R1_greater_than_R2
 
ba  R1_equals_R2

bonzefou merci bcp
 
la on sait que r1 et r2 sont differents ou pas  
mais pr savoir qui est le + gd?
 
 :jap:
zi_ril_wanou

bonzefou a écrit a écrit :

voila
je dois faire de la compaison avec un microcon qui n a pas la fonction CMP et pas de negativ flag
j ai par contre ts les autres operateurs
 
qq un aurait il une idee pr m aider?
 
merci :)  




r1 <- val1
r2 <- val2
r2 <- not(r2)
r3 <- and(r1,r2)
bnz IF_<>
ba ELSE
...
 
Cà t'irait ??? (c'est du petit nègre, tu adaptes ensuite à ton assembleur)
 
en gros c'est équivalent en C à
 
int i,j;
 
i=val1;
j=val2;
 
j=j^0xFFFF; /* r2 = not(r2)*/
 
if ((i&j)!=0) /* bnz */  
   {...}
else  
   {...}

 

[jfdsdjhfuetppo]--Message édité par zi_ril_wanou--[/jfdsdjhfuetppo]

bonzefou voila
je dois faire de la compaison avec un microcon qui n a pas la fonction CMP et pas de negativ flag
j ai par contre ts les autres operateurs
 
qq un aurait il une idee pr m aider?
 
merci :)

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR