ayuda con contador con displey de 7 seg y multiplexacion

[RockLee_89]

hola que tal gente del foro
necesito su ayuda para hacer este ejemplo es un contador acendente y decendente  con 2 pulsadores con 4 displey de 7 segmentos por el metodo de multiplexacion el compilador que utilizo es el
 basic (pic simulador ide) llevo varios dias rompiendome la cabeza de como hacerlo pero no encuentro la forma espero alguien con mas experiencia con los pic me pueda ayudar y tal vez asi ayudar a otros usarios del foro que no tenga idea de como hacerlo tengan un ejemplo ala mano.
saludos y adjunto lo que tengo

AllDigital

'DECLARACION DE LAS CONFIGURACIONES DE LOS PUERTOS
'_...................................................._
TRISA = %000000
TRISC = %00000000
TRISD = %00000011
'_...................................................._


'DECLARACION DE VARIABLES
'_...................................................._

Dim a1 As Word

Dim uni As Byte
Dim dec As Byte
Dim cen As Byte
Dim und As Byte
'_...................................................._

a1 = 0
uni = 0
dec = 0
cen = 0

PORTC = 0x40
RA.0 = 1
RA.1 = 1

inicio:


If RD.0 = 1 Then
h:
If RD.0 = 1 Then Goto h
a1 = a1 + 1

Endif

If RD.1 = 1 Then
l:
If RD.1 = 1 Then Goto l
a1 = a1 - 1
Endif


Gosub unidades
Gosub decenass
Goto inicio
End                                               

'SUBRUTINAS PARA LAS UNIDADES
unidades:
'_...................................................._
RA.0 = 0
If a1 = 9 Then uni = 0
PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), uni
RA.1 = 1
WaitMs 17
Return                                           
Goto unidades
'_...................................................._

'SUBRUTINAS PARA LAS DECENAS
'_...................................................._
decenass:
RA.1 = 0
PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), dec
RA.0 = 1
WaitMs 17
Return                                           
Goto decenass
'_...................................................._

'SUBRUTINAS PARA LAS CENTENAS
'_...................................................._
centenas:
PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), cen
WaitMs 17
Return                                           
Goto centenas
'_...................................................._

'SUBRUTINAS PARA LAS UNIDADES DE MILLAR
'_...................................................._
unidades_d_m:
RA.1 = 0
PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), und
RA.0 = 1
WaitMs 17
Return                                           
Goto unidades_d_m
'_...................................................._

[RockLee_89]

ya busque varias ejemplos en el buscador pero no son para psi el problema que se me da es para la hora de restar seguire buscando ejemplo o pensando como resolverlo espero alguien me inspire o me ayude a encontrar la solucion saludos

[dogflu66]

He realizado unos cuantos arreglos básicos.
La estructura del programa no es la correcta, pero por lo menos podrás ir avanzando.
He pegado dos funciones que son fundamentales para trabajar con los 7segmentos.
Si tienes alguna duda por aquí estare.
 

Código: FreeBasic

