Subrutina para el manejo de pantalla Nextion

[KILLERJC]

buenas.

KILLER. podrías explicarme bien esta parte-  no comprendo la función del -

Para el compilador, una etiqueta es la direccion de una instruccion. Es decir es un numero. Si en mi tabla de opciones, todas fueran de 3 letras como en el codigo que pase:

Código: ASM

1. OBTENER_OPT:
2.     ADDWF PCL, F
3. TXT_OPT_TXT:    DT "txt",0x00    
4. TXT_OPT_BCO:    DT "bco",0x00
5. TXT_OPT_PCO:    DT "pco",0x00  
6. TXT_OPT_FNT:    DT "fnt",0x00

( OBTENER_OPT es en realidad la direccion de la instruccion ADDWF PCL,F )

No necesitaria de 2 tablas, ya que podria precalcular donde comienza mi segunda, o tercera opcion (multiplicando por 4, shift a la izquierda 2 veces ). Es decir, supongamos que tenes el primer opcion que es txt, entonces le pasas un 0, para la opcion BCO, le pasas un 4 en W, para la opcion PCO le pasas un 8 en W. Esto es lo mismo que opcion*4

Yo no sabia todas las opciones, y es un codigo "general" para que sirva para cualquier opcion y longitud de la misma, que ocurre si tenemos algo asi ahora:

Código: ASM

1. OBTENER_OPT:
2.     ADDWF PCL, F
3. TXT_OPT_TXT:    DT "text",0x00    
4. TXT_OPT_BCO:    DT "bco",0x00
5. TXT_OPT_PCO:    DT "pco",0x00  
6. TXT_OPT_FNT:    DT "font",0x00

En que algunos son 3, otros son 4, etc. Podrias tener varios enfoques para solucionar este problema.
Uno simple seria poner todos los de 3 al comienzo y luego los de 4 al final, pasado cierto numero de opciones empezas a sumarle por 5 en ves de 4. Es una opción, pero al agregar alguna opción de 3 mas, tenes que modificar ese limite.
Otra opciones es contar los 0x00, para saber cuando es que comienza tu opcion, el problema de esto es que realizas muchísimos saltos, si es la ultima de las opciones, realizas 2 saltos por cada caracter que le precede, y ni hablar que los saltos son de 2 ciclos cada uno. Es MUCHO tiempo que tal ves no afecte, pero es mala practica realizarlo si existe alguna otra forma mejor.

En cambio con el uso de una tabla mas:

Código: ASM

1. OPT_TABLA:
2.     ADDWF PCL, F
3.     RETLW   TXT_OPT_TXT - TXT_OPT_TXT    
4.     RETLW   TXT_OPT_BCO - TXT_OPT_TXT
5.     RETLW   TXT_OPT_PCO - TXT_OPT_TXT
6.     RETLW   TXT_OPT_FNT - TXT_OPT_TXT

Puedo tener el offset de mi otra tabla, es decir, cuanto le debo agregar al 0 para que me de justo el comienzo de mi opción, y pasarle ese resultado por W.

Supongamos que TXT_OPT_TXT es la direccion 150, y que TXT_OPT_PCO es la 160. Entonces lo que genero ahi es una resta de las 2 direcciones, quedandome un RETLW 10. Y que eso es lo que se le suma al PCL. Pudiendo modificar el texto de las opciones sin modificar nada mas.
Obviamente esto posee un limite, en caso de que supere los 255 caracteres si es que esta puesta al comienzo de la pagina la tabla, vas a necesitar agregar codigo adicional para que esto funcione correctamente, ahora con opciones de 4 caracteres (incluido el 0), tenes una buena cantidad de opciones para agregar (63 para ser exactos).

-----------------

Mi idea del código es que sea fácilmente escalable, que agregarle algun elemento mas, no implique ningún cambio significativo. Entonces vos terminas pasando a la misma función esto:

Tipo de elemento ( t,g,etc), Numero de elemento. Y ya te genera todo la parte inicial
Envías el mensaje, sea Numero o Texto, esto va aparte, porque sino implica que debas separar las opciones en las que admiten texto y las que admiten números. Se lo dejas al usuario, es responsabilidad del usuario, no de la libreria.
Envia el final.

