¿Cómo se representar números decimales en displays?

[Lorenzo]

Hola, ¿cómo se se guarda un número de dos dígitos decimales en un byte, es decir, en ocho bits, ya se que se dividen en dos unidades de 4 dígitos,pero como se va incrementando y se van guardando en ese byte?
Gracias y saludos.

[maunix]

Hola, ¿cómo se se guarda un número de dos dígitos decimales en un byte, es decir, en ocho bits, ya se que se dividen en dos unidades de 4 dígitos,pero como se va incrementando y se van guardando en ese byte?
Gracias y saludos.

Lo que yo hago es guardarlo siempre como un número de 1 byte, normal (no en BCD) y lo convierto a BCD cuando lo tengo que mostrar pero siempre la matemática involucrada es tradicional.

Si lo que tu pretendes es usar matemática toda en BCD ese es ooootro gran tema, y no he visto por aquí rutinas completas que te permitan hacer sumas, restas, multiplicaciones y divisiones trabajando completamente con variables en BCD.

Espero haber dado respuesta a tu pregunta.

Saludos

[Lorenzo]

Hola maunix, gracias por contestar a este y el otro mensaje. Yo quiero hacer un contador del 0 al 99, y utilizar un solo archivo, empiezo en cero y lo voy incrementado y lo voy guardando en dicho archivo, cuando llego a 9, en binaqrio se representa por 00001001, pero al volver a incrementarlo en una unidad más, el decimal a representar sería el diez, pero éste en binario es 0001010, pero ¿cómo lo guardaría para representarlo en dos displays, el uno por un lado y el cero por otro, qué subrutina utilizaría? Espero haberme explicado bien.
Gracias y saludos.

[eldavids]

Hola Lorenzo, lo que debes hacer es que al momento que desees representar tu numero binario en dos displays, transformas ese binario a dos digitos BCD y envias a cada display el numero BCD correspondiente. no te preocupes por guardar el los numeros BCD, simplemente guarda el binario y transformalo cuando necesites mostrarlo.



saludos

[maunix]

Hola Lorenzo, lo que debes hacer es que al momento que desees representar tu numero binario en dos displays, transformas ese binario a dos digitos BCD y envias a cada display el numero BCD correspondiente. no te preocupes por guardar el los numeros BCD, simplemente guarda el binario y transformalo cuando necesites mostrarlo.
saludos

eldavids exactamente eso fue lo que le sugerí en mi anterior post 

Lorenzo tal vez no lo comprendes pero la mejor forma de hacer lo que pretendes hacer es guardarlo binariamente como un 10! osea 00001010 y al momento de tenerlo que sacar en los 2 displays, lo conviertes a BCD.

Entonces, por ejemplo

NUMERO = 00001010

Cada vez que NUMERO se modifica, ejecutas la rutina de convertir a BCD.

NUMERO --> BCD

Esa rutina te debiera devolver como resultado DIG1 y DIG2.  El DIG1 sería Dígito de las Unidades y el DIG2 el dígito de las decenas.  NUMERO seguirá siendo 00001010 !  Las operaciones sobre NUMERO serán las convencionales! y solo se afectara DIG1 y DIG2 cuando ejecutes la rutina de conversión.

Aclaro que es solo un ejemplo, tu podrías usar cualquier nombre de variable que se te ocurra.

Espero hayas entendido ahora el punto.

[microcom]

caballero lo que tienes que hacer es  dividir por diez todo el contador y te saldran las unidades y decenas que despues tienes que convertirlas en  siete segmentos con rutina tabla

[Lorenzo]

Hola a todos, lo que me comentais de guardarlo en binario y después transformarlo en BCD lo comprendo, lo que no sé es transformar un número binario, por ejemplo, el 10101 en binario a BCD en 21, o mejor dicho la rutina o el hardware para representarlo en dos displays, ya que traqnsformar número a diferente sistemas si lo sé hacer.
Gracias y saludos.

[microcom]

caballero aqui un programa que incrementa hasta 99 sin tener que increnmentar unidades despues decenas etc este es mas complicadoo que el que dice viejo maunix.

;DECLARACION DE VARIABLES
BENI   EQU   10
REG1   EQU   11
REG2   EQU   12
REG3   EQU   13
VALOR1   EQU   14
VALOR2   EQU   15
SAT   EQU   16
decenas   EQU   17
unidad   EQU   18
RESTA   EQU   19
porta   EQU   05
PORTB   EQU   06
STATUS   EQU   03
PCL   EQU   02
CONTA   EQU   21   
BEN   EQU   22
MACGY   EQU   23


   ORG   00
   GOTO   INICIO