1. AllDigital
2. 'DECLARACION DE LAS CONFIGURACIONES DE LOS PUERTOS
3. '_...................................................._
4. TRISA = %000000
5. TRISC = %00000000
6. TRISD = %00000011
7. '_...................................................._
8. 'DECLARACION DE VARIABLES
9. '_...................................................._
10. Dim a1 As Word
11. Dim uni As Byte
12. Dim dec As Byte
13. Dim cen As Byte
14. Dim und As Byte
15. '_...................................................._
16. 'Asignaciones
17. a1 = 0
18. uni = 0
19. dec = 0
20. cen = 0
21. PORTC = 0x40
22. RA.0 = 1  'Unidades
23. RA.1 = 1  'Decenas
24. 'Rutina principal
25. main:
26.         If RD.0 = 1 Then
27.                 While RD.0 = 1
28.                 Wend
29.                 a1 = a1 + 1
30.         Endif
31.  
32.         If RD.1 = 1 Then
33.                 While RD.1 = 1
34.                 Wend
35.                 a1 = a1 - 1
36.         Endif
37.  
38.         Gosub unidades
39.         Gosub decenass
40.  
41. Goto main
42. End                                              
43.  
44. 'SUBRUTINAS PARA LAS UNIDADES
45. unidades:
46. '_...................................................._
47.         Dim digito As Byte
48.         If a1 > 99 Then a1 = 0
49.         uni = a1
50.         RA.1 = 0
51.         digito = _nmrbcd(uni, 0)
52.         PORTC = _nmr7seg(digito)
53.         RA.0 = 1
54.         WaitMs 17
55. Return                                            
56. 'Goto unidades
57. '_...................................................._
58. 'SUBRUTINAS PARA LAS DECENAS
59. '_...................................................._
60. decenass:
61.         Dim digito As Byte
62.         If a1 > 99 Then a1 = 0
63.         uni = a1
64.         RA.0 = 0
65.         digito = _nmrbcd(uni, 1)
66.         PORTC = _nmr7seg(digito)
67.         RA.1 = 1
68.         WaitMs 17
69. Return                                            
70. 'Goto decenass
71. '_...................................................._
72. 'SUBRUTINAS PARA LAS CENTENAS
73. '_...................................................._
74. centenas:
75.         PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), cen
76.         WaitMs 17
77. Return                                            
78. 'Goto centenas
79. '_...................................................._
80. 'SUBRUTINAS PARA LAS UNIDADES DE MILLAR
81. '_...................................................._
82. unidades_d_m:
83.         RA.1 = 0
84.         PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), und
85.         RA.0 = 1
86.         WaitMs 17
87. Return                                            
88. 'Goto unidades_d_m
89. '_...................................................._
90. '******************************************************
91. 'FUNCIONES PARA TRABAJAR CON DISPLAY DE 7 SEGMENTOS.
92. '******************************************************
93. 'Codigo BCD, decimal codificado en binario
94. 'Extrae el digito indicado, hasta 4 digitos (_nmrbcd=Word)
95. 'Extrae el digito indicado, hasta 10 digitos (_nmrbcd=Long)
96. 'numero = Cifra a descomponer
97. 'digito = Digito a extraer de 0 a 3 (_nmrbcd=Word)
98. 'digito = Digito a extraer de 0 a 9 (_nmrbcd=Long)
99. 'Los digitos se nombras de derecha a izquierda, cero es el primero
100. '_nmrbcd, retorna el digito.
101. Function _nmrbcd(_numero As Word, _digito As Byte) As Long
102.         'Descompone el numero a mostrar en digitos
103.         Dim _nn As Byte
104.         For _nn = 1 To _digito
105.                 _numero = _numero / 10
106.         Next _nn
107.         _nmrbcd = _numero Mod 10
108. End Function                                      
109. 'Numero a mascara tipo digito display 7 segmentos
110. 'numero = numero a procesar
111. '_nmr7seg, retorna la mascara de los segmentos a activar
112. Function _nmr7seg(_numero As Byte) As Byte
113.         _nmr7seg = LookUp(0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f), _numero
114. End Function

[RockLee_89]

Hola amigo dogflu66 gracias por tomarte tu tiempo y decirme como solucionar el multiplexado con los displey de 7 segmentos nunca e utilizado la opción funcion ya leí un poco sobre la instrucción esa solo que no me queda bien claro no sé si me puedas explicar un poco sobre ella tu  u otro usuario mas experimentado sepa como utilizarla.

Sé que funciona casi como una subrutina solo que no  la tienes que llamarla, pero como funciona solo al mencionar las variables que se encuentran dentro del funcion el se redirecciona hacia allá ejecuta lo que encuentra dentro de esa pequeña subrutina y luego retorna con los valores modificados y así, o estoy mal si así lo es corregirme no me molestare ya que estarán haciendo un gran bien  al explicarme bien el funcionamiento y así no me boy con un mala duda.

[dogflu66]

Las funciones como indicas son porciones de código independientes al programa. No se utilizan en ellas variables globales. Esto hace de ellas códigos fáciles de transportar de un programa a otro, en realidad es una forma de tener algoritmos fácilmente reutilizables en cualquier proyecto.

