CALL vs RETURN

[microcom]

supuestamente  hablaN que despues de un call debe venir un return y si no es asi que pasa?
puesto que si yo acciono un pulsador en preguntas ese return no se ejecuta.
esto lo hice una vez para que un pulsador quedará sencibles a la pulsada.
o de que otra manera ese  pulsador puede quedar sensible  que el pic lo atienda inmediatamente.
ejemplo:
 
call retardo

retardo

         movlw .250
        movwf reg1
        decfsz  reg1
        goto  preguntas
        return

preguntas
       btfsc porta,0
       goto   rot1
       btfsc porta,1
       goto   rot2
       btfsc porta,2
       goto   rot3
       goto   retardo

gracias caballeroS.
le agradesco la colaboracion

[maunix]

supuestamente  hablaN que despues de un call debe venir un return y si no es asi que pasa?

El call carga en la PILA (o stack) la dirección desde donde se está llamando a la subrutina.  Esto permite que al ejecutar RETURN el PIC tome esa dirección+1 para seguir ejecutando instrucciones (o +2 en caso de los PIC18). 

El return no tiene que venir necesariamente después del call, debe venir en "algun momento" a los fines de que el pic vacíe su stack y el software siga su curso normal.

El CALL se usa para llamar a una subrutina pero el software debe continuar donde estamos y no en otro lado.   Es un "salto con memoria" por decirlo así, que nos permite volver al punto inmediato después de donde estabamos antes de llamar a la subrutina.

El GOTO en cambio es un salto a otro lugar, pero no tiene 'registro o referencia' desde donde venía.

puesto que si yo acciono un pulsador en preguntas ese return no se ejecuta.
esto lo hice una vez para que un pulsador quedará sencibles a la pulsada.
o de que otra manera ese  pulsador puede quedar sensible  que el pic lo atienda inmediatamente.
ejemplo:
 
call retardo

retardo

         movlw .250
        movwf reg1
        decfsz  reg1
        goto  preguntas
        return

preguntas
       btfsc porta,0
       goto   rot1
       btfsc porta,1
       goto   rot2
       btfsc porta,2
       goto   rot3
       goto   retardo

En tu caso, haces un call a "retardo".  Inmediatamente en retardo, pones una variable en 250 y la decrementas.  Si la variable es 0, haces el RETURN y el software regresa a la instrucción justo por debajo de "call retardo" (en este pequeño ejemplo volvería a ejecutar retardo: porque no hay mas instrucciones después de call retardo)

Sigamos analizando.  Si RA0, RA1 o RA2 están en 1, el flujo del programa seguirá por rot1, rot2 y rot3.  Si nunca nunca se hace un return, el stack quedará cargado con un valor que no tiene mayor sentido.

No se qué se haga en rot1, rot2 y rot3, pero lo más certero sería que en esa parte "haga algo" y luego haga un return, para volver justamente a donde se llamó a la subrutina.

Espero haber aclarado la duda, sino, vuelve a preguntar.   

[microcom]

bueno muy bien entendido caballero.
al momento de ejecutar el call y no el  return de ese call y el programa sigue y para estar seguro de que ese return que no hice no me afecte el programa como se haria para eliminar ese return que queda esparando en el call.

se que es confusa la pregunta

gracias caballero.

[maunix]

bueno muy bien entendido caballero.
al momento de ejecutar el call y no el  return de ese call y el programa sigue y para estar seguro de que ese return que no hice no me afecte el programa como se haria para eliminar ese return que queda esparando en el call.

se que es confusa la pregunta

gracias caballero.

Es que en ese caso, no debieras usar el call, sino un GOTO.   

Si no quieres hacer 'return' llamar a la subrutina con un goto. 

Si quieres hacer un call para que en algun momento vuelva a donde lo llamaste, debieramos ver otro ejemplo porque el qu e subiste está incompleto.   

[microcom]

ahi va caballero.

retardo
   movlw   .200
   movwf   contador
ggg   decfsz  contador,1
   goto     ooo
   return
ooo   btfsc     porta,1
   goto    PRIMER_ROT
           btfsc     porta,2
   goto   SEGUNDO_ROT
   btfsc     porta,3
   goto    TERCER_ROT
   goto       ggg       
     

   