Tu forma de realizarlo para mi lo que veo es generar una subrutina para cada una de las opciones.
Si... es mas "directo", en ves de rellenar con las opciones, le das una lista larga de subrutinas, pero es muy repetitivo, ocupa mas espacio y si terminas generando codigo para que luego pueda ser retirado, termina siendo mas engorroso que tenerlo todo mas compacto. Mi codigo le faltan muchas cosas, lo hice en un momento y no mire si habia errores o no, me di cuenta de algunos mientras estaba escribiendo aca en el foro, pero era para que tengas de referencia, como ves le faltan muchas cosas, como el manejo de las paginas, ORG, etc, que eso lo vas a tener que agregar las instrucciones para que funcione correctamente en cualquier parte del codigo.

A diferencia de la programación de un PLC, en lo que respecta a informática y/o electrónica (hay casos especiales obviamente) si se repite el código, algo mal estas haciendo.

Son posturas distintas, por eso bien dije cuando te puse el codigo:

Disculpa si hay un error, pero esto es masomenos lo que te puedo ayudar, de ahi queda en vos:

[estebanfolcher]

buenas tardes a todos.

killerjc: antes de seguir con mi método. e decidido probar el tullo, en espesado con buen pie pero los problemas aumentaron a medida que la tabla para los offset crecía. (solo llegue a 4 proclividades)

como se predijo, el problema radica en que si la tabla esta ubicada en una posición de memoria muy cerca de su limite, a medida que vas aumentando la tabla llegan los errores.
si las tablas las coloco en el programa principal, en la cabecera, puedo continuar. es el ubico modo rápido.

bien hora pensando en su utilidad y la función que cumplirá ( que es damas que esterar las funciones para enviarlas por usart)
quiero probar de meter la tabla directamente en la ultima memoria para dejas las del principio  " libres" en mi caso el pic16f877a
 pero no consigo que funcione.

a ver si la sintaxis es correcta:

Código: ASM