Estoy escribiendo un manual de programación moderna en Basic, basado en el basic del PSI, cuando lo termine ya indicaré de donde lo pueden bajar los que estén interesados en el tema.

[RockLee_89]

gracias amigo dogflu66 espero con ancias el manual    seguire con el programa para ver si lo logro funcionar
saludos

[Bregy]

Yo también quiero el manual. Me pasas el link cuando este listo...Tambien lo espero con ansias

[RockLee_89]

hola amigo dogflu66 queria preguntarte algo sobre el ejemplo este en el cual me ayudaste llevo dias tratando de entender como funciona esta parte no se si podrias explicarmela o alguien del foro que me pueda hechar una mano con esto

digito = _nmrbcd(uni, 0)
PORTC = _nmr7seg(digito)
Function _nmrbcd(_numero As Word, _digito As Byte) As Long

estas partes son las que me estan sacando las canas leei un poco sobre function se que es parte del programa al que puedes acceder pero veo que numero lo declaraste como word y digito como byte y a fuera esta todo como long asi que no se por que lo abras puesto asi, espero me puedes explica un poco de las 3 partes del programa que te deje.

saludos

[dogflu66]

Digito = _nmrbcd(uni, 0)

Las funciones hay que llamarlas igual que se llama a las rutinas, hay dos maneras de llamar a una función:

Mediante el comando de salto Call -> Call _nmrbcd(uni, 0) para posteriormente utilizar la variable _nmrbcd en la rutina principal.

Mediante la asignación a una variable o registro, variable sabemos lo que es, y un registro en general pude ser por ejemplo Portb, de todas manera una variable tambien es un registro solo que definido por el usuario.
Digito = _nmrbcd(uni, 0)
Portc = _nmr7seg(digito)

Digito se iguala al valor que retorna la función mediante la variable de salida _nmrbcd
Portc se iguala al valor que retorna la función mediante la variable de salida _nmr7seg.  

Así que:
Digito = _nmrbcd(uni, 0)
Uni es el número al que se le quiere extraer un digito.
0 indica el digito del extremo derecho de uni.
El digito deseado es almacenado en _nmrbcd y asignada una copia a digito.
'------------------------------------------------------------

Portc = _nmr7seg(digito)

Digito es el número del que se solicita la mascara de 7segmentos.
Que es asignada a Portc mediante _nmr7seg que contiene la mascara solicitada.

Function _nmrbcd(_numero As Word, _digito As Byte) As Long

"Long" no es todo eso, Long solo se refiere a la variable global _nmrbcd y que a su vez también es el nombre de la función. Lo que ocurre es que el tipo de dato que es _nmrbcd se pone al final de la sentencia, después de los paréntesis.

Después _nmrbcd se puede declarar como Long o como Word, como indica la cabecera de la función, como Long se declara cuando el numero tiene muchas cifras (más de dos bytes) y como Word cuando el numero ocupa hasta 2 bytes. Por supuesto el uso de la librería Long interna ocupa mucha más memoria que el uso de la librería Word. La declaración una u otra forma solo depende de las necesidades del programador.
'----------------------------------------------------------------

Un poco más sobre las funciones:

Como sabemos estamos hablando de lo que en otros lenguajes se llama función, es un código o algoritmo que realiza una tarea concreta y es un código muy transportable. En realidad tiene grandísimas ventajas con respecto a lo que llamamos subrutinas en el lenguaje Basic.

Para que realmente sean efectivas no se utilizan variables globales. Esto permite que su código sea realmente transportable. Las funciones en el Basic del PSI están dividas en dos, las que realizan la acción y retornan valor o resultado (Function) y las que realizan la acción pero no retornan valor o resultado (Proc).