UNO_SEG 
   movlw     .14       
          movwf     PDel0   
PLoopx    movlw     .72   
           movwf     PDel1   
PLoopy     movlw     .247     
           movwf     PDel2 
PLoopz     clrwdt             
   btfsc     porta,0
   goto      FIJO   
           btfsc     porta,2
   goto   SEGUNDO_ROT
   btfsc     porta,3
   goto   TERCER_ROT
   decfsz    PDel2, 1 
           goto      PLoopz   
           decfsz    PDel1,  1
          goto      PLoopy   
          decfsz    PDel0,  1
           goto      PLoopx   
PDelL1     goto PDelLx       
PDelLx     clrwdt             
        return             


TRES_SEG  
   movlw     .67     
           movwf     PDel0   
PLoop0     movlw     .91     
           movwf     PDel1   
PLoop1     movlw     .122   
           movwf     PDel2     
PLoop2     clrwdt           
   btfsc     porta,0
   goto     FIJO   
                btfsc     porta,1
   goto   PRIMER_ROT
   btfsc     porta,3
   goto   TERCER_ROT
           decfsz    PDel2, 1
           goto      PLoop2 
          decfsz    PDel1,  1
           goto      PLoop1   
           decfsz    PDel0,  1
           goto      PLoop0   
PDelL6     goto PDelL2       
PDelL2     clrwdt             
           return       

CINCO_SEGUNDOS 
   movlw     .165     
           movwf     PDel0   
PLoopv     movlw     .41     
          movwf     PDel1   
PLoopw  movlw     .147     
           movwf     PDel2   
PLoopm  clrwdt           
           clrwdt             
   btfsc     porta,0
   goto      FIJO  
                btfsc     porta,1
   goto    PRIMER_ROT
   btfsc     porta,2
   goto    SEGUNDO_ROT
           decfsz    PDel2, 1
           goto      PLoopm   
           decfsz    PDel1,  1
           goto      PLoopw   p
           decfsz    PDel0,  1
           goto      PLoopv   
           return             



EMPEZAR                         
                  btfss     porta,0         
                goto      UNO_ROT
   call       anti
   btfss     porta,0
   goto      UNO_ROT 
                goto  FIJO
UNO_ROT  btfss     porta,1       
               goto     DOS_ROT
   call       anti
   btfss     porta,1     
   goto       DOS_ROT
                goto       PRIMER_ROT

DOS_ROT  btfss     porta,2       
                  goto      TRES_ROT   
                call      anti
   btfss     porta,2     
   goto       TRES_ROT
                  goto      SEGUNDO_ROT

TRES_ROT btfss     porta,3       
               goto      EMPEZAR
   call      anti
   btfss     porta,3     
   goto      EMPEZAR
                   goto      TERCER_ROT




FIJO   movlw   H'ff'
   movwf   portb
   call    retardo
   goto   FIJO

PRIMER_ROT 
   clrf      contador
repit         movf       contador,0
   call      tabla
   movwf  portb
                call      uno_seg
                incf     contador,1
                movlw  .7
   xorwf  contador,0
                   btfss   status,2
                goto     repit
    goto    PRIMER_ROT 



                            
SEGUNDO_ROT       
   clrf      contador
repit1          movf       contador,0
   call      tabla
   movwf  portb
                  call      tres_seg
                 incf     contador,1
                 movlw  .7
   xorwf  contador,0
                btfss   status,2
                goto     repit1
    goto    segundo_rot                                               

TERCER_ROT  
   clrf      contador
repit2       movf       contador,0
   call      tabla
   movwf  portb
                  call      cinco_seg
                incf     contador,1
                movlw  .7
   xorwf  contador,0
                   btfss   status,2
                goto     repit2
    goto    TERCER_ROT                                              

      end


muchas gracias

[maunix]

microcom,

¿Ese es todo el código?

¿Dónde comienza?

[microcom]

caballero disculpas por el descuido en el programa

omiti unas etiquetas de inicio para aminarar el espacio en el programa.

el programa empieza en empezar y ahi pregunto por los pulsadores y cada pulsador me lleva a 4 diferentes rutinas.
ya al momento de darles el retardo requerido ahi tambien coloco las preguntas para los pulsadores.


