TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: Mrpic en 30 de Junio de 2006, 00:36:32

Título: RESTA DE 32BITS CON SIGNO
Publicado por: Mrpic en 30 de Junio de 2006, 00:36:32
lo que sucede es que necesito realizar una resta
que da  resultado negativo, es decir por ejemplo (8-16), bueno yo se que esta es muy facil ya que es de 8 bits
y se que solo bastaria con mirar el bit "C" del status para saber que es negativa. el problema es
que en mi programa a veces no necesito restar solo 8 bits sino tambien 32; razon por la cual empeze a utilizar
una subrutina de resta de 32bits que me baje de
http://www.piclist.com/techref/microchip/math/32bmath-ph.htm
ya que esta tambien podria efectuar restas de 8 bits, claro esta colocando los otros 3 registros
que esta usa; hice las pruebas pertinentes y la subrutina funciona perfectamente cuando son restas normales
es decir de resultado positivo, pero cuando se trata de restas como por ejemplo (5-6) o (7000-1400).. etc
no funciona bien, ya que esta subrutina me entrega en 4 registros el resultado y cuando efectuo dichas restas
el resultado que me entrega no es el esperado sino por ejemplo:

  01101101011000 -----> 7000
- 11011010110000
____________________
  10010010101000

analizandolo yo se que ese resultado sacandole el complemento a dos da el resultado esperado, pero entonces mi pregunta es
en el programa yo necesito saber si el resultado es negativo o positivo porque depende de ese resultado tengo que hacer otras cosas
y mirando el status despues de que me entrega este resultado veo que el bit "C" no se altera para mostrarme que es negativo solo me saca ese resultado
que mostre y nada mas, yo podria hacer lo del complemento a dos, pero como le defino yo al pic cuando si y cuando no hacerlo.
otra cosa, haciendo varias pruebas veo que funciona perfecto, es decir me activa el bit "C" y me muestra el resultado correcto sin sacar complementos
cuando hago restas de numeros muy grandes por ejemplo:

  01000000000000000000000000000000 ---------> 1073741824
- 10000000000000000000000000000000 ---------> 2147483648

si algien me puede ayudar por favor se lo agradeceria mucho, estoy programando en ASM y con un pic16f877.
no me explico porque no funciona ya que las otras rutinas que hay funcionan perfecto y ademas se supone que esta rutina es una resta con signo
pues segun lo que ahi dice tiene un registro que me indica el signo.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Chaly29 en 30 de Junio de 2006, 03:55:16
Hola Mrpic, aqui te dejo una rutina para realizar restas en 32 bit, revisando el carry al finalizar la resta sabras si el resultado es negativo o positivo tal cual si fuera una resta de 8 bit.

Código: ASM
  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;
  3. ;              Resta de 32 bit - 32 bit con CARRY
  4. ;
  5. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  6.  
  7. ; Variables a definir en la RAM
  8.  
  9. CARRY   EQU     .32
  10.  
  11. DATO1   EQU     .33     ; dato 1 (8 bits + significativos)
  12. DATO2   EQU     .34     ;
  13. DATO3   EQU     .35     ;
  14. DATO4   EQU     .36     ; dato 1 (8 bits - significativos)
  15.  
  16. FUNC1   EQU     .37     ; dato 2 (8 bits + significativos)
  17. FUNC2   EQU     .38     ;
  18. FUNC3   EQU     .39     ;
  19. FUNC4   EQU     .40     ; dato 2 (8 bits - significativos)
  20.  
  21. RES1    EQU     .41     ; resultado (8 bits + significativos)
  22. RES2    EQU     .42     ;
  23. RES3    EQU     .43     ;
  24. RES4    EQU     .44     ; resultado (8 bits - significativos)
  25.  
  26. ;.............................................................................
  27.  
  28. RESTA                           ;32 - 32
  29.         clrf    CARRY
  30.  
  31.         comf    DATO4,W
  32.         addwf   FUNC4,W
  33.         movwf   RES4
  34.         btfsc   STATUS,C
  35.         incfsz  FUNC3,F
  36.         goto    IOP1
  37.         incfsz  FUNC2,F
  38.         goto    IOP1
  39.         incfsz  FUNC1,F
  40.         goto    IOP1
  41.         bsf     CARRY,0
  42. IOP1   
  43.         comf    DATO3,W
  44.         addwf   FUNC3,W
  45.         movwf   RES3
  46.         btfsc   STATUS,C
  47.         incfsz  FUNC2,F
  48.         goto    IOP2
  49.         incfsz  FUNC1,F
  50.         goto    IOP2
  51.         bsf     CARRY,0
  52. IOP2
  53.         comf    DATO2,W
  54.         addwf   FUNC2,W
  55.         movwf   RES2
  56.         btfsc   STATUS,C
  57.         incfsz  FUNC1,F
  58.         goto    IOP3
  59.         bsf     CARRY,0
  60. IOP3
  61.         comf    DATO1,W
  62.         addwf   FUNC1,W
  63.         movwf   RES1
  64.         btfsc   STATUS,C
  65.         bsf     CARRY,0
  66.  
  67.         bcf     STATUS,C
  68.         btfss   CARRY,0
  69.         bsf     STATUS,C       
  70.         comf    RES4,F
  71.         comf    RES3,F
  72.         comf    RES2,F
  73.         comf    RES1,F
  74.         return
  75.  
  76. ;.............................................................................