Las funciones de tipo Proc están compuestas de un nombre, que no es más que una etiqueta, de esta forma nos podemos referir a ellas, lo que se llama “llamada a la función”, para llamarlas se utiliza el comando Call delante del nombre de la función. Al ser recomendado solo trabajar con variables globales en su cuerpo, la única forma de suministrarles los datos a su código es mediante registros de entrada (solo de entrada), estos registros de entrada se nombran y declaran entre los paréntesis que van a continuación del nombre de la función, estos registros son variables locales a la función (tienen que ser del tipo adecuado o compatible al valor que recibirán), por lo que sí intentamos utilizarlos desde cualquier lugar del código fuera de la función obtendremos un error. Estas variables a la hora de llamar a la función son sustituidas por constantes o por otras variables que suministran los datos necesarios demandados por su código, estos datos suministrados son copiados en las variables locales de entrada, por lo que cualquier operación interna que realice la función no modificará la fuente de los datos. Tanto el cuerpo de la función Proc y Function tiene que ser limitado o cerrado, mediante “End Proc” y por End Function respectivamente.

Las funciones de tipo Function cumplen con todo lo expuesto para las de tipo Proc, pero tienen una diferencia muy significativa. Está en el nombre de la función, este nombre no es una etiqueta, es una variable global al código. Hay que especificar el tipo de dato con el que trabajará y se especifica al final de la sentencia después de los paréntesis, esta variable se utiliza para retornar un valor interno a la función al resto del código, por lo que se deduce que las funciones declaradas con el comando Function sí retornan valor.

La función definida mediante el comando Function tiene dos formas de ser llamada con Call y otra mediante la asignación a una variable o registro.

Ejemplo:

Llamada mediante el comando de salto Call:
Call _nmrbcd(uni, 0)

Y la llamada mediante la asignación a una variable:
digito = _nmrbcd(uni, 0)
En este último el valor de retorno de la función mediante la variable global _nmrbcd, es asignado a la variable digito. _nmrbcd también es el nombre de la función, tiene doble utilidad.

Por último añadir que el número de registros o variables de entrada a las funciones (Function y Proc) están limitados en este lenguaje a cinco. Si se declaran más de cinco variables de entrada obtendremos un error.

----------------------------------------------------
Para cualquier pregunta más concreta estaré por aquí.

[dogflu66]

He paso las funciones a subrutinas, el codigo sigue haciendo lo mismo.
Si observas _numero y _numero1 tienen que nombarse de distinta forma porque ahora al ser variables globales no pueden duplicarse los nombres.
Cuando se trabaja con variables locales está permitido la duplicidad o tripicidad y etc de los nombres. Esta caracteristica permite pegar la función en
cualquier otro codigo, solo manteniendo el cuidado de no duplicar los nombres de las funciones.

Código: FreeBasic