ya puedes ver el programa resalté con mayusculas las etiquetas.
 
saludos y muchas gracias .

[BrunoF]

Perdona microcom, pero se ve que ando lelo hoy.
¿Que es lo que queres reformar de ese programa?
Saludos.

[maunix]

Perdona microcom, pero se ve que ando lelo hoy.
¿Que es lo que queres reformar de ese programa?
Saludos.

Te cuento un poco Bruno.  Este tema surge de una inquietud que me manifestó microcom en privado sobre si en un determinado software un call "no seguido" de un return podría afectar al "stack".

Le dije que su pregunta era conveniente subirla al foro ya que dicha duda podría ser la de algún otro usuario. 

Aún no he tenido tiempo de analizar y simular su software, pero básicamente lo que hay que ver es si están bien encadenados los calls y gotos de manera de que luego de algunas cuantas ejecuciones el stack siga cómo debe ser y no se llene innecesariamente porque en algún "camino" de los saltos de decisión se haga un call pero que se retorne por algún goto en vez de su correspondiente return.

PD: microcom , como he dicho no le he respondido por falta de tiempo pero no por falta de interés en darte una mano con este software.   

Bruno, aclaro que tampoco me molesta que otro postee una solución al tema, ya que no considero "invasión de post" el que otro quiera aportar algo más

[BrunoF]

Bueno, por lo que veo hay errores.
Se van a producir Overflows del STACK.
Dejame ver si me hago un tiempo y lo corrijo.
Saludos.

[microcom]

caballeros
para anular ese return que se puede hacer.
o sea despues del call si no biene un return como se hace para normalizarl a pila sin llevar a cabo ese return.

o eso no tiene solucion sino es con un return

gracias y saludos.

[BrunoF]

¿Cual es el problema microcom?

Si cargas el STACK con un CALL, tenes que liberarlo con un RETURN o un RETLW.
Un RESET tambien produce una descarga completa del STACK, pero bueno...¡hace un RESET!

Saludos.

[maunix]

caballeros
para anular ese return que se puede hacer.
o sea despues del call si no biene un return como se hace para normalizarl a pila sin llevar a cabo ese return.

o eso no tiene solucion sino es con un return

gracias y saludos.

microcom Como te dijo bruno , en los 16F la única forma sería organizar bien el código.  Siempre de alguna forma debes corresponder con un return al call.  Si por alguna razón te queda mal es porque hay un problema de lógica.

En los 18F podrías hacer una triquinuela con el stack (porque se tiene acceso al puntero del stack ) pero no es recomendable para nada.

[microcom]

caballeros muchas gracias por lo correspondido y las explicaciones dadas.

como se puede hacer para que un pulsador o pregunta se a atendida inmediatamente.
sin recurrir al las interrupciones.
para un retardo de 1seg tiene que pasar este tiempo para que el pulsador sea atendido
yo sierta ocacion dentro de un retardo coloque un pregunta y el pulsador quedó inmediatamenta sencible a la puldada.esa pila quedo cargada con un call
y el programa no tubo inconvenientes.

caballeros disculpen si las preguntas son poco invenientes o triviales.


saludos desde sucre.

[BrunoF]

caballeros muchas gracias por lo correspondido y las explicaciones dadas.

como se puede hacer para que un pulsador o pregunta se a atendida inmediatamente.
sin recurrir al las interrupciones.
para un retardo de 1seg tiene que pasar este tiempo para que el pulsador sea atendido

Ok. Dejame ver si entendi bien.

Quieres revisar el estado de un pulsador, sin necesitar de interrupciones.
Si el pulsador es presionado, debe mantenerse al menos 1 segundo presionado para que se ejecute cierta rutina. Si se suelta antes de completado el segundo, se ignora la pulsación.

Pensemos lógicamente.

Inicio:

¿Pulsador Presionado?
NO -->  Volver a Inicio
SI --> ¿Pulsador presionado durante al menos 1 segundo?
           NO--> Ignorar pulsacion y volver a Inicio
           SI-- > Ejecutar rutina predefinida para el pulsador.