1. CBLOCK
2.                         AUX_MENSAJE
3.                          
4.                         ENDC    
5.  
6. #DEFINE                 OBJETO_TEXTO    d'0'
7. #DEFINE                 FUNCION_TEXTO   d'1'
8. #DEFINE                 FUNCION_FIN     d'2'
9. #DEFINE                 FUNCION_BCO     d'3'
10. #DEFINE                 FUNCION_PCO     d'4'                   
11. ;#DEFINE                        OBJETO_TEXTO_S  d'0'
12. ;#DEFINE                        FUNCION_TXT     d'0'                   
13. ;#DEFINE                        FUNCION_FONT    d'0'       
14. ;#DEFINE                        FUNCION_XCEN    d'0'         
15. ;#DEFINE                        FUNCION_YCEN    d'0'         
16. ;#DEFINE                        FUNCION_PW      d'0'       
17. ;#DEFINE                        FUNCION_ISBR    d'0'         
18. ;#DEFINE                        FUNCION_BORRA   d'0'       
19.  
20. Inicia_Nextion         
21.                         CALL    Retardo_200ms
22.                        
23.                         MOVLW   FUNCION_FIN
24.                         PAGESEL Tabla_Offset
25.                         CALL    Tabla_Offset
26.                         CALL    Lee_Y_Envia_Items
27.                         RETURN
28. ;
29. ;-------------------------------------------------------------------------------
30. Nex_Texto_Borra        
31.                        
32.                         MOVLW   OBJETO_TEXTO
33.                         PAGESEL Tabla_Offset
34.                         CALL    Tabla_Offset
35.                         CALL    Lee_Y_Envia_Items
36.                         CALL    Envia_Numero_Objeto
37.                         MOVLW   '.'
38.                         CALL    Envia_USART
39.                        
40.                         MOVLW   FUNCION_TEXTO
41.                         PAGESEL Tabla_Offset
42.                         CALL    Tabla_Offset
43.                         CALL    Lee_Y_Envia_Items
44.                         MOVLW   '='
45.                         CALL    Envia_USART
46.                         MOVLW   '"'
47.                         CALL    Envia_USART
48.                         MOVLW   '"'
49.                         CALL    Envia_USART
50.                        
51.                         MOVLW   FUNCION_FIN
52.                         PAGESEL Tabla_Offset
53.                         CALL    Tabla_Offset
54.                         CALL    Lee_Y_Envia_Items
55.                         RETURN
56. ;-------------------------------------------------------------------------------                       
57. Nex_Texto_Envia         MOVWF   AUX_MENSAJE
58.                         MOVLW   OBJETO_TEXTO
59.                         PAGESEL Tabla_Offset
60.                         CALL    Tabla_Offset
61.                         CALL    Lee_Y_Envia_Items
62.                         CALL    Envia_Numero_Objeto
63.                         MOVLW   '.'
64.                         CALL    Envia_USART
65.                        
66.                         MOVLW   FUNCION_TEXTO
67.                         PAGESEL Tabla_Offset
68.                         CALL    Tabla_Offset
69.                         CALL    Lee_Y_Envia_Items
70.                         MOVLW   '='
71.                         CALL    Envia_USART
72.                         MOVLW   '"'
73.                         CALL    Envia_USART
74.                         MOVF    AUX_MENSAJE,W
75.                         CALL    Envia_Mensaje
76.                         MOVLW   '"'
77.                         CALL    Envia_USART
78.                        
79.                         MOVLW   FUNCION_FIN
80.                         PAGESEL Tabla_Offset
81.                        
82.                         CALL    Tabla_Offset
83.                         CALL    Lee_Y_Envia_Items
84.                         RETURN
85.                        
86. ;-------------------------------------------------------------------------------
87.  
88.                     ;ORG        0x1900
89.                     ORG         0x1800 
90. Tabla_Offset       
91.                     ADDWF       PCL,F
92.                     RETLW       SUTRAE_O_TXT - SUTRAE_F_TXT
93.                     RETLW       SUTRAE_F_TXT - SUTRAE_F_TXT                    
94.                     RETLW       SUTRAE_F_FIN - SUTRAE_F_TXT
95.                     RETLW       SUTRAE_F_BCO - SUTRAE_F_TXT
96.                     RETLW       SUTRAE_F_PCO - SUTRAE_F_TXT
97.                        
98.                        
99. Tabla_Items        
100.                     ADDWF       PCL,F
101.                        
102. SUTRAE_F_TXT        DT  "txt",0x00
103. SUTRAE_F_BCO        DT  "bco",0x00
104. SUTRAE_F_PCO        DT  "pco",0x00    
105. SUTRAE_F_FONT       DT  "font",0x00
106. SUTRAE_F_XCEN       DT  "xcen",0x00  
107. SUTRAE_F_YCEN       DT  "ycen",0x00  
108. SUTRAE_F_PW         DT  "pw",0x00
109. SUTRAE_F_ISBR       DT  "isbr",0x00
110. SUTRAE_F_FIN        DT  "ÿÿÿ",0x00
111. SUTRAE_O_TXT        DT  "t",0x00
112.            
113.            
114.  
115.                    
116.                    
117.                    
118.                    
119.                     INCLUDE     LEE_Y_ENVIA.INC
120.                     INCLUDE     BIN_BCD_16.INC
121.                     INCLUDE     USART.INC
122.                     INCLUDE     CRIBA_X3.INC

saludos



 

[estebanfolcher]

perdon:

dejo el programa completo para simular.

 

[KILLERJC]

killerjc: antes de seguir con mi método. e decidido probar el tullo, en espesado con buen pie pero los problemas aumentaron a medida que la tabla para los offset crecía. (solo llegue a 4 proclividades)

como se predijo, el problema radica en que si la tabla esta ubicada en una posición de memoria muy cerca de su limite, a medida que vas aumentando la tabla llegan los errores.
si las tablas las coloco en el programa principal, en la cabecera, puedo continuar. es el ubico modo rápido.

Creo que no leiste correctamente lo que te puse:

Mi codigo le faltan muchas cosas, lo hice en un momento y no mire si habia errores o no, me di cuenta de algunos mientras estaba escribiendo aca en el foro, pero era para que tengas de referencia, como ves le faltan muchas cosas, como el manejo de las paginas, ORG, etc, que eso lo vas a tener que agregar las instrucciones para que funcione correctamente en cualquier parte del codigo.