1. Define SIMULATION_WAITMS_VALUE = 1  'Aumenta la velocidad de las pausas
2. AllDigital
3. 'DECLARACION DE LAS CONFIGURACIONES DE LOS PUERTOS
4. '_...................................................._
5. TRISA = %000000
6. TRISC = %00000000
7. TRISD = %00000011
8. '_...................................................._
9. 'DECLARACION DE VARIABLES
10. '_...................................................._
11. Dim a1 As Word
12. Dim uni As Byte
13. Dim dec As Byte
14. Dim cen As Byte
15. Dim und As Byte
16. '******************************************************
17. 'Variables de la rutinas
18. Dim _nmrbcd As Long
19. Dim _numero As Word
20. Dim _digito As Byte
21.  
22. Dim _nmr7seg As Byte
23. Dim _numero1 As Byte
24. '_...................................................._
25. 'Asignaciones
26. a1 = 0
27. uni = 0
28. dec = 0
29. cen = 0
30. PORTC = 0x40
31. RA.0 = 1  'Unidades
32. RA.1 = 1  'Decenas
33. 'Rutina principal
34. main:
35.         If RD.0 = 1 Then
36.                 While RD.0 = 1
37.                 Wend
38.                 a1 = a1 + 1
39.         Endif
40.  
41.         If RD.1 = 1 Then
42.                 While RD.1 = 1
43.                 Wend
44.                 a1 = a1 - 1
45.         Endif
46.  
47.         Gosub unidades
48.         Gosub decenass
49.  
50. Goto main
51. End                                              
52.  
53. 'SUBRUTINAS PARA LAS UNIDADES
54. unidades:
55. '_...................................................._
56.         Dim digito As Byte
57.         If a1 > 99 Then a1 = 0
58.         uni = a1
59.         RA.1 = 0
60.  
61.         _numero = uni
62.         _digito = 0
63.         Gosub nmrbcd
64.         digito = _nmrbcd
65.  
66.         _numero1 = digito
67.         Gosub nmr7seg
68.         PORTC = _nmr7seg
69.  
70.         RA.0 = 1
71.         WaitMs 17
72. Return                                            
73. 'Goto unidades
74. '_...................................................._
75. 'SUBRUTINAS PARA LAS DECENAS
76. '_...................................................._
77.  
78. decenass:
79.         Dim digito As Byte
80.         If a1 > 99 Then a1 = 0
81.         uni = a1
82.         RA.0 = 0
83.  
84.         _numero = uni
85.         _digito = 1
86.         Gosub nmrbcd
87.         digito = _nmrbcd
88.  
89.         _numero1 = digito
90.         Gosub nmr7seg
91.         PORTC = _nmr7seg
92.        
93.         RA.1 = 1
94.         WaitMs 17
95. Return                                            
96. 'Goto decenass
97. '_...................................................._
98. 'SUBRUTINAS PARA LAS CENTENAS
99. '_...................................................._
100. centenas:
101.         PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), cen
102.         WaitMs 17
103. Return                                            
104. 'Goto centenas
105. '_...................................................._
106. 'SUBRUTINAS PARA LAS UNIDADES DE MILLAR
107. '_...................................................._
108. unidades_d_m:
109.         RA.1 = 0
110.         PORTC = LookUp(0x40, 0x79, 0x24, 0x30, 0x19, 0x12, 0x02, 0x38, 0x00, 0x18), und
111.         RA.0 = 1
112.         WaitMs 17
113. Return                                            
114. 'Goto unidades_d_m
115. '_...................................................._
116. '******************************************************
117. 'FUNCIONES PARA TRABAJAR CON DISPLAY DE 7 SEGMENTOS.
118. '******************************************************
119. 'Codigo BCD, decimal codificado en binario
120. 'Extrae el digito indicado, hasta 4 digitos (_nmrbcd=Word)
121. 'Extrae el digito indicado, hasta 10 digitos (_nmrbcd=Long)
122. 'numero = Cifra a descomponer
123. 'digito = Digito a extraer de 0 a 3 (_nmrbcd=Word)
124. 'digito = Digito a extraer de 0 a 9 (_nmrbcd=Long)
125. 'Los digitos se nombras de derecha a izquierda, cero es el primero
126. '_nmrbcd, retorna el digito.
127. nmrbcd:
128.         'Descompone el numero a mostrar en digitos
129.         Dim _nn As Byte
130.         For _nn = 1 To _digito
131.                 _numero = _numero / 10
132.         Next _nn
133.         _nmrbcd = _numero Mod 10
134. Return                                            
135. 'Numero a mascara tipo digito display 7 segmentos
136. 'numero = numero a procesar
137. '_nmr7seg, retorna la mascara de los segmentos a activar
138. nmr7seg:
139.         _nmr7seg = LookUp(0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f), _numero1
140. Return

[RockLee_89]

hola amigo dogflu66  gracias por los ejemplos y aun mas por la explicacion en unos dias con mas calma los leeo y los practico antemano muchas gracias por tomarte parte de tu tiempo en ayudarme
saludos

[RockLee_89]

hola amigo dogflu66 ahora con nuevas dudas  espero y no te moleste   

sobre el proceso de las funciones y procesos me a quedado muy claro su funcionamiento tambien lo que te pregunte anterior mente ahora lo que me esta dando vueltas la cabeza y no se que tipo de magia utilizaste o mi ignorancia tan grande que no me hace comprender el funcionamiento de esta parte del codigo


Function _nmrbcd(_numero As Word, _digito As Byte) As Long    ///// entiendo que la funcion es llamada al ser invocada por el uso de la variable _nmrbcd que tu la declaraste
                                                                                             //// como tipo long _numero como word y _digito como byte. hasta hay todo bien ahora despues declaras la variable
   Dim _nn As Byte                                                    ///// _nn as byte  y dices que es=1 entonces si se supongo yo que _digito es =0 ya que no la inicializaste ningun
                                                                              / ///   valor entonces cuantas veces se ejecutara ese siclo for esa es mi primera  pregunta
