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

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]

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

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?

+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

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]

un petit up parce que je vois vraiment pas comment faire
 

up  

siouplait

c'est quoi ton microcontroleur ?
tu as une URL où il est décrit ?
A+

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]

ok merci je vais tester
faudrait que j arrive enfin a trouver si les nbres negatif sont bien traites comme ca
 
   
je te tiens au courant

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