En si una referencia.

En la tabla antes del ADDWF, vas a tener que precalcular si se pasa de los 255 para aumentar el PCLATH, y tambien vas a tener que encontrar en que pagina estas, debido a que el CALL/GOTO utilizan mas bits de los que un salto computado con el PCL podes tener.

--------------------

El otro tema es que ya estas mezclando todo, la idea de 2 tablas ( aunque una de ellas use 2 ) es que puedas agregar de forma rápida elementos, y esten separados por "categorias", una son los elementos y el otro las propiedades, con una sola tabla estas buscando llegar a los 255 facilmente, y ahi si tener que utilizar no solo W, otras formas mas de poder realizarlas. Ya que vas a usar 16 bits para el "direccionamiento" de tu tabla.

Y poniendolo en la posicion de memoria 0x1800 estas logrando que necesites SI o SI pre-cargar el PCLATH para cada CALL/GOTO desde tu "main", ya que estas superando los 10bits de direccionamiento.
En ves de hacer un codigo que sea dependiente de la posicion, trata de hacer un codigo que no lo sea.

[estebanfolcher]

buenas.

tienes razón aun no acabe de entender del todo, este tema de las dos tablas. con respecto a la tabla objeto, sera mejor poner todo en solo una tabla ya que en los momento que estoy sin poder seguir voy estudiando como funciona la pantalla y e visto que ay objetos que ocupan 2 byts de nombre, y a demás ay que poner el resto de variable que hacen otras cosas.

[estebanfolcher]

BUENAS.

a ver que os parece así. este modo nos permite utilizar los objetos y funciones de una lista  tantas veces como queramos.

la rutina de la tabla se vasa en que todos los objetos y funciones  representan cada linea,  cada carácter representa columnas.
para ir a cada linea,  multiplico la linea que deseo por la cantidad de columnas que tiene la tabla y me da el valor H y L a estos le sumo la dirección donde inicia la tabla y se posiciona en el inicio de la linea, dándome el primer dato. para seguir sacando mas datos de esa linea en cada paso después de la extracción incremento la parte baja ( columnas ) y pregunto si es cerro
si no lo es, envía por usart y sigue. si es cero finaliza el incremento y retorna


que te parece así killer?

adjunto programa ejemplo y subrutina.

PD: si ven algo que mejorara soy todo ojos. saludos.
PD: falta las rutinas para las demás funciones del objeto texto. pero como este trabajo lo empece muchas veces, espero opiniones y sigo.

[estebanfolcher]

BUENAS.


aquí otra idea. yo creo que se puede quedar entre esta y la otra.

PD: aclaro que en la idea anterior  estamos limitados a literalmente 255 lineas (objetos y funciones) esta nueva que presento esta limitado a la cantidad de memoria del micro. pero ay
que establecer  la linea completa. como se puede observar  en la tabla  en cada opción,  las variables ( numero objeto, mensaje, o literal bcd a ASCII) están remplasadas
por 3 marcadores ( 251, 252 y 253 ). cuando el dato es devuelto lo pasamos por una criba que pregunta por los tres marcadores y por el 0., el 251 pide numero objeto,
el 252 pide mensaje, el 253 pide numero literal bcd aASCII y el 0  indica fin de la linea.

cual os parece mejor para manejar?? dejo  ejemplo.

PD: aun esta sin terminar pero se puede apreciar la diferencia entre esta y la anterior saludos espero sus opiniones y consejos
 

[KILLERJC]

Te doy mi opinion, pero sos vos el que tenes que hacer lo que desees, tal ves te sobre con lo que hagas. Entonces no tomes mi opinion como la verdad absoluta

que te parece así killer?

Un gasto de Flash.

cual os parece mejor para manejar?? dejo  ejemplo.

MAS gasto de Flash que la version anterior.

---------------------------------------------------------------------------------------------------------