For _nn = 1 To _digito                                                            ///    ahora _numero=_numero /10   si _numero=0 al no ser inicializada simpre tendra que ser 0 no es asi
                                                                                           ////    entonces como hace para tomar los valores de la tabla lookup
   _numero = _numero / 10

Next _nn

   _nmrbcd = _numero Mod 10                                  /// ahora esta otra _nmrbcd = _nmrbcd = _numero  mod  10 entonces como _numero=0  _nmrbcd sera =cero
End Function                                                                         ///  entonces la variable digito sera = a 0 siempre o como


espero y me puedas ayudar y no te pierdan mis preguntas confusas ya que este codigo en lo personal yo estan un poco raros para mi intelecto pero funcionan asi que no hay mas que aprender de un poco de tu razonamiento asi entendere mas en la programacion de pics

a una ultima duda ya carge el programa al pic y funciona solo que por ejemplo el numero a desplegar en los displey es 21 el numero 1 lo forma bien pero lo que es el numero 2 forma el 2 y ala vez el 1 pero con luz un poco mas apagado que le tendria que modificar para solucionarlo intente aumentando el tiempo pero no funciono 
espero me puedas ayudar

saludos

[dogflu66]

Se entiende que cuando _digito = 0 el bucle For es saltado, solo se ejecuta _nmrbcd = _numero Mod 10.

El resto es tan solo tomar lapiz y papel y realizar el recorrido de la función haciendo los calculos a mano.

Creo que te confundes;

A _nn le da el valor en todo momento el bucle For.
El hacer _nn = 1 antes del bucle For seria redundante, le demos el valor que le demos a _nn antes del bucle For es indiferente ya que el bucle For inicia esta variable con valor 1 y posteriormente se limita a incrementa en 1 su valor mientras el valor de _nn sea menor o igual al de _digito.

Y con respecto a _numero y a _digito en la función solo se declaran, su valor es suministrado desde fuera durante la llamada a la función.
Recuerda que cuando haces esto:

   digito = _nmrbcd(uni, 1)  esta línea es equivalente a estas tres + salto y retorno:
   digito =  _nmrbcd
   _numero = uni
   _digito = 1
   Gosub...... Return

   PORTC = _nmr7seg(digito) y esta es igual a estas otras dos + salto y retorno:
   PORTC = _nmr7seg
   _numero = digito
   Gosub...... Return

Recuerda que _numero de la primera función y _numero de la segunda función, son variables locales, por lo que son variables distintas aunque se llamen igual.

[dogflu66]

Sobre el tema de que un digito se ilumina más que otro, no te puedo ayudar, no tengo manera de probarlo fisicamente. Tengo un display de 4 digitos para hacer pruebas con la entrenadora Pic EBasic, que por un motivo u otro no llego a terminarlo. El problema que tienes es cuestion de experimentar.

Aqui te dejo otro ejemplo que realiza los calculos antes de llamar a la funcion del display:

Código: [Seleccionar]

Dim und As Byte
'_...................................................._
'Asignaciones
a1 = 55
uni = 0
dec = 0
cen = 0
PORTC = 0x40
RA.0 = 1  'Unidades
RA.1 = 1  'Decenas
'Rutina principal
Dim pause As Byte
pause = 17  'Tiempo que un digito permanece iluminado
main:
Dim dig_uni As Byte
Dim dig_dec As Byte

Call _wdisplay(dig_uni, dig_dec, pause)  'Escribe display
If RD.0 = 1 Then
While RD.0 = 1
Call _wdisplay(dig_uni, dig_dec, pause)  'Escribe display
Wend
a1 = a1 + 1
If a1 > 99 Then a1 = 0
Endif

If RD.1 = 1 Then
While RD.1 = 1
Call _wdisplay(dig_uni, dig_dec, pause)  'Escribe display
Wend
If a1 > 1 Then a1 = a1 - 1
Endif

dig_uni = _nmrbcd(a1, 0)  'Calcula digito 1
dig_dec = _nmrbcd(a1, 1)  'Calcula digito 2
Call _wdisplay(dig_uni, dig_dec, pause)  'Escribe display