Espero te sea de utilidad, un saludo.

Atte. CARLOS.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: maunix en 30 de Junio de 2006, 08:09:41
Mrpic es cierto que no es tan intuitivo hacer estas rutinas cuando uno trabaja en ensamblador pero es lo que tienen que resolver nuestros amigos que hacen los compiladores de C cuando se enfrentan a una nueva arquitectura.  :? :?

Como observación fíjate que en la rutina que subió Carlos, él se refiere a CARRY como variable y no al bit C del STATUS.  :mrgreen:


Saludos
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Chaly29 en 30 de Junio de 2006, 14:12:35
Hola maunix, fijate que al final de la rutina yo modifico el Carry del Status, por lo tanto yo me refiero al carry del status y no como una variable, nuevamente y como ya lo e dicho, usas esta rutina como si se tratara de solo 8 bits, pero en este caso es de 32 bit.

Un saludo.

Atte. CARLOS.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: BrunoF en 30 de Junio de 2006, 14:52:50
No se empiecen a confundir muchachos. Charly, Maunix se refirio a la variable CARRY que creaste y usas para transportar el valor del carry que luego volcas en el registro STATUS,C.Por lo tanto, estan hablando de cosas distintas, aunque los dos estan en lo correcto.
Saludos.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: maunix en 30 de Junio de 2006, 15:45:16
Cita de: BrunoF en 30 de Junio de 2006, 14:52:50
No se empiecen a confundir muchachos. Charly, Maunix se refirio a la variable CARRY que creaste y usas para transportar el valor del carry que luego volcas en el registro STATUS,C.Por lo tanto, estan hablando de cosas distintas, aunque los dos estan en lo correcto.
Saludos.

jeje, Bruno gracias por defenderme pero creo que esta vez tiene razón Carlos.  :) :)

Es cierto que hablabamos de cosas diferentes, yo me refería a la variable CARRY pero en la rutina a último momento se vuelva le resultado de CARRY sobre la variable STATUS,C. 

Sería lo mismo chequear la variable CARRY,0 pero creo que este movimiento está hecho así para que sea "transparente" a cualquier código y usemos esa rutina de la misma forma que estamos acostumbrados a usar las rutinas de 8 bits.

Entonces hacer una resta de 8 bits o de 32 bits, en ambos casos al final de la subrutina verificaremos el STATUS,C independientemente de como veniamos trabajando.

 :) :)

Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Chaly29 en 30 de Junio de 2006, 20:34:14
Hola maunix, efectivamente es como tu lo comentas, si bien ese metodo alarga un poquito la rutina, es más facil de manejar por el echo de que la tratas como si fuera una resta de 8 bits.

Un saludo.

Atte. CARLOS.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Mrpic en 01 de Julio de 2006, 03:09:33
Muchas gracias  Chaly29 por la rutina me ha sido de gran utilidad, funciona perfecto.
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Leon Pic en 20 de Noviembre de 2008, 00:15:33
Por alguna extraña razón, este programa no me funcionaba. Me sumaba los resultados en vez de restarlos :shock:

He realizado una propia basándome en como funciona el programa de CHARLY

Código: ASM
  1. es_negativo     EQU             H'20'
  2.  
  3. sub1    EQU             H'30'   ; dato 1 (8 bits + significativos)
  4. sub2    EQU             H'31'   ;
  5. sub3    EQU             H'32'   ;
  6. sub4    EQU             H'33'   ; dato 1 (8 bits - significativos)
  7.  
  8. min1    EQU             H'34'   ; dato 2 (8 bits + significativos)
  9. min2    EQU             H'35'   ;
  10. min3    EQU             H'36'   ;
  11. min4    EQU             H'37'   ; dato 2 (8 bits - significativos)
  12.  
  13. res1    EQU             H'40'   ; resultado (8 bits + significativos)
  14. res2    EQU             H'41'   ;
  15. res3    EQU             H'42'   ;
  16. res4    EQU             H'43'   ; resultado (8 bits - significativos)
  17.  
  18. ;.............................................................................
  19.  
  20.  
  21. RESTA   CLRF            es_negativo
  22.                 MOVFW           sub4
  23.                 SUBWF           min4,F
  24.                 BTFSC           STATUS,C        ;¿HUBO ACARREO?
  25.                 GOTO            IOPA            ;NO,
  26.                 COMF            min4,W          ;SI, REALIZO EL COMPLEMENTO
  27.                 ADDLW           .1
  28.                 MOVWF           res4            ;Y LO VUELCO AL RESULTADO FINAL
  29.                 INCFSZ          min3
  30.                 GOTO            IOP1
  31.                 INCFSZ          min2
  32.                 GOTO            IOP1
  33.                 INCFSZ          min1
  34.                 GOTO            IOP1
  35.                 BSF                     es_negativo,0
  36.                 GOTO            IOP1
  37. IOPA    MOVFW           min4
  38.                 MOVWF           res4
  39. IOP1    MOVFW           sub3
  40.                 SUBWF           min3,F
  41.                 BTFSC           STATUS,C
  42.                 GOTO            IOPB
  43.                 COMF            min3,W
  44.                 ADDLW           .1
  45.                 MOVWF           res3
  46.                 INCFSZ          min2
  47.                 GOTO            IOP2
  48.                 INCFSZ          min1
  49.                 GOTO            IOP2
  50.                 BSF                     es_negativo,0
  51.                 GOTO            IOP2
  52. IOPB    MOVFW           min3
  53.                 MOVWF           res3
  54. IOP2    MOVFW           sub2
  55.                 SUBWF           min2,F
  56.                 BTFSC           STATUS,C
  57.                 GOTO            IOPC
  58.                 COMF            min2,W
  59.                 ADDLW           .1
  60.                 MOVWF           res2
  61.                 INCFSZ          min1
  62.                 GOTO            IOP3
  63.                 BSF                     es_negativo,0
  64.                 GOTO            IOP3
  65. IOPC    MOVFW           min2
  66.                 MOVWF           res2
  67. IOP3    MOVFW           sub1
  68.                 SUBWF           min1,F
  69.                 BTFSC           STATUS,C
  70.                 GOTO            IOPD
  71.                 COMF            min1,W
  72.                 ADDLW           .1
  73.                 MOVWF           res1
  74.                 BSF                     es_negativo,0
  75.                 RETURN
  76. IOPD    MOVFW           min1
  77.                 MOVWF           res1
  78.                 RETURN

Me imagino que se puede mejorar, pero es todo lo que puedo hacer por ahora que tengo mucho sueño (son las 12:15 am).
Título: Re: RESTA DE 32BITS CON SIGNO
Publicado por: Leon Pic en 07 de Enero de 2009, 20:06:51
Corrigo. Algo de seguro estaba haciendo mal, por que ahora me funciona. Desconozco que estaba haciendo mal porque jamás lo descubri, pero no es el primer error misterioso que me ocurrió. Por ahora le estoy echando la culpa al MPLAB y que seguro no debe ser compatible con Vista 32. En fin. Para resumir, la rutina de charly, funciona muy bien.