RETARDO   return
   MOVLW   .9
   MOVWF   REG1
DEC3   MOVLW   .9
   MOVWF   REG2
DEC2   MOVLW   .5
   MOVWF   REG3
DEC1   DECFSZ   REG3,1
   GOTO   DEC1
   DECFSZ   REG2,1
   GOTO   DEC2
   DECFSZ   REG1,1
   GOTO   DEC3
   RETURN
   
tabla     ADDWF   PCL,1
   RETLW   B'11000000'
   RETLW   B'11111001'
   RETLW   B'10100100'
   RETLW   B'10110000'
   RETLW   B'10011001'
   RETLW   B'10010010'
   RETLW   B'10000010'
   RETLW   B'11111000'
   RETLW   B'10000000'
   RETLW   B'10011000'
   RETLW   B'10111111'

;CONFIGURACION DE PUERTOS

   
inicio   bsf   status,5
      movlw   b'000000'   ;para transistores
       movwf   porta
      clrf      portb
       bcf      status,5
      clrf      portb
      clrf      decenas
      clrf      unidad

SHORT   CLRF   CONTA   
   CLRF   decenas
   MOVF   CONTA,0
   MOVWF   unidad
         call      tabla
         bcf      porta,2
         movwf   portb
         call      retardo
         bsf      porta,2
         movf      decenas,0
         call      tabla
         bcf      porta,3
         movwf   portb
         call      retardo
         bsf      porta,3
         bsf      porta,2

      
RER   INCF   CONTA,1
   CLRF   decenas
   MOVF   CONTA,0
   MOVWF   BENI
   MOVLW   .100
   XORWF   CONTA,0
   BTFSS   STATUS,2
   GOTO   SHET
   GOTO   SHORT
SHET   MOVLW   .10                                                               
   SUBWF   BENI,1
   BTFSC   STATUS,0
   GOTO   SUICHE
   MOVLW   .10
   ADDWF   BENI,0
   MOVWF   unidad
   MOVF   unidad,0
   call      tabla
         bcf      porta,2
         movwf   portb
         call      retardo
         bsf      porta,2
         movf      decenas,0
         call      tabla
         bcf      porta,3
         movwf   portb
         call      retardo
         bsf      porta,3

   GOTO   RER
SUICHE   INCF   decenas,1
   GOTO   SHET   
   
END   

[microcom]

lo que se hace es lo siguiente lo usual es que al llegar a 10 ya seria una decenas y cero unidades y mostrarias por tabla el 1 y despues el cero.
luego uncrementas las unidades y seria 11, hasta llegar a 9 unidades despues de 9 unidades< borrarias estas y incrementarias las decenas y seria 20 ya asi sucesivamente.

lo que yo hice fue lo contrario boy incrementando el contador 1,2,3456789,10,11,12,13,14 y despues de esto divido el contador por 10 para saber cuantas decenas hay y cuantas unidades me quedan
por ejemplo 43, si yo lo divido por 10 serian 4 decenas y 3 unidades
las cuales son las que se van a mostrar en los displays por la rutina tabla que contiene los segmentos que deben prenderse para mostrar el indicado numero ejemplo 1  prenderian los segmentos b y c

[microcom]

Este es un contador de 0 a 99 la salida es por el puertob
display de anodo comun
2 transistores 3904
emisor a  vcc
colector a comun de display
resistencias de 220ohm para segmentos display
base de  transistor a salidas del puertoa ra2 y ra3.
 
   list    p=16f84A
           include"p16f84A.INC"

con1      equ   0x0c
con2      equ   0x0d
con3      equ   0x0e
unidades   equ   0x0f
temp      equ   0x11
porta      equ   0x05
portb      equ   0x06
status      equ   0x03
pcl      equ   0x02     
intcon      equ   0x0b
z      equ   0x02
trisa      equ   85h
trisb      equ   86h
   

      org   0
      goto   inicio
      org   5

retardo      movlw   .1      ;30
      movwf   con3
c_con2      movlw   .1      ;100
      movwf   con2
repeat      decfsz   con2,f
      goto   repeat
      decfsz   con3,f
      goto   c_con2   
      return         ;termino subrutina de retardo

           