Vos no queres tocar la libreria y que paresca simple para el usuario?, pero aun asi todos los CBLOCKs que tenes luego vas a tener que definirles el comienzo, sino no te van a funcionar. Ver si te entran en la RAM, estan en el banco correcto, etc.
Suponiendo que luego la otra persona no defina sus variables sobre las mismas direcciones que vos tenes usadas. Asi que diseñar algo abstracto asi como queres no puede ser en ASM, la persona deberá tener acceso a la libreria y saber como funciona minimo. Esto es ASM, si quisiera un nivel pequeño de abstraccion iria a otro lenguaje mas avanzado. Y eso SI haria el lenguaje mas simple.

Por otra parte, si queres quitar la limitante de 256 valores de las tablas:

Código: ASM

1. ;Aca cargo OffsetH y OffsetL
2.     CALL    Table
3. ; LLamada a la tabla
4.  
5. Table:  
6.         MOVLW   HIGH(TStart)
7.     ADDWF       OffsetH, W
8.     MOVWF       PCLATH
9.     MOVLW       LOW(TStart)
10.     ADDWF       OffsetL, W
11.     BTFSC       STATUS, C
12.     INCF        PCLATH,F
13.     MOVWF   PCL
14.     ; fin de la subrutina de la tabla, no se necesita return ni nada, ya que al mover al PCL salta
15.  
16.  
17.     ; La tabla donde se te ocurra ponerla
18.     ORG 0x????
19. TStart:
20.         RETLW   d'0'
21.     RETLW       d'1'
22.     RETLW       d'2'
23.     ;....
24.     ;etc

No importa donde este la tabla porque el PCLATH va a estar cargado de forma correcta, y al mover al PCL, accede a PCLATH:PCL que vendría a ser la posición de la tabla, ubicada donde se quiera y que su tamaño no importe

Podes hacer:
- Que las variables se ubiquen solas, es decir que el linker lo haga por si solo, lo cual vas a tener que programar para que sea valido para cualquier posciion de la variable.
- Que el codigo se ubique solo también, y lo haga el linker.

Y aca tenes un super codigo que no importa donde lo pongas, el cual va a funcionar correctamente, sea como sea. Y si se intenta gastar mas RAM de la que se necesita, tengas un error.

El problema esta en que el usuario tambien debe aprender a programar en ASM correctamente, sino va a ser un DESASTRE.

[estebanfolcher]

buenas.

y si hago un macro por cada rutina, así ocuparía tiempo y espacio en función a la cantidad de macros que llame??

[KILLERJC]

buenas.

y si hago un macro por cada rutina, así ocuparía tiempo y espacio en función a la cantidad de macros que llame??

Y pensas hacer una macro para cada uno de los textos? con texto incluido? es decir un codigo especializado en cada texto. Cuando podes hacer un codigo que te valga para cualquier cosa y que siempre se use el mismo. Sigo pensando que estas complicandote la vida sin sentido.

No logro comprender que estas intentando lograr con el codigo, lo unico que pedis es que quede "lindo" el main, eso lo podes lograr creando una subrutina que lo resuma todo en un solo CALL, lo que estamos discutiendo es la mejor forma de acomodar el codigo, no solo para que sea mas rapido, sino menos espacio, menos complicado debido a que tenes 3000 lineas, mas simple de agregar algun elemento nuevo (MANTENIBLE), etc.

Como ya te dije, cualquiera te puede servir, y seguramente tengas espacio de sobra. Entonces algo estas buscando, si estas buscando mejorar el codigo, para mi, mi aproximacion es la mejor. Con un par de variables, mas un par de funciones, no necesito agregar casi nada de código para agregar o quitar alguna opción. Las funciones son cortas como para poder debugearlas bien.
El problema de los 256 datos de la tabla, esta solucionado, ya te pase la solucion.
El problema de poner el codigo TAN lejos que no llegue ni siquiera un GOTO/CALL ese es un problema ya del que vaya a ubicar el archivo. requieriendo que haga uso de PCLATH como se debe.

Y vuelvo a repetirte:

Te doy mi opinion, pero sos vos el que tenes que hacer lo que desees, tal ves te sobre con lo que hagas. Entonces no tomes mi opinion como la verdad absoluta