Pensemoslo ahora, un poco más orientado al código que debes generar.
Si RA0 = 1 pulsador no presionado
Si RA0 = 0 pulsador presionado

Código: ASM

1. ;Registros a declarar:
2.  
3. Flag    EQU     0x??
4. PDel0   EQU     0x??
5. Pdel1   EQU     0x??
6. Pdel2   EQU     0x??
7.  
8.  
9. ;////////////////////////////////////////////////////////////////
10.  
11. ;Porcion de programa:
12.  
13. Inicio
14.  
15.         btfss   PORTA,0                 ;¿pulsador presionado?
16.         call    CheckearPulsador        ;SI
17.  
18.         goto    Inicio                  ;NO
19.  
20. ;////////////////////////////////////////////////////////////////
21.  
22. CheckearPulsador
23.         call    Antirebote              ;Esperar durante 60ms para evitar rebotes mecánicos
24.         call    Demora1Seg              ;Revisar si se mantiene durante al menos 1 segundo presionado
25.         movwf   Flag                    ;Volcar valor retornado por la funcion previa en la variable Flag
26.         movf    Flag,F                  ;Sobreescribir contenido de Flag para afectar flag Z
27.         btfsc   STATUS,Z                ;Aqui: Z= 1 indica que se solto antes del segundo. Z = 0 indica que se cumplio el segundo presionado
28.         return                          ;Z= 1. Volver sin hacer nada
29.  
30.         nop                             ;Z=0. Aqui va el codigo de lo que debe hacerse
31.         return                          ;Volver para descargar el STACK
32.  
33. ;////////////////////////////////////////////////////////////////
34.  
35.  
36. Antirebote
37.         movlw   .66
38.         movwf   PDel0
39. PLoop1  movlw   .181
40.         movwf   PDel1
41. PLoop2  clrwdt
42.         clrwdt
43.         decfsz  PDel1,1
44.         goto    PLoop2
45.  
46.         decfsz  PDel0,1
47.         goto    PLoop1
48.  
49.         clrwdt
50.         return
51.  
52. ;////////////////////////////////////////////////////////////////
53.  
54. Demora1Seg
55.         movlw   .14
56.         movwf   PDel0
57. PLoop0  movlw   .72
58.         movwf   PDel1
59. PLoop1  movlw   .247
60.         movwf   PDel2
61. PLoop2
62.         btfsc   PORTA,0 ;¡REVISAR PULSADOR PRESIONADO!
63.         retlw   0       ;SE HA SOLTADO ANTES DEL SEGUNDO. Volver con FALSE(0)
64.  
65.         decfsz  PDel2,1
66.         goto    PLoop2
67.  
68.         decfsz  PDel1,1
69.         goto    PLoop1
70.  
71.         decfsz  PDel0,1
72.         goto    PLoop0
73.  
74. PDelL1  goto    PDelL2
75. PDelL2  clrwdt
76.         retlw   1       ;Se mantuvo presionado durante un segundo. Volver con TRUE(1)
77.  
78. ;////////////////////////////////////////////////////////////////

Con respecto a lo otro.
Si no descargas correctamente el STACK...

Ejemplo:

Código: ASM

1. Inicio
2.  
3.         btfss   PORTA,0
4.         call    Pulsado
5.  
6.         goto    Inicio
7.  
8. ;////////////////////////////////////////////////////////////////
9.  
10. Pulsado
11.         movlw   .1
12.         movwf   PORTB
13.         goto    Inicio
14.  
15. ;////////////////////////////////////////////////////////////////

El programa funcionara bien, hasta que presiones por novena vez el pulsador. En este punto, el PIC volvera al vector 0x00 ya que produjiste un OVERFLOW del STACK

En este otro ejemplo, un UNDERFLOW del STACK (produce lo mismo que el OVERFLOW)

Código: ASM

1. Inicio
2.  
3.         btfss   PORTA,0
4.         goto    Pulsado
5.  
6.         goto    Inicio
7.  
8.  
9. ;////////////////////////////////////////////////////////////////
10.  
11. Pulsado
12.         movlw   .1
13.         movwf   PORTB
14.         return
15.  
16. ;////////////////////////////////////////////////////////////////

Saludos.