tabla    addwf   pcl,f
      retlw   b'00111111';0
      retlw   b'00000110';1
      retlw   b'01011011';2
      retlw   b'01001111';3
.      retlw   b'01100110';4
      retlw   b'01101101';5
      retlw   b'01111100';6
      retlw   b'00000111';7
      retlw   b'01111111';8
      retlw   b'01100111';9

visu  movf      unidad,0
      call      tabla
      bcf      porta,2
      movwf   portb
      call      retardo
      bsf      porta,2
              movf      decenas,0
      call      tabla
      bcf      porta,3
      movwf   portb
      call      retardo
      bsf      porta,3
      return
return

inicio      bsf   status,5
      movlw   b'00000'       
      movwf   trisa
      movlw   b'00000000'   portb     salida para segmentos del display
      movwf   trisb   
      bcf   status,5   
      clrf   unidades
      clrf   decenas
   
   
ciclo call   visu
     
      incf   unidades,1
      movlw   .10
      xorwf   unidades,w
      btfss   status,z
      goto   siclo
      clrf   unidades    ;cuando las unidades son 10 entonces es 1 decenas
      incf   decenas,1   ;1 decenas y cero unidades   
      movlw  .10
      xorwf  decenas,0
      btfss  status,2
      goto   ciclo       ;fin de conteo 9 decenas y 9 unidades
      clrf  decenas     
      clrf  unidades
      goto  ciclo
     


      end

cada que las unidades lleguen a 10 las decenas se incrementn a 1 y las unidades se borran  para empazar a contar y asi sucesivamente .
para 18 seran   1 decena y 8 unidades   para el 19  lo mismo
para el 20 ya he incrementado 1 decenas y haber borrado las unidades para empezar con estas nuenvamente. 21 22 23
29  2 decenas y 9 unidades  cuando estas ultimas pasen a 10  se borran e incremento las decenas para 3 y sera 30.
espero haber ayudado

[Marioguillote]

Hola amigos:

A ver Lorenzo si es algo de esto lo que estás buscando ...

http://www.todopic.com.ar/foros/index.php?topic=3613.msg62408#msg62408

Espero te sirva

Saludos a todos.

Mario

[Manofwar]

Hola Lorenzo

Si te decides por guardar en un sólo byte el valor de 2 dígitos, aquí tienes el código que lo hace y lo envía al display

Código: ASM

1. CONTADOR        equ 0x20
2.  
3.  
4.         ORG 0
5.  
6.  
7.         clrf    CONTADOR
8.  
9. inicio 
10.         incf    CONTADOR,F      ;Incrementamos el contador
11.  
12.         btfss   CONTADOR,3      ;Si el bit 3
13.         goto    display         ;y el bit 1
14.         btfss   CONTADOR,1      ;del contador
15.         goto    display         ;son 1 (10 en binario)
16.         movlw   0x06            ;sumamos 6 a las unidades
17.         addwf   CONTADOR,F      ;para incrementar las decenas
18.  
19.         btfss   CONTADOR,7      ;Si el bit 7
20.         goto    display         ;y el bit 5
21.         btfss   CONTADOR,5      ;del contador
22.         goto    display         ;son 1 (100 en binario)
23.         movlw   0x60            ;sumamos 6 a las decenas
24.         addwf   CONTADOR,F      ;asi pasamos a cero todo el contador
25.  
26.  
27. display
28.  
29.         movf    CONTADOR,W      ;Presentamos en
30.         andlw   0x0F            ;el display el
31.         call    tabla_segmentos ;valor de las
32.         movwf   PORTA           ;decenas
33.  
34.         swapf   CONTADOR,W      ;Presentamos en
35.         andlw   0x0F            ;el display el
36.         call    tabla_segmentos ;valor de las
37.         movwf   PORTB           ;centenas
38.  
39.  
40.         goto    inicio
41.  
42. tabla_segmentos
43.  
44.         addwf   pcl,f
45.         retlw   b'00111111';0
46.         retlw   b'00000110';1
47.         retlw   b'01011011';2
48.         retlw   b'01001111';3
49.         retlw   b'01100110';4
50.         retlw   b'01101101';5
51.         retlw   b'01111100';6
52.         retlw   b'00000111';7
53.         retlw   b'01111111';8
54.         retlw   b'01100111';9
55.  
56. END

Deberás de adaptarlo a tu programa pero creo que te será de utilidad.