Tal ves mi aproximacion no te guste, y eso esta en vos, cada uno programa como desea ... Por eso al preguntar sobre "que me parece" termino comparando los pros/contra con lo que te pase. Y tal ves ni siquiera necesites tanto. Y te funcione con lo que vos tenes. Te sugiero que no le des tantas vueltas y que si funciona le des para adelante, si luego ves que algo falla (memoria,etc) podes buscar otras alternativas.

[estebanfolcher]

sabes que pasa es que no acabo de entender cual es tu idea para poder plasmarla en en ejemplo.

voy a intentar poner aquí todo lo que hace falta para poder manejar de forma básica  la nextion. luego hablamos
 

[KILLERJC]

Mi idea en el programa que te pase es:

Yo deseo tener una subrutina que envie cierto comando a la pantalla. Entonces le paso los parametros de lo que quiero que se envie y le pido que lo envie, nada mas.

Quiero que el objeto sea texto, entonces cargo en un registro el tipo TEXTO
Quiero que el numero de objeto sea el numero XXX, entonces cargo en unos registros ese numero.
Quiero que la propiedad de ese objeto sea TXT, entonces cargo en un registro cual propiedad quiero modificar.
Envio...
Debo enviar texto o numero, aca es donde es totalmente variable el contenido, y esto queda a disposicion de la persona, le podes ofrecer un codigo para esto.
Envio el final.

Quiero enviarle a otro elemento? Cambio solamente el registro donde pido que objeto sea.
Quiero cambiar la propiedad? Cambio la propiedad con un solo MOVLW y MOVWF, el literal va a ser un nombre facil de recordar, por ejemplo NXT_PROPIEDAD_TXT, son nombres faciles de recordar y no le importa como es que se envia, solo que al cargar eso ya se envia el .TXT

Entonces cambiando un simple registro envio todo lo que se me puede ocurrir. Las subrutinas que le debo ofrecer son 4 o 5 nomas

- Enviar la parte inicial
- Enviar un numero (en caso de que requiera la propiedad)
- Enviar un texto ( en caso de que requiera la propiedad)
- Enviar el final

4 "funciones"

Y si queres le podes presentar un solo CALL, pero eso requiere ademas configurar la direccion del texto o numero, y complicar un poco mas la logica.
El tema es que la parte "inicial" , es decir mi subrutina es valido para cualquier tipo de objeto, propiedad, etc, no necesito 1 por cada una de las propiedades y/o objetos, 1 sola para todo. Y si queres ver como queda es esto:

Código: ASM

1. PRINCIPAL:
2.     MOVLW NXT_TEXT_T               ;El objeto TEXT
3.     MOVWF NXT_TIPO
4.     MOVLW .12                             ; El numero de objeto
5.     MOVWF NXT_NUMBER            
6.     MOVLW NXT_PCO_OPT            ; La propiedad del objeto
7.     MOVWF NXT_OPTION
8.     CALL  NXT_ENVIAR_INICIO      ; Que envie todo lo que pedi antes
9.     CALL  NXT_ENVIAR_MENSAJE  ; Envio el mensaje o numero segun lo que corresponda
10.     CALL  NXT_ENVIAR_FINAL       ; Envio la parte final, el cual se podria incluir en el anterior CALL
11.    
12.    
13.     GOTO PRINCIPAL

Todo lo demas del codigo es la libreria, Y lo unico que deberias "compartir" para que la persona sepa como usarlo son estos nombres:

Código: ASM

1. ; Defines para el uso de la libreria
2. NXT_TEXT_T      EQU  0
3. NXT_TXTSC_T     EQU  1
4.  
5. NXT_TXT_OPT     EQU  0
6. NXT_BCO_OPT     EQU  1  
7. NXT_PCO_OPT     EQU  2
8. NXT_FNT_OPT     EQU  3

Por supuesto le podes dar mejores nombres como NXT_OBJETO_TEXT, NXT_PROPIEDAD_BCO, etc.
Y decirlo, cargar los OBJETOS en NXT_TIPO (es el nombre que use yo ), cargar el numero de objeto en NXT_NUMBER, y cargar la propiedad en NXT_OPTION.

[estebanfolcher]