Goto main
End                                               
'_...................................................._
'Funcion escribe display
'_...................................................._
Proc _wdisplay(_uni As Byte, _dec As Byte, _waitms As Byte)
'Unidades
RA.1 = 0
PORTC = _nmr7seg(_uni)
RA.0 = 1
WaitMs _waitms
'Decenas
RA.0 = 0
PORTC = _nmr7seg(_dec)
RA.1 = 1
WaitMs _waitms
RA.1 = 0
End Proc                                         
'_...................................................._
'******************************************************
'FUNCIONES PARA TRABAJAR CON DISPLAY DE 7 SEGMENTOS.
'******************************************************
'Codigo BCD, decimal codificado en binario
'Extrae el digito indicado, hasta 4 digitos (_nmrbcd=Word)
'Extrae el digito indicado, hasta 10 digitos (_nmrbcd=Long)
'numero = Cifra a descomponer
'digito = Digito a extraer de 0 a 3 (_nmrbcd=Word)
'digito = Digito a extraer de 0 a 9 (_nmrbcd=Long)
'Los digitos se nombras de derecha a izquierda, cero es el primero
'_nmrbcd, retorna el digito.
Function _nmrbcd(_numero As Word, _digito As Byte) As Long
'Descompone el numero a mostrar en digitos
Dim _nn As Byte
For _nn = 1 To _digito
_numero = _numero / 10
Next _nn
_nmrbcd = _numero Mod 10
End Function                                     
'Numero a mascara tipo digito display 7 segmentos
'numero = numero a procesar
'_nmr7seg, retorna la mascara de los segmentos a activar
Function _nmr7seg(_numero As Byte) As Byte
_nmr7seg = LookUp(0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f), _numero
End Function
La llamada a la rutina que escribe en el display tendria que ser llamada periodicamente por las interrupciones.
Call _wdisplay(dig_uni, dig_dec, pause)  'Escribe display

[RockLee_89]

Hola amigo dogflu66 se que ya te debo de tener fastidiado por tantas preguntas tontas, pero aun con tu explicaciones y estudiando no encuentro las respuestas
A mis dudas, ya tengo un montón de hojas donde es escrito el programa y no  encuentro respuestas.

Código: [Seleccionar]

Digito= _nmrbcd (uni,0 )

 al ala variable uni se le quiere extraer el digito que se encuentra ala derecho digamos que uni es =10 entonces extraeria el 0
Al ser llamado mediante la invocación de digito entro ala funcion declaro variables
 Y al ser _digito igual a cero salto el siclo for y solo ejecuto lo que es
_nmrbcd = _numero / 10 pero como _numero es = 0 entonces _nmrbcd sigue siendo cero
 
Portc = (digito)

Al ser digito = 0 entra ala otra funcion y toma de la tabla el valor _numero=0
Entonces el dato a visualizar en el puerto c va  a ser igual a cero


Ahora

Digito= _nmrbcd (uni,1 )

Ahora es = que antes solo que ahora _nmrbcd va a ser = 1 entra ala funcion declaro variables
 Y al ser _digito igual a cero salto el siclo for y solo ejecuto lo que es
_nmrbcd = _numero / 10 pero como _numero es = 0 entonces _nmrbcd es =1 por ser lo mismo que uni extrajo

Entra ala 2 funcion y como _numero es =0 saca otra vez cero entonces como formo el 1


Ahora
digito = _nmrbcd(uni, 1)  esta línea es equivalente a estas tres + salto y retorno:
   digito =  _nmrbcd       digito es = _nmrbcd si lo entiendo ya que es una copia del
mismo
     

   _numero = uni            y estas otras 2 funciones ya no las entiendo no se como te
basaste o que pero ya le busque yo y nomas no se como le   
haces
  _digito = 1
   Gosub...... Return


   PORTC = _nmr7seg(digito) y esta es igual a estas otras dos + salto y retorno:
   
PORTC = _nmr7seg       una copia de _nmr7seg   

   _numero = digito       y esto si no se como le hiciste
   Gosub...... Return

Espero estes bien y te agradesco por la ayuda que me brindas

Saludos