pero lo que tu dices es lo mismo que lo mio con la diferencia en que yo minimizo la llamada en el programa principal  armo la frece  en una rutina y esta llama a las tablas a la comunicación etc.
tu armas la frece en el programa principal  y solo llamas a la tabla, comunicaciones y converso res.

[estebanfolcher]

ademas creo que muy poco que manejen otro lenguaje  lo an desglosado para ver como trabaja en asemblar  creo que cuando otorgo un nombre soy bastante directo 

movlw      mensaje
call           Envia_texto
 
es bastante conciso no ay mas.
claro que ay que poner nombres entendible para la parte que pocos deciden estudiar.

esta claro mi llamada en el programa principal es mas simple porque yo tengo un paso intermedio que es el armado de la llamada  tu tienes el armado directo en el programa principal

pero entendiendo esto si es lo que tu quieres explicarme  lo que quiero saber  si el método para acede a la tabla  en los dos últimos ejemplos son buenos   

[estebanfolcher]

cuando me refería a hacerlo en macros para poder conservar la simplicidad en el programa principal  lo decía porque si yo llamo a un macro que dentro tendría  el segundo paso (el armado de la frase completa )  en el micro solo se cargaría los macros que es llamado y las rutinas obligatorias que son el conv. bdc, las criba para el numero de objeto,  la comunicación,  y la rutina que envía el mensaje del usuario. ahora mis métodos de rutina se cargan enteras, las use o no
y con un macro la llamada incluso seria mas entendible  CALL    NEXTION      Objeto,N_Objeto,Funcion,Variable o Mensaje, Fin (si no me equivoco esto seria asi si fuese todo en macros.

desde que empese que os mando una rutina de retardos. esta se carga entera pero no utiliza toda la rutina mucho codigo se queda grabado para nada os dejo un retado en macro

Código: ASM

1. ;************************************************************************************************************************
2. ;                                                                                              
3. ;
4. ;Macro y rutina de temporización que se ajustan en función de la frecuencia de trabajo Fosc. En el programa principal
5. ;se debe definir:
6. ;a)     La frecuencia de trabajo (en hz) mediante ... "#define Fosc xxxxxxxx"
7. ;b)     Las variables de trabajo Temporal_1, Temporal_2 y Temporal_3 mediante ... "Temporal_x   equ     0xXX"
8. ;
9. ;El usuario llama a la macro desde su programa principal mediante ... "Delay xxxx Milis"
10. ;
11. ;Se obtiene una precisión razonable con valores de temporización desde 1 hasta 2000 mS y a frecuencias Fosc
12. ;que van desde 1MHz hasta 48MHz
13.  
14. #define         Milis                   * D'1000000'
15.        
16. Delay   macro   tiempo_ns       ;tiempo_ns expresa en ns el tiempo de temporización deseado
17.        
18.         ifndef Fosc                     ;En el programa principal se ha definir la frecuencia de trabajo en Hz                                                         
19.         messg "ERROR !! - Establecer la frecuencia de trabajo (p.e. #define     Fosc 4000000)"
20.         exitm
21.         endif
22.  
23.         radix dec                                                                                               ;Operaciones en base decimal
24.         variable ciclo_instruc_ns =  (( 1000000000 ) / (Fosc / 4 ))     ;Calcula ciclo de instrucción en función de la frecuencia Fosc
25.         variable ciclos = (tiempo_ns / ciclo_instruc_ns)                ;Calcula el nº de ciclos necesarios para la temporización deseada
26.  
27.                                 movlw   upper (ciclos/4)+1
28.                                 movwf   Temporal_1
29.                                 movlw   high (ciclos/4)+1
30.                                 movwf   Temporal_2
31.                                 movlw   low (ciclos/4)
32.                                 movwf   Temporal_3              ;Carga las variables de temporización con el nº de ciclos calculado
33.                                 call    MSE_Delay
34.  
35.  endm
36.  
37. MSE_Delay               clrwdt                                  ;Bucles de temporización
38.                                 decfsz  Temporal_3,f
39.                                 goto    MSE_Delay
40.                                 decfsz  Temporal_2,f
41.                                 goto    MSE_Delay
42.                                 decfsz  Temporal_1,f
43.                                 goto    MSE_Delay
44.                                 return