Imprimir Página - Subrutina para el manejo de pantalla Nextion

Microcontroladores PIC => Almacén del Assembler => Mensaje iniciado por: estebanfolcher en 14 de Agosto de 2018, 16:55:42

Título: Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 14 de Agosto de 2018, 16:55:42

Buenas tardes a todos.

Ante todo agradezco todo tipo de ayuda. gracias.

Tengo un problema y consiste en mandar una cadena de texto y variables mezclados, por ejemplo: "v0.val=100ÿÿÿ" para comunicar por rs232.
pero tiene que ser algo simple de llamar. intentare explicarme. tengo que comunicar con una pantalla Nextion por rs232 que en gran parte lo hace en modo ASCII
si quiero que un un objeto texto me imprima una cantidad e de enviarle n0.val=100ÿÿÿ donde "n" es el tipo de objeto "0" es el numero de objeto que puede ir de 0 a 255, "val" es como la pantalla identifica su valor, = indicamos que su valor es igual a XXX, 100 es el valor ( que se a de desglosar en ASCII )( enviar por orden primero el 1 segundo el 0 tercero 0. y luego los tres bytes de final de envió "ÿÿÿ". pero intento que sea algo simple algo parecido a la directiva DT donde colocas todo el mensaje y lo envías. el problema que esta directiva es solo para el ensamblador y a demás solo funciona con constantes, no puedo hacer esto por ejemplo: DT "n" ,reg_uni, ".val=", reg_cen, reg_dec, reg_uni, "ÿÿÿ" donde reg_cen, reg_dec y reg_uni, son registros variables.
busco una manera simple que en cualquier momento de programa que lo necesite pueda enviar diferentes textos mezclado con registros, algo parecido a lo que se puede hacer en lenguaje C
pero en assembler.

adjunto dos ejemplos de lo que si funciona hasta ahora.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: Pinolillo16 en 14 de Agosto de 2018, 22:23:55

Que tal, lo mas facil es usar una conversion de binario a ASCCI. Como el siguiene:

Código: ASM

CONVERSION_BCD
        MOVWF   AUXILIAR
        CLRF    AUX_UNIDADES
        CLRF    AUX_DECENAS
        CLRF    AUX_CENTENAS
S_CENTENAS
        MOVLW   .100
        SUBWF   AUXILIAR,W
        BTFSC   STATUS,C
        GOTO    SUMA_CENTENAS
        GOTO    S_DECENAS
SUMA_CENTENAS
        MOVWF   AUXILIAR
        INCF    AUX_CENTENAS,F
        GOTO    S_CENTENAS
S_DECENAS
        MOVLW   .10
        SUBWF   AUXILIAR,W
        BTFSC   STATUS,C
        GOTO    SUMA_DECENAS
        GOTO    SUMA_UNIDADES
SUMA_DECENAS
        MOVWF   AUXILIAR
        INCF    AUX_DECENAS,1
        GOTO    S_DECENAS
SUMA_UNIDADES
        MOVF    AUXILIAR,W
        MOVWF   AUX_UNIDADES
        MOVLW   B'00110000'
        ADDWF   AUX_UNIDADES,F
        ADDWF   AUX_DECENAS,F
        ADDWF   AUX_CENTENAS,F
        RETURN

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: Pinolillo16 en 14 de Agosto de 2018, 22:28:28

Donde siempre de una variable de 8 bits la separas por 3, unidades, decenas y centenas respectivamente. El ultimo paso es sumar el numero para que sea ASCCI. De esta manera tendras que mandar asi: "v0.val=" como una tabla o caracter por caracter despues tus 3 bytes resultado de tu conversion y por ultimo "ÿÿÿ" para acompletar tu cadena.

Realmente me parece la forma mas sencilla, ya que al ser ensamblador puedes hacer un codigo que no haga bucles innecesarios.

Saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 15 de Agosto de 2018, 17:52:03

buenas tardes.

ante todo gracias por vuestra atención.

Pinolillo16 gracias por tu atención. el tema del bcd esta ya contemplado dentro de la subrutinaria ya tengo claro que cada ves que e de enviar un resultado variable tendré que pasarlo a bcd y guardarlo en las variable de envió en su orden correspondiente. no es ese el problema, ahora para enviar una cadena de texto con variables meclado solo veo por mi falta de conocimiento dos manetas una de ellas es:

la primera que es muy limitada y esto es porque es un texto constante

Tabla_Nextion     MOVWF   PCL         ;CALCULA EL DESPLAZAMIENTO SOBRE LA TABLA
Nextion_Tabla_1
        DT      "n0.val=100ÿÿÿ"0x00

esta forma es muy rápida para crear una subrutina . cualquiera puede usarla y cada ves que tienen que enviar información a la pantalla puede hacerlo así
pero el problema es que tienes que crear tantos mensajes como te hagan falta para enviar., ponerlos en la cabecera del programar o al final y llamarlos cuando te haga falta.
que pasa con esto, pues que no puedes mandar variables, no puedes llamar a este manejase cada ves por que 100 siempre valdrá 100.

nada vamos a la segunda opción un tanto mas engorrosa:

COMIENZO CALL     Inicia_USART_Nextion
        MOVLW     'n'
        MOVWF     Dato_TX_1
        MOVLW     0
        MOVWF     Dato_TX_2
        MOVLW     '.'
        MOVWF     Dato_TX_3
        MOVLW     'v'
        MOVWF Dato_TX_4
        MOVLW     'a'
        MOVWF     Dato_TX_5
        MOVLW     'l'
        MOVWF     Dato_TX_6
        MOVLW     '='
        MOVWF     Dato_TX_7
        MOVF Resu_cen,W
        MOVWF Dato_TX_8
MOVLW     Resu_dec,W
        MOVWF     Dato_TX_9
MOVLW     Resu_uni,W
        MOVWF     Dato_TX_10
MOVLW     'ÿ'
MOVWF     Dato_TX_Fin

Principal     CALL   Nextion

subrutina
Nextion      MOVf   Dato_TX_1,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_2,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_3,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_4,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_5,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_6,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_7,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_8,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_9,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_10,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_Fin,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_Fin,W
         CALL   Envia_USART_Nextion
         MOVF   Dato_TX_Fin,W
         CALL   Envia_USART_Nextion
         RETURN
el problema de este es que cada ves que quiero actualizar una variables del objeto 'n' tengo que en mi programa principal en el momento que quiera rellenar cada letra y cada resultado bcd

tu diras y porque no haces una rutina pre configurada donde yo cargue la variable llame a una subrutina donde primero combierta a bcd, lo acomode en el lugar que le coresponde y punto
seria algo asi:

movf variable,w
calla premensaje_n0.val=XXXÿÿÿ

subrutina:

call a.bcd
MOVLW     'n'
        MOVWF     Dato_TX_1
        MOVLW     0
        MOVWF     Dato_TX_2
        MOVLW     '.'
        MOVWF     Dato_TX_3
        MOVLW     'v'
        MOVWF Dato_TX_4
        MOVLW     'a'
        MOVWF     Dato_TX_5
        MOVLW     'l'
        MOVWF     Dato_TX_6
        MOVLW     '='
        MOVWF     Dato_TX_7
        MOVF Resu_cen,W
        MOVWF Dato_TX_8
MOVLW     Resu_dec,W
        MOVWF     Dato_TX_9
MOVLW     Resu_uni,W
        MOVWF     Dato_TX_10
MOVLW     'ÿ'
MOVWF     Dato_TX_Fin
CALL     Nextion

el problema es que aquí solo cambio la variable y me estaría bien si es solo eso lo que tengo que cambiar, pero no es asi porque ay muchos tipos de objetos y a cada objeto no solo se puede cambiar su valor, también el tamaño el color 1 el color 2 etc etc etc esta pantalla tiene varios objetos a demás de muchas funciones que puedo enviarle por usart que lee en ascii
en la pantalla se puede poner 255 paginas en cada pagina se puede poner 255 objetos diferentes (si no estoy mal informado)
seria de locos tener que escribir tanto.
mi idea es poder poco a poco hacer una rutinaria como la librería que tiene arduino para esta pantalla, un modo fusil de poder mandar texto con variables que no sea tan engorroso

un ejemplo de simple y rápido en lenguaje para arduino: este lenguaje no lo conozco pero algo me dice que es lo mismo

Serial.print("n0.val= "); aqui el texto
Serial.print(variable); aqui la variable
Serial.println("ÿÿÿ"); aqui mas texto

no se si consigo explicarme, busco algo en assembler que me permita hacer una llamada simple en el programa principal y la subtutina se encarge del resto

a groso modo: movlw "bt0.val=variableÿÿÿ"
call subrutina

saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 15 de Agosto de 2018, 20:33:35

buenas

sabiendo que en la directiva DT no puedo poner registros variales como por ejemplo: DT "n0.val=", registro_x, "ÿÿÿ",0x00.
pero si puedo poner un valor constante pre definido como por ejemplo:

contado equ d'100'
------------
-----------
-----------
DT "n0.val=", contador, "ÿÿÿ",0x00

¿ay manera que cambiar esa constate dentro del programa?

PD: perdón esto tampoco me vale aunque se pudiera porque tendría que de todas formas rellenar cada constante y seria igual de engorroso

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 15 de Agosto de 2018, 20:37:28

Esa constante sigue siendo una constante...

Lo que podes hacer es justamente lo que te dijo Pinolillo:

Comando: DT "n0.val=",0x00
Final: DT "ÿÿÿ",0x00

CALL Enviar_Comando
CALL Transformar_variable_a_ASCII ; Primero a BCD y luego a ASCII
CALL Enviar_Final

Y si la parte final es simpre la misma, entonces conviene hacerlo de esta forma.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: Pinolillo16 en 15 de Agosto de 2018, 22:21:47

La forma en que planteas solucionarlo creo que no existe, solo he visto ese tipo de rutinas en compiladores cuando llaman alguna funcion en especifico. Pero debes tener presente que el compilador genera un ASM que seguramente lo ejecuta como te estamos planteando la solucion.

En algun proyecto que hice con comunicacion bluetooth hacia lo que te comente, y pues nada de engorroso ya que todo lo resumes en un conjunto de instrucciones con un solo call y listo.

Podrias usar:

Código: ASM

MOVF  DATO,W
CALL   RUTINA_NEXTION

Y en tu rutina nextion guardas el dato, mandas comando seguido del valor ascii resultado de la conversion y por ultimo el bloque final.

Como lo plantea KillerJC. El es uno de los colegas que mejor maneja el ensamblador.

Saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 15 de Agosto de 2018, 23:21:38

buenas

ay radica el problema que lo único que es constante es el final de envió porque lo demás cambia en los ejemplos ponco el mismo mensaje pero por ejempo:

si quiero que en la pantalla aparezca o desaparezca un objeto e de mandar el texto "vis n0,1" o "vis n0,0"
todo en esta pantalla se maneja enviando texto ay muchísimas combinaciones de combinaciones por ejemplo:
(n) es un tipo de objeto de texto numérico donde le afecta el valor del texto el color de de fondo el color del texto la cantidad de máxima y mínima de dígitos
te adjunto una imagen en la que sale el programa de esta pantalla, veras que en la parte derecha ay un menú atributos que yo puedo poner a mi gusto y cargarlo en la pantalla
pero si fuese el caso puedo cambiar los atributos desde mi programa en el pic. esta claro que desde el pic uno maneja lo justo y necesario pero por ejemplo se me ocurre que al objeto de texto numérico (n) cuando supera un valor (val) cambie el color de fondo del texto a un color rojo (que también puedo especificar) a modo de alarma.
imagina que en un programa muy extenso antes deberia de pre definir cada texto a enviar para luego sumarle la variable
te volverías loco como dije antes esta pantalla tienen muchos objetos y entra 255 por pagina y se pueden meter asta 255 paginas (( siempre y cuando los 32mb de memoria que tienen te permita)mi intención es ver primero de que manera en cualquier momento de mi programa enviar el texto y si luego la variable y luego el final, no tener que editar los textos en la cabecera para luego llamarlos. porque los textos son mas variables que las propias variables numéricas que tengo que enviar.
como comente antes esta marca tiene dos librerías una para arduino y otra para Raspberry Pi. pero la comunicación es tan simple que con el pic mandado texto también la puedes conectar
pero esta claro que si no ay una subrutina que facilite el uso toca romperte mucho el coco.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: Pinolillo16 en 16 de Agosto de 2018, 04:25:30

Asi es el ensamblador. Es tan basico que puedes hacer y deshacer lo que tu quieras y como mejor te convenga. Si lo que buscas es una libreria como arduino es simple, cambiate a un compilador puede ser CCS, XC8 o MikroC. Y adapta la libreria, ya que como se comento anteriormente si comprendemos la cantidad de combinaciones que hay cada que agregas un bit o un byte completo. Pero me parece que lo que vos buscas es algo que no existe en ensamblador a menos de que lo construyas tu mismo. Si te gusta el ensamblador creo que lo deberias implementar de lo contrario muchos colegas aqui en el foro siempre recomiendan usar compiladores para que todo se ejecute de manera mas sencilla finalmente eres tu quien debe decidir.

Saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 16 de Agosto de 2018, 08:17:47

Buenas.

(Pinolillo16). ese es el motivo por el cual no quiero pasarme a C. pero como desconozco algunos aspectos del assembler, no podía evitar preguntar si se conoce algún modo para poder hacerlo.

por lo visto solo quedan dos opciones: una es hacerlo como en el ejemplo que os dejo, o la otra es crear una subrutinas de cada objeto con sus diferentes variables.

saludos y gracias.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 16 de Agosto de 2018, 08:34:18

Código: ASM

;------------------------------------------------------------
; Código assembler 
; Proyecto: usart_prueba
; Autor: 
; Fecha: 06/08/2018
; PIC: 16F877A
; Velocidad de reloj: 4 Mhz
; Descripcion: 
;------------------------------------------------------------
                    LIST    P=PIC16F877A
                    INCLUDE P16F877A.INC
 
        __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
    
                   
                    
    
 
PUERTO_TX           EQU         6       ;PIN DE TRANSMICION
PUERTO_RC           EQU         7       ;PINDE RECEPCION                
                
                    CBLOCK      0x20
                    ENDC
                    
                
STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
                    PAGESEL     COMIENZO
                    GOTO        COMIENZO    ;COMIENZO DEL PROGRAMA
                
                    CODE
                    
                    
COMIENZO            CALL        Inicia_USART_Nextion
                    MOVLW       d'191'
                    CALL        CONVERSION_BCD
                    
                    MOVLW       'n'
                    MOVWF       Dato_TX_1
                    MOVLW       '0'
                    MOVWF       Dato_TX_2
                    MOVLW       '.'
                    MOVWF       Dato_TX_3
                    MOVLW       'v'
                    MOVWF       Dato_TX_4
                    MOVLW       'a'
                    MOVWF       Dato_TX_5
                    MOVLW       'l'
                    MOVWF       Dato_TX_6
                    MOVLW       '='
                    MOVWF       Dato_TX_7
                    MOVF        BCD_UNIDADES,W
                    MOVWF       Dato_TX_8
                    MOVF        BCD_DECENAS,W
                    MOVWF       Dato_TX_9
                    MOVF        BCD_CENTENAS,W
                    MOVWF       Dato_TX_10
                    
Principal           CALL        Nextion
                    CALL        Retardo_1s
                    GOTO        Principal
                    INCLUDE     <BINARIO_A_BCD.INC>
                    INCLUDE     <Nextion_TX_RC.INC>
                    INCLUDE     <RETARDOS.INC>
 
                  
                    END

Código: ASM

;****************************BINARIO_A_BCD:INC**********************************
        CBLOCK                  
        AUXILIAR 
        BCD_UNIDADES
        BCD_DECENAS
        BCD_CENTENAS    
        ENDC
 
CONVERSION_BCD
        MOVWF   AUXILIAR
        CLRF    BCD_UNIDADES
        CLRF    BCD_DECENAS
        CLRF    BCD_CENTENAS
S_CENTENAS
        MOVLW   d'100'
        SUBWF   AUXILIAR,W
        BTFSC   STATUS,C
        GOTO    SUMA_CENTENAS
        GOTO    S_DECENAS
SUMA_CENTENAS
        MOVWF   AUXILIAR
        INCF    BCD_CENTENAS,F
        GOTO    S_CENTENAS
S_DECENAS
        MOVLW   d'10'
        SUBWF   AUXILIAR,W
        BTFSC   STATUS,C
        GOTO    SUMA_DECENAS
        GOTO    SUMA_UNIDADES
SUMA_DECENAS
        MOVWF   AUXILIAR
        INCF    BCD_DECENAS,1
        GOTO    S_DECENAS
SUMA_UNIDADES
        MOVF    AUXILIAR,W
        MOVWF   BCD_UNIDADES
        MOVLW   d'48'
        ADDWF   BCD_UNIDADES,F
        ADDWF   BCD_DECENAS,F
        ADDWF   BCD_CENTENAS,F
        RETURN

Código: ASM

;********************NEXTION_TX_RC.INC******************************************
;****************  SUBRUTINA INICIALISA, ENVIA Y RECIBE  ***********************
;*******************************************************************************
;               BIT A DECLARAR PARA ESTA SUBRUTINA 
;                   
;   PUERTO_TX   EQU     6       ;PIN DE TRANSMICION
;   PUERTO_RC   EQU     7       ;PINDE RECEPCION
;                   
;                   
;******************************  INICIO  ***************************************
                        CBLOCK
                        Dato_TX_1
                        Dato_TX_2
                        Dato_TX_3
                        Dato_TX_4
                        Dato_TX_5
                        Dato_TX_6
                        Dato_TX_7
                        Dato_TX_8
                        Dato_TX_9
                        Dato_TX_10
                        Dato_TX_11
                        Dato_TX_12
                        Dato_TX_13
                        Dato_TX_Fin             ;FIN DE TRANSMICION ENVIAR E 
                        ENDC                    ;VECES PARA QUE LA PANTALLA 
                                                ;LEA FIN DE TRANSMICION 
Inicia_USART_Nextion    BSF     STATUS,RP0      ;ENTRO EN BANCO 1
                        BCF     STATUS,RP1                      
                        BCF     TRISC,PUERTO_TX ;PONE A (0) ESTE PIN COMO SALIDA 
                        BSF     TRISC,PUERTO_RC ;PONE A (1) ESTE PIN COMO ENTRADA
                        MOVLW   0x24            ;TX HABILITADA, MODO ASINCRON0
                        MOVWF   TXSTA           ;CON 8 BITS Y ALTA VELOCIDAD
                        MOVLW   0x19            ;SET BAUDIOS A 9600   
                        MOVWF   SPBRG           ;CON Fosc = 4MHz
                        BCF     STATUS,RP0      ;ENTRO EN BANCO 0
                        BCF     STATUS,RP1
                        MOVLW   0x90            ;AJUSTA RECEPTOR A 8 BITS, RECEPCION
                        MOVWF   RCSTA           ;CONTINUA HABILITADA USART EN ON
                        MOVLW   'ÿ'    
                        MOVWF   Dato_TX_Fin
                        RETURN
 
 
                    
Envia_USART_Nextion     BSF     STATUS,RP0
                        BCF     STATUS,RP1
                        BTFSS   TXSTA,TRMT
                        GOTO    Envia_USART_Nextion
                        BCF     STATUS,RP0
                        BCF     STATUS,RP1
                        MOVWF   TXREG
                        RETURN
                    
Recibe_USART_Nextion    BCF     STATUS,RP0
                        BCF     STATUS,RP1
                        BTFSS   PIR1,RCIF
                        GOTO    Recibe_USART_Nextion
                        MOVF    RCREG,W
DATO                    BCF     PIR1,RCIF
                        BSF     STATUS,RP0
                        BCF     STATUS,RP1
                        
                        RETURN
 
Nextion                 MOVf    Dato_TX_1,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_2,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_3,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_4,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_5,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_6,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_7,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_8,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_9,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_10,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_Fin,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_Fin,W
                        CALL    Envia_USART_Nextion
                        MOVF    Dato_TX_Fin,W
                        CALL    Envia_USART_Nextion
                        RETURN

Código: ASM

;**************************** Librería "RETARDOS.INC" *********************************
; Librería con múltiples subrutinas de retardos, desde 4 microsegundos hasta 20 segundos. 
; Además se pueden implementar otras subrutinas muy fácilmente.
;
; Se han calculado para un sistema microcontrolador con un PIC trabajando con un cristal
; de cuarzo a 4 MHz. Como cada ciclo máquina son 4 ciclos de reloj, resulta que cada
; ciclo máquina tarda 4 x 1/4MHz = 1 µs.
;
; En los comentarios, "cm" significa "ciclos máquina".
;
; ZONA DE DATOS *********************************************************************
 
        CBLOCK
        R_ContA                         ; Contadores para los retardos.
        R_ContB
        R_ContC
        ENDC
;
; RETARDOS de 4 hasta 10 microsegundos ---------------------------------------------------
;
; A continuación retardos pequeños teniendo en cuenta que para una frecuencia de 4 MHZ,
; la llamada a subrutina "call" tarda 2 ciclos máquina, el retorno de subrutina
; "return" toma otros 2 ciclos máquina y cada instrucción "nop" tarda 1 ciclo máquina.
;
Retardo_10micros                                ; La llamada "call" aporta 2 ciclos máquina.
        nop                             ; Aporta 1 ciclo máquina.
        nop                             ; Aporta 1 ciclo máquina.
        nop                             ; Aporta 1 ciclo máquina.
        nop                             ; Aporta 1 ciclo máquina.
        nop                             ; Aporta 1 ciclo máquina.
Retardo_5micros                         ; La llamada "call" aporta 2 ciclos máquina.
        nop                             ; Aporta 1 ciclo máquina.
Retardo_4micros                         ; La llamada "call" aporta 2 ciclos máquina.
        return                          ; El salto del retorno aporta 2 ciclos máquina.
;
; RETARDOS de 20 hasta 500 microsegundos ------------------------------------------------
;
Retardo_500micros                               ; La llamada "call" aporta 2 ciclos máquina.
        nop                             ; Aporta 1 ciclo máquina.
        movlw   d'164'                  ; Aporta 1 ciclo máquina. Este es el valor de "K".
        goto    RetardoMicros           ; Aporta 2 ciclos máquina.
Retardo_200micros                               ; La llamada "call" aporta 2 ciclos máquina.
        nop                             ; Aporta 1 ciclo máquina.
        movlw   d'64'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
        goto    RetardoMicros           ; Aporta 2 ciclos máquina.
Retardo_100micros                               ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'31'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
        goto    RetardoMicros           ; Aporta 2 ciclos máquina.
Retardo_50micros                                ; La llamada "call" aporta 2 ciclos máquina.
        nop                             ; Aporta 1 ciclo máquina.
        movlw   d'14'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
        goto    RetardoMicros           ; Aporta 2 ciclos máquina.
Retardo_20micros                                ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "K".
;
; El próximo bloque "RetardoMicros" tarda:
; 1 + (K-1) + 2 + (K-1)x2 + 2 = (2 + 3K) ciclos máquina.
;
RetardoMicros
        movwf   R_ContA                 ; Aporta 1 ciclo máquina.
Rmicros_Bucle
        decfsz  R_ContA,F               ; (K-1)x1 cm (cuando no salta) + 2 cm (al saltar).
        goto    Rmicros_Bucle           ; Aporta (K-1)x2 ciclos máquina.
        return                          ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_500micros:  2 + 1 + 1 + 2 + (2 + 3K) = 500 cm = 500 µs. (para K=164 y 4 MHz).
; - Retardo_200micros:  2 + 1 + 1 + 2 + (2 + 3K) = 200 cm = 200 µs. (para K= 64 y 4 MHz).
; - Retardo_100micros:  2     + 1 + 2 + (2 + 3K) = 100 cm = 100 µs. (para K= 31 y 4 MHz).
; - Retardo_50micros :  2 + 1 + 1 + 2 + (2 + 3K) =  50 cm =  50 µs. (para K= 14 y 4 MHz).
; - Retardo_20micros :  2     + 1     + (2 + 3K) =  20 cm =  20 µs. (para K=  5 y 4 MHz).
;
; RETARDOS de 1 ms hasta 200 ms. --------------------------------------------------------
;
Retardo_200ms                           ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'200'                  ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_100ms                           ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'100'                  ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_50ms                            ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'50'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_20ms                            ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'20'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_10ms                            ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'10'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_5ms                             ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_2ms                             ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'2'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
        goto    Retardos_ms             ; Aporta 2 ciclos máquina.
Retardo_1ms                             ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'1'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
;
; El próximo bloque "Retardos_ms" tarda:
; 1 + M + M + KxM + (K-1)xM + Mx2 + (K-1)Mx2 + (M-1) + 2 + (M-1)x2 + 2 =
; = (2 + 4M + 4KM) ciclos máquina. Para K=249 y M=1 supone 1002 ciclos máquina
; que a 4 MHz son 1002 µs = 1 ms.
;
Retardos_ms
        movwf   R_ContB                 ; Aporta 1 ciclo máquina.
R1ms_BucleExterno
        movlw   d'249'                  ; Aporta Mx1 ciclos máquina. Este es el valor de "K".
        movwf   R_ContA                 ; Aporta Mx1 ciclos máquina.
R1ms_BucleInterno
        nop                             ; Aporta KxMx1 ciclos máquina.
        decfsz  R_ContA,F               ; (K-1)xMx1 cm (cuando no salta) + Mx2 cm (al saltar).
        goto    R1ms_BucleInterno               ; Aporta (K-1)xMx2 ciclos máquina.
        decfsz  R_ContB,F               ; (M-1)x1 cm (cuando no salta) + 2 cm (al saltar).
        goto    R1ms_BucleExterno       ; Aporta (M-1)x2 ciclos máquina.
        return                          ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_200ms:      2 + 1 + 2 + (2 + 4M + 4KM) = 200007 cm = 200 ms. (M=200 y K=249).
; - Retardo_100ms:      2 + 1 + 2 + (2 + 4M + 4KM) = 100007 cm = 100 ms. (M=100 y K=249).
; - Retardo_50ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  50007 cm =  50 ms. (M= 50 y K=249).
; - Retardo_20ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  20007 cm =  20 ms. (M= 20 y K=249).
; - Retardo_10ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  10007 cm =  10 ms. (M= 10 y K=249).
; - Retardo_5ms  :      2 + 1 + 2 + (2 + 4M + 4KM) =   5007 cm =   5 ms. (M=  5 y K=249).
; - Retardo_2ms  :      2 + 1 + 2 + (2 + 4M + 4KM) =   2007 cm =   2 ms. (M=  2 y K=249).
; - Retardo_1ms  :      2 + 1     + (2 + 4M + 4KM) =   1005 cm =   1 ms. (M=  1 y K=249).
;
; RETARDOS de 0.5 hasta 20 segundos ---------------------------------------------------
;
Retardo_20s                             ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'200'                  ; Aporta 1 ciclo máquina. Este es el valor de "N".
        goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
Retardo_10s                             ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'100'                  ; Aporta 1 ciclo máquina. Este es el valor de "N".
        goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
Retardo_5s                              ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'50'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
        goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
Retardo_2s                              ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'20'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
        goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
Retardo_1s                              ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'10'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
        goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
Retardo_500ms                           ; La llamada "call" aporta 2 ciclos máquina.
        movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "N".
;
; El próximo bloque "Retardo_1Decima" tarda:
; 1 + N + N + MxN + MxN + KxMxN + (K-1)xMxN + MxNx2 + (K-1)xMxNx2 +
;   + (M-1)xN + Nx2 + (M-1)xNx2 + (N-1) + 2 + (N-1)x2 + 2 =
; = (2 + 4M + 4MN + 4KM) ciclos máquina. Para K=249, M=100 y N=1 supone 100011
; ciclos máquina que a 4 MHz son 100011 µs = 100 ms = 0,1 s = 1 décima de segundo.
;
Retardo_1Decima
        movwf   R_ContC                 ; Aporta 1 ciclo máquina.
R1Decima_BucleExterno2
        movlw   d'100'                  ; Aporta Nx1 ciclos máquina. Este es el valor de "M".
        movwf   R_ContB                 ; Aporta Nx1 ciclos máquina.
R1Decima_BucleExterno
        movlw   d'249'                  ; Aporta MxNx1 ciclos máquina. Este es el valor de "K".
        movwf   R_ContA                 ; Aporta MxNx1 ciclos máquina.
R1Decima_BucleInterno          
        nop                             ; Aporta KxMxNx1 ciclos máquina.
        decfsz  R_ContA,F               ; (K-1)xMxNx1 cm (si no salta) + MxNx2 cm (al saltar).
        goto    R1Decima_BucleInterno   ; Aporta (K-1)xMxNx2 ciclos máquina.
        decfsz  R_ContB,F               ; (M-1)xNx1 cm (cuando no salta) + Nx2 cm (al saltar).
        goto    R1Decima_BucleExterno   ; Aporta (M-1)xNx2 ciclos máquina.
        decfsz  R_ContC,F               ; (N-1)x1 cm (cuando no salta) + 2 cm (al saltar).
        goto    R1Decima_BucleExterno2  ; Aporta (N-1)x2 ciclos máquina.
        return                          ; El salto del retorno aporta 2 ciclos máquina.
;
;En total estas subrutinas tardan:
; - Retardo_20s:        2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 20000807 cm = 20 s.
;                       (N=200, M=100 y K=249).
; - Retardo_10s:        2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 10000407 cm = 10 s.
;                       (N=100, M=100 y K=249).
; - Retardo_5s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  5000207 cm =  5 s.
;                       (N= 50, M=100 y K=249).
; - Retardo_2s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  2000087 cm =  2 s.
;                       (N= 20, M=100 y K=249).
; - Retardo_1s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  1000047 cm =  1 s.
;                       (N= 10, M=100 y K=249).
; - Retardo_500ms:      2 + 1     + (2 + 4N + 4MN + 4KMN) =   500025 cm = 0,5 s.
;                       (N=  5, M=100 y K=249).

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 16 de Agosto de 2018, 16:01:28

buenas a todos:

a partir de las conclusiones sacadas al respecto, decidí empezar poco a poco con el rompe como de hacer una subrutina para un manejo diría yo bastante amplio.
para empezar y siguiendo el orden de la lista de objeto, la primera es TEXTO. ya me tope con solo un problema. paso a esplicar
para enviar un texto o modificar el texto en esta pantalla de a lo siguiente: (usando como ejemplo el texto hola mundo) t0.txt="hola mundo"ÿÿÿ
donde (t) es el objeto texto, (0) el numero de objeto (recuerden que puede ir desde 0 asta 255 objetos), (.) separación, (txt) la variable que yo quiero modificar, (=), ("hola mundo")mensaje que
quiero visualizar (a de ir cerrado por las comillas aunque estas no aparecen en el mensaje) y (ÿÿÿ) fin de envió (necesario si no nextion sigue esperando mas)
el programa y la subrutina funcionan bien si se visualiza en el Hyper Terminal (si lo quieren probar tener en cuenta que en el Hyper Terminal este caracter (ÿ) me sale como espacio en blanco,
desconozco porque, ya que en el programa de edición de la pantalla y en otro programa de conexión rs232 si me aparece. acepto sugerencias),
pero tanto en la pantalla como en el debuger de del programa nextion no funciona, y el problema es el siguiente
como tenemos un numero limitado de objetos "t" (objeto texto) e de especificar a cual de ellos me dirijo. por eso antes de llamar a la subrutina primero cargo el numero del objeto, lo convierto a bcd y solo bcd de momento y lo paso por una rutina que pregunta a cada resultado (unidades, decenas y centenas) si su valor es "0".

si no es "0" en centenas pasa a ascii los tres resultados y los muevo a tres registros para enviar
si es "0" salta y pregunta a decenas
si no es "0" paso a ascii solo unidades y centenas pero al traspasarlos a los tres registros para enviar, en el lugar donde debería ir las centenas coloco el decimal "0" que en ascii es carácter nulo
si es "0" salta y no pregunta paso unidades a ascii y lo guardo en registro que le corresponde de los tres que uso para enviar y a los otros dos donde debería ir decena y centena le coloco decimal "0"
esto en mis programas de rs232 sale perfecto pero para la pantalla el nulo no es nulo me lo detecta como espacio en blanco
solo funciona cuando el numero del objeto es 100 o superior (esto es porque ya no envió nulo).

a ver que solución le veis vosotros.
os adjunto programa y dos imagenes
saludos

Código: ASM

;------------------------------------------------------------
; Código assembler 
; Proyecto: usart_prueba
; Autor: 
; Fecha: 06/08/2018
; PIC: 16F877A
; Velocidad de reloj: 4 Mhz
; Descripcion: 
;------------------------------------------------------------
                    LIST    P=PIC16F877A
                    INCLUDE P16F877A.INC
 
        __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
    
                   
                    
 
 
 
PUERTO_TX           EQU         6       ;PIN DE TRANSMICION
PUERTO_RC           EQU         7       ;PINDE RECEPCION                
                
                    CBLOCK      0x20
                    ENDC
STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
                    PAGESEL     COMIENZO
                    GOTO        COMIENZO    ;COMIENZO DEL PROGRAMA
                    CODE
T_Texto_NEX         MOVWF       PCL
Mensaje_NEX_1       DT          "HOLA MUNDO", 0x00
;////////           //          //        2,0X00  
 
            
            
COMIENZO            MOVLW       d'1'
                    MOVWF       NUM_OBJ
                    CALL        Nex_Texto_Inicializa
                
                   
Principal           MOVLW       Mensaje_NEX_1
                    CALL        Nex_Texto
                    CALL        Retardo_1s
                    GOTO        Principal
                    INCLUDE     <NEXTION_SUB.INC>
                    INCLUDE     <RETARDOS.INC>
 
                  
                    END

Código: ASM

CBLOCK
                        Guarda_Posicion_Tabla
                        Guarda_Caracter
                        NUM_OBJ
                        DATO_TX_0
                        DATO_TX_1
                        DATO_TX_2
                        DATO_TX_3
                        DATO_TX_4
                        DATO_TX_5
                        DATO_TX_6
                        DATO_TX_7
                        DATO_TX_8
                        DATO_TX_9
                        DATO_TX_10
                        ENDC
Nex_Texto_Inicializa    CALL    Inicia_USART_Nextion
                        MOVLW   't'
                        MOVWF   DATO_TX_0
                        MOVF    NUM_OBJ,W
                        CALL    BIN_BCD
                        CALL    Si_Uni_Dec_Cen
                        MOVLW   '.'
                        MOVWF   DATO_TX_4
                        MOVLW   't'
                        MOVWF   DATO_TX_5
                        MOVLW   'x'
                        MOVWF   DATO_TX_6
                        MOVLW   't'
                        MOVWF   DATO_TX_7
                        MOVLW   '='
                        MOVWF   DATO_TX_8
                        MOVLW   '"'
                        MOVWF   DATO_TX_9
                        RETURN
Nex_Texto               MOVWF   Guarda_Posicion_Tabla
                        MOVf    DATO_TX_0,W
                        CALL    Envia_USART_Nextion
                        MOVf    DATO_TX_1,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_2,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_3,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_4,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_5,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_6,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_7,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_8,W
                        CALL    Envia_USART_Nextion
                        MOVF    DATO_TX_9,W
                        CALL    Envia_USART_Nextion
Nex_Texto_1             MOVF    Guarda_Posicion_Tabla,W
                        CALL    T_Texto_NEX
                        MOVWF   Guarda_Caracter
                        MOVF    Guarda_Caracter,F
                        BTFSS   STATUS,Z
                        GOTO    Nex_Texto_2
                        MOVF    DATO_TX_9,W
                        CALL    Envia_USART_Nextion
                        MOVLW   'ÿ'
                        CALL    Envia_USART_Nextion
                        MOVLW   'ÿ'
                        CALL    Envia_USART_Nextion
                        MOVLW   'ÿ'
                        CALL    Envia_USART_Nextion
                        RETURN  
Nex_Texto_2             CALL    Envia_USART_Nextion
                        INCF    Guarda_Posicion_Tabla,F
                        GOTO    Nex_Texto_1
 
                        
                        
                        
;********************BIN_BCD_ASCII**********************************************
                                
                                CBLOCK                  
                                AUXILIAR 
                                BCD_UNIDADES
                                BCD_DECENAS
                                BCD_CENTENAS    
                                ENDC
BIN_BCD
                        MOVWF   AUXILIAR
                        CLRF    BCD_UNIDADES
                        CLRF    BCD_DECENAS
                        CLRF    BCD_CENTENAS
S_Centenas
                        MOVLW   d'100'
                        SUBWF   AUXILIAR,W
                        BTFSC   STATUS,C
                        GOTO    Suma_Centenas
                        GOTO    S_Decenas
Suma_Centenas
                        MOVWF   AUXILIAR
                        INCF    BCD_CENTENAS,F
                        GOTO    S_Centenas
S_Decenas
                        MOVLW   d'10'
                        SUBWF   AUXILIAR,W
                        BTFSC   STATUS,C
                        GOTO    Suma_Decenas
                        GOTO    Suma_Unidades
Suma_Decenas
                        MOVWF   AUXILIAR
                        INCF    BCD_DECENAS,1
                        GOTO    S_Decenas
Suma_Unidades
                        MOVF    AUXILIAR,W
                        MOVWF   BCD_UNIDADES
                        BCF     STATUS,Z
                        BCF     STATUS,C
                        
                        RETURN
;***************** SOLO SI CUALQUIERA DE LOS REGISTROS BCD>0********************
Si_Uni_Dec_Cen      MOVF        BCD_CENTENAS,W      
                    SUBLW       d'0'
                    BTFSS       STATUS,Z
                    GOTO        Todo_UDC
                    GOTO        Pregunta_Dec
Todo_UDC            MOVLW       d'48'
                    ADDWF       BCD_UNIDADES,F
                    ADDWF       BCD_DECENAS,F
                    ADDWF       BCD_CENTENAS,F
                    
                    MOVF        BCD_UNIDADES,W
                    MOVWF       DATO_TX_3
                    MOVF        BCD_DECENAS,W
                    MOVWF       DATO_TX_2
                    MOVF        BCD_CENTENAS,W
                    MOVWF       DATO_TX_1
                    BCF         STATUS,Z
                    BCF         STATUS,C
                    RETURN
                    
Pregunta_Dec        MOVF        BCD_DECENAS,W       
                    SUBLW       d'0'
                    BTFSS       STATUS,Z
                    GOTO        Todo_UD
                    GOTO        Solo_Uni
Todo_UD             MOVLW       d'48'
                    ADDWF       BCD_UNIDADES,F
                    ADDWF       BCD_DECENAS,F
                    MOVF        BCD_UNIDADES,W
                    MOVWF       DATO_TX_3
                    MOVF        BCD_DECENAS,W
                    MOVWF       DATO_TX_2
                    MOVLW       d'0'
                    MOVWF       DATO_TX_1
                    BCF         STATUS,Z
                    BCF         STATUS,C
                    RETURN
 
Solo_Uni            MOVLW       d'48'
                    ADDWF       BCD_UNIDADES,F
                    MOVF        BCD_UNIDADES,W
                    MOVWF       DATO_TX_3
                    MOVLW       d'0'
                    MOVWF       DATO_TX_2
                    MOVLW       d'0'
                    MOVWF       DATO_TX_1
                    RETURN
                    
;******************INICIA COMUNICACION USART************************************                    
Inicia_USART_Nextion    BSF     STATUS,RP0      
                        BCF     STATUS,RP1                      
                        BCF     TRISC,PUERTO_TX ;PONE A (0) ESTE PIN COMO SALIDA 
                        BSF     TRISC,PUERTO_RC ;PONE A (1) ESTE PIN COMO ENTRADA
                        MOVLW   0x24            ;TX HABILITADA, MODO ASINCRON0
                        MOVWF   TXSTA           ;CON 8 BITS Y ALTA VELOCIDAD
                        MOVLW   0x19            ;SET BAUDIOS A 9600   
                        MOVWF   SPBRG           ;CON Fosc = 4MHz
                        BCF     STATUS,RP0      ;ENTRO EN BANCO 0
                        BCF     STATUS,RP1
                        MOVLW   0x90            ;AJUSTA RECEPTOR A 8 BITS, RECEPCION
                        MOVWF   RCSTA           ;CONTINUA HABILITADA USART EN ON
                        RETURN
;*****************ENVIA Y RECIBE USART******************************************
Envia_USART_Nextion     BSF     STATUS,RP0
                        BCF     STATUS,RP1
                        BTFSS   TXSTA,TRMT
                        GOTO    Envia_USART_Nextion
                        BCF     STATUS,RP0
                        BCF     STATUS,RP1
                        MOVWF   TXREG
                        RETURN
Recibe_USART_Nextion    BCF     STATUS,RP0
                        BCF     STATUS,RP1
                        BTFSS   PIR1,RCIF
                        GOTO    Recibe_USART_Nextion
                        MOVF    RCREG,W
DATO                    BCF     PIR1,RCIF
                        BSF     STATUS,RP0
                        BCF     STATUS,RP1
                        RETURN

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 16 de Agosto de 2018, 19:35:42

buenas.

me auto respondo.

como dije antes ay tres registros en este caso DATO_TX_1(centenas) DATO_TX_2(decenas) DATO_TX_3(unidades) que uso como auxiliares a la otra de transmitir por el usar

estos fueron cargados con los registros unidades, decenas y centenas que pasa que si envió los tres. el dato seria (txxx.texto="hola mundo"ÿÿÿ) si digo que el objeto es el numero 1 entonces

(t001.txt="..........) que pasa nextion no no acepta los ceros por delante (t001) que hice, pensando que en ascii el '0' es nulo, en la criba a los registros que no me interesaba mandar nada le

asigne '0'. perfecto en hyper terminal salia perfecto cambiaba el numero de objeto y la criba funciona. pero la pantalla o el debug del programa de la pantalla si que reconoce el nulo, por ende

ella recibía esto: ( t 0.txt="hola mundo"ÿÿÿ) como se ve ay dos espacios vacíos entre t y el numero de objeto, por ese motivo solo funcionaba en la pantalla si el numero era 100 o mas

porque en la criba entraban unidades, decenas y centenas. solución para que no me envié los nulos, meter un filtro justo antes de la salida pregunto cuales son ceros y los descaro solo envió

todo lo que no es cero.

PD; ahora continuare con lo atributos modificables al objeto texto ( lo bueno es que puedo aprovechar la misma rutina bin a bcd, la rutina de criba, la de envió por usart)
PD; posiblemente esta subrutina la modifique para agregar como predeterminado el numero de pagina así no tendríamos que entrar primero a la pagina y luego modificar el texto o los atributos.

dejo los fichero para experimentar. saludos

PD: os dejo un programa con varios mensajes temporizados
PD: para simula se puede descargar el sof de nesxtion aqui https://nextion.itead.cc/resources/download/nextion-editor/ (esto es lo bueno no hace falta tener la pantalla fisica )

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 17 de Agosto de 2018, 12:27:22

Lo voy a hacer mas simple...

Para enviar algo a la pantalla necesitas:

- Enviar el objeto, ejemplo "t" de texto, y nos se que mas hay
- Enviar el numero de objeto, sin 0 precedentes
- Enviar un punto.
- Enviar el parametro a modificar, hasta ahora el unico que conozco es "txt"
- Enviar '='
- En caso de que sea texto, enviar un texto encerrado entre comillas.
- Enviar ÿÿÿ

Me gustaria si es posible que me digas lo siguiente, para poder ayudarte:

- Que otros tipos de objetos vas a usar aunque sea 1 mas
- Que parametros poseen cada objeto, obviamente los que vas a usar, no todos, no tiene sentido programar para todos.
- Luego del igual, dependiendo del parametro que se debe enviar?, texto,numero,etc.
- el valor ÿÿÿ, ¿que valor hexadecimal posee?

Citar

si lo quieren probar tener en cuenta que en el Hyper Terminal este caracter (ÿ) me sale como espacio en blanco,
desconozco porque, ya que en el programa de edición de la pantalla y en otro programa de conexión rs232 si me aparece. acepto sugerencias),

Esto es porque depende del charset que se use, Creo que windows posee una diferencia, ya que si vos tratas de usar Alt + 255 utiliza un charset que es el CP-437 en mi caso, generando ese "espacio vacio", lo podes ver en la tabla:

https://es.wikipedia.org/wiki/P%C3%A1gina_de_c%C3%B3digos_437

Ahora si usas Alt + 0255 utiliza el charset CP-1252 / Windows-1252, que es el que posee el caracter: ÿ

https://en.wikipedia.org/wiki/Windows-1252

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 17 de Agosto de 2018, 23:31:35

buenas.

os dejo la primera rutina de atributos para el objeto texto, teniendo esta rutina el resto saldrá rápido y podremos pasar a otro objeto.

en el programa principal a bajo de todo voy a ir dejando una pequeña descripción de cada rutina que se va a ir añadiendo.

SALUDOS

PD:a por el resto. Nota: en el programa edito de la pantalla ay la opción depug que nos permite conectar nuestro pic por el puerto rs232 y simular para el que no tenga la pantalla
esta muy bien porque nos permite ver el código que le enviamos y ver físicamente el aspecto que tendrá en nuestra pantalla.
tengo una pantalla ejemplo que es la que uso y usare para cara rutina que saque, pero no la puedo subir por su tamaño. si alguien la quiere que me avise. de todas formas
cuando bajen el programa verán que es bastante fácil para hacer cosas básicas.

reponiendo a KILLERJC:

parámetro para el primer objeto que estoy haciendo las "X" las pongo porque ay una variable numerica

el objeto es TEXTO. envía texto--> tXXX.txt="aqui texto"ÿÿÿ -->Ej: t0.txt="HOLA MUNDO"ÿÿÿ

color fondo--> tXXX.bco= aqui de 0 a65535 ÿÿÿ -->Ej: t0.bco=10000ÿÿÿ

color fuente--> tXXX.pco=aqui de 0 a65535 ÿÿÿ -->Ej: t0.pco=10000ÿÿÿ

tipo fuente--> tXXX.font=XXXÿÿÿ -->Ej: t0.font=1ÿÿÿ ; esta depende de la cantidad de fuentes que ayas cargado en la pantalla desde el edito Nextion

xcen esta es para la posición del texto dentro del marco derecha centro izquierda
ycen esta es para la posición del texto dentro del marco arriba centro abajo

y ay la proclividad de poder mover el marco dentro de pantalla desde el pic, pero esto es algo mas complicado, ahora mismo no es imprescindible para un manejo básico desde el pic.
se me ocurre que se podría utilizar para hacer un texto flotante.

tened en cuenta que estoy aprendiendo a medida que hago las rutinas, a manejar esta pantalla, porque en realidad todo esto se puede gestionar dentro de la pantalla.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 17 de Agosto de 2018, 23:44:48

buenas.

añado rutina atributo color fuentes

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 00:36:43

buenas.

añado rutina Nex_Texto_Passwor.

1 para password on y 0 para passwor off --> tXX.pw=Xÿÿÿ

si password on, intercambia todo el texto por asteriscos

NOTA: en un objeto texto no puede entra mas de 254 caracteres. ( voy haciendo comentarios en fusión a lo que aprendo)

PD: agradezco la rutina de binario a bcd 16 bits que subió "suky" y a " Pinolillo16"binario a bcd 8 bits, las de la implemente y no di las gracias
si es posible me gustaría tener la de binario a bcd 16 bit bien explicada, porque la de 8 entiendo el funcionamiento y estoy seguro que tengo una bien explicada solo que por no buscar entre mis cosas ya aproveche la de Pinolillo16. pero la de 16 es diferente a la que tengo yo pero esta es mas compacta y me gustaría entenderla

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 02:12:36

buenas.

añado rutina Nex_Texto_Pos_X --> tXXX.xcen=Xÿÿÿ

esta rutina posiciona nuestro texto en el eje x. tiene 3 posiciones. si no se declara la posición o esta es mayor que 2, por defecto ella la pondrá en 0 (derecha).

derecha = 0
centro = 1
izquierda = 2

PD: estas instrucciones que en enviamos por usart, son las mismas que se pueden usar en el editor de Nextion, para los programas que hagan directamente en el edito, prescindiendo del pic
con la diferencia que al final no ay que poner ÿÿÿ

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 02:29:25

buenas.

añado rutina Nex_Texto_Pos_Y --> tXXX.ycen=Xÿÿÿ

esta rutina posiciona nuestro texto en el eje y. tiene 3 posiciones. si no se declara la posición o esta es mayor que 2, por defecto ella la pondrá en 0 (up).

up = 0
centro = 1
down = 2

PD; en las pruebas con las rutinas de posicionamiento del texto, e detectado que si el marco del texto no es lo suficientemente grande, no se aprecia el movimiento.
aconsejo que para las pruebas no meter demacrado texto y extender el marco a una medida que os permita ver el funcionamiento.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 03:37:11

buenas.

añado rutina Nex_Texto_Linea --> tXXX.isbr=Xÿÿÿ

esta rutina lo que hace es que pone el mensaje todo en una linea o salta al renglón de a bajo cuando el mensaje supera en tamaño al marco.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 11:39:34

buenas.

añado el ultimo atributo para el objeto texto. Nex_Texto_Fuente --> tXXX.font=Xÿÿÿ

con esta rutina ay que tener en cuenta la cantidad de fuentes cargadas en el editor de nextion. el máximo permitido son 255.

con esta rutina termino el objeto texto y pasare al objeto (text scrolling).
sintaxis;
gXXX.txt="aqui texto"ÿÿÿ envía texto
gXXX.bco=XXXXXÿÿÿ color fondo del maro de 0 a 65535
gXXX.pco=XXXXXÿÿÿ color de la fuente de 0 a 65535
gXXX.font=XXXÿÿÿ tipo de fuente de 0 a 255 en función de las cantidad de fuentes cargadas en el editor nextion
gXXX.xcen=Xÿÿÿ posición en eje x del texto 0=derecha 1=centro 2=izquierda
gXXX.ycen=Xÿÿÿ posición en eje y del texto 0=arriba 1=centro 2=abajo
gXXX.dir=Xÿÿÿ dirección en que se mueve de arriba asía abajo, de abajo asía arriba, de derecha a izquierda, de izquierda a derecha (0, 1, 2 y 4 aun por determinar )
gXXX.tim=XXXXXÿÿÿ tiempo de espera entre saltos minimo 90 maximo 65534
gXXX.dis=XXÿÿÿ distancia entre saltos minimo 2 maximo 50
gXXX.en=Xÿÿÿ activado desplazamiento 0 off 1on

esta también ira rápido

por favor viendo mas o menos como va el funcionamiento, si creéis que se puede mejorar el método díganmelo. y estudiaremos pros y contras para hacer la modificación que corresponda
saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 18 de Agosto de 2018, 13:56:21

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

Código: ASM

; Defines para el uso de la libreria
NXT_TEXT_T      EQU  0
NXT_TXTSC_T     EQU  1
 
NXT_TXT_OPT     EQU  0
NXT_BCO_OPT     EQU  1  
NXT_PCO_OPT     EQU  2
NXT_FNT_OPT     EQU  3          
        
    ; Vars para la libreria
    
    CBLOCK 0x20
    NXT_TIPO
    NXT_NUMBER
    NXT_OPTION
    NumH        ; Binary a BCD
    NumL
    TenK        ; BCD Result
    Thou
    Hund
    Tens
    Ones
    TMP         ; Temporal
    ENDC
 
;Comienzo de programa
    
    ;Vector de reset
    ORG 0x00
    GOTO INICIO
    ;Vector de interrupcion
    ORG 0x04
    RETURN
     
TIPO_TABLA:
    ADDWF  PCL, F
    RETLW  't'
    RETLW  'g'
 
OBTENER_OPT:
    ADDWF PCL, F
TXT_OPT_TXT:    DT "txt",0x00    
TXT_OPT_BCO:    DT "bco",0x00
TXT_OPT_PCO:    DT "pco",0x00   
TXT_OPT_FNT:    DT "fnt",0x00
        
OPT_TABLA:
    ADDWF PCL, F
    RETLW   TXT_OPT_TXT - TXT_OPT_TXT
    RETLW   TXT_OPT_BCO - TXT_OPT_TXT
    RETLW   TXT_OPT_PCO - TXT_OPT_TXT
    RETLW   TXT_OPT_FNT - TXT_OPT_TXT
 
OPT_STRING:
        ;MOVLW 02H
        ;MOVWF PCLATH
        MOVF NXT_OPTION, W
        CALL OPT_TABLA
        MOVWF TMP       
 
OPT_STRING_1:
        MOVF TMP, W
        CALL OBTENER_OPT
        ADDLW 0 
        BTFSC STATUS, Z
        GOTO OPT_STRING_2
        CALL ENVIAR_CHAR
        INCF TMP, F
        GOTO OPT_STRING_1
OPT_STRING_2:
        RETURN    
    
INICIO:
 
    CLRF NXT_TIPO
    CLRF NXT_NUMBER
    CLRF NXT_OPTION
    CLRF NumH       
    CLRF NumL
    CLRF TenK
    CLRF Thou
    CLRF Hund
    CLRF Tens
    CLRF Ones
 
    
PRINCIPAL:
    MOVLW NXT_TEXT_T
    MOVWF NXT_TIPO
    MOVLW .12
    MOVWF NXT_NUMBER
    MOVLW NXT_PCO_OPT
    MOVWF NXT_OPTION
    CALL  NXT_ENVIAR_INICIO
    CALL  NXT_ENVIAR_MENSAJE
    CALL  NXT_ENVIAR_FINAL
    
    
    GOTO PRINCIPAL
    
NXT_ENVIAR_INICIO:
    MOVF    NXT_TIPO, W     ; Envio el tipo
    CALL    TIPO_TABLA
    CALL    ENVIAR_CHAR
    CLRF    NumH
    MOVF    NXT_NUMBER, W
    MOVWF   NumL
    CALL    BIN_BCD
    CALL    ENVIAR_NUMERO   ; Envio el numero
    MOVLW   '.'
    CALL    ENVIAR_CHAR     ; Envio el .
    CALL    OPT_STRING      ; Envio la opcion
    MOVLW   '='
    CALL    ENVIAR_CHAR     ; Envio el IGUAL
    RETURN
    
NXT_ENVIAR_FINAL:
    MOVLW   0xFF
    CALL    ENVIAR_CHAR     ; Envio el final
    MOVLW   0xFF
    CALL    ENVIAR_CHAR     
    MOVLW   0xFF
    CALL    ENVIAR_CHAR
    RETURN
    
ENVIAR_CHAR:
    ;Aca enviar por UART.
    RETURN
    
ENVIAR_NUMERO:
    MOVLW   6
    MOVWF   TMP
    MOVLW   TenK
    MOVWF   FSR
ENVIAR_NUMERO_1:    
    DECF    TMP, F
    BTFSC   STATUS, Z
    RETURN
    MOVF    INDF, W
    BTFSC   STATUS, Z
    GOTO    ENVIAR_NUMERO_2
    ADDLW   '0'
    CALL    ENVIAR_CHAR
ENVIAR_NUMERO_2:
    INCF    FSR, F
    GOTO    ENVIAR_NUMERO_1
    
NXT_ENVIAR_MENSAJE:
    RETURN
    
;Takes hex number in NumH:NumL  Returns decimal in ;TenK:Thou:Hund:Tens:Ones
;written by John Payson
 
;input
;=A3*163 + A2*162 + A1*161 + A0*160
;=A3*4096 + A2*256 + A1*16 + A0
 
BIN_BCD:
        swapf   NumH,w  ;w  = A2*16+A3
        andlw   0x0F     ;w  = A3               *** PERSONALLY, I'D REPLACE THESE 2
        addlw   0xF0    ;w  = A3-16     *** LINES WITH "IORLW b'11110000B' " -AW
        movwf   Thou    ;B3 = A3-16
        addwf   Thou,f  ;B3 = 2*(A3-16) = 2A3 - 32
        addlw   .226    ;w  = A3-16 - 30 = A3-46
        movwf   Hund    ;B2 = A3-46
        addlw   .50     ;w  = A3-46 + 50 = A3+4
        movwf   Ones    ;B0 = A3+4
 
        movf    NumH,w  ;w  = A3*16+A2
        andlw   0x0F    ;w  = A2
        addwf   Hund,f  ;B2 = A3-46 + A2 = A3+A2-46
        addwf   Hund,f  ;B2 = A3+A2-46  + A2 = A3+2A2-46
        addwf   Ones,f  ;B0 = A3+4 + A2 = A3+A2+4
        addlw   .233    ;w  = A2 - 23
        movwf   Tens    ;B1 = A2-23
        addwf   Tens,f  ;B1 = 2*(A2-23)
        addwf   Tens,f  ;B1 = 3*(A2-23) = 3A2-69 (Doh! thanks NG)
 
        swapf   NumL,w  ;w  = A0*16+A1
        andlw   0x0F    ;w  = A1
        addwf   Tens,f  ;B1 = 3A2-69 + A1 = 3A2+A1-69 range -69...-9
        addwf   Ones,f  ;B0 = A3+A2+4 + A1 = A3+A2+A1+4 and Carry = 0 (thanks NG)
 
        rlf     Tens,f  ;B1 = 2*(3A2+A1-69) + C = 6A2+2A1-138 and Carry is now 1 as tens register had to be negitive
        rlf     Ones,f  ;B0 = 2*(A3+A2+A1+4) + C = 2A3+2A2+2A1+9 (+9 not +8 due to the carry from prev line, Thanks NG)
        comf    Ones,f  ;B0 = ~(2A3+2A2+2A1+9) = -2A3-2A2-2A1-10 (ones complement plus 1 is twos complement. Thanks SD)
;;Nikolai Golovchenko [golovchenko at MAIL.RU] says: comf can be regarded like:
;;      comf Ones, f
;;      incf Ones, f
;;      decf Ones, f
;;First two instructions make up negation. So,
;;Ones  = -1 * Ones - 1 
;;      = - 2 * (A3 + A2 + A1) - 9 - 1 
;;      = - 2 * (A3 + A2 + A1) - 10
        rlf     Ones,f  ;B0 = 2*(-2A3-2A2-2A1-10) = -4A3-4A2-4A1-20
 
        movf    NumL,w  ;w  = A1*16+A0
        andlw   0x0F    ;w  = A0
        addwf   Ones,f  ;B0 = -4A3-4A2-4A1-20 + A0 = A0-4(A3+A2+A1)-20 range -215...-5 Carry=0
        rlf     Thou,f  ;B3 = 2*(2A3 - 32) = 4A3 - 64
 
        movlw   0x07    ;w  = 7
        movwf   TenK    ;B4 = 7
 
;B0 = A0-4(A3+A2+A1)-20 ;-5...-200
;B1 = 6A2+2A1-138       ;-18...-138
;B2 = A3+2A2-46         ;-1...-46
;B3 = 4A3-64            ;-4...-64
;B4 = 7                 ;7
; At this point, the original number is
; equal to TenK*10000+Thou*1000+Hund*100+Tens*10+Ones 
; if those entities are regarded as two's compliment 
; binary.  To be precise, all of them are negative 
; except TenK.  Now the number needs to be normal- 
; ized, but this can all be done with simple byte 
; arithmetic.
 
        movlw   .10     ;w  = 10
Lb1:                    ;do
        addwf   Ones,f  ; B0 += 10
        decf    Tens,f  ; B1 -= 1
        btfss   3,0
        ;skip no carry
         goto   Lb1     ; while B0 < 0
        ;jmp carry
Lb2:                    ;do
        addwf   Tens,f  ; B1 += 10
        decf    Hund,f  ; B2 -= 1
        btfss   3,0
         goto   Lb2     ; while B1 < 0
Lb3:                    ;do
        addwf   Hund,f  ; B2 += 10
        decf    Thou,f  ; B3 -= 1
        btfss   3,0
         goto   Lb3     ; while B2 < 0
Lb4:                    ;do
        addwf   Thou,f  ; B3 += 10
        decf    TenK,f  ; B4 -= 1
        btfss   3,0
         goto   Lb4     ; while B3 < 0
 
        retlw   0
    END

La idea es que configures, que tipo de elemento queres ( t,g,etc) Luego cargues el numero de elemento asi es enviado. Teniendo toda una tabla de opciones, puedas elegir cual es la que queres enviar, se envia el '=' y luego donde dice ENVIAR_MENSAJE es donde o envias el texto o envias el numero, si es el numero podes usar la misma rutina que hay que se llama ENVIAR_NUMERO. Y finalmente donde dice ENVIAR_FINAL que es para terminar el mensaje. Aunque te sirva para ver como se puede hacer de otra forma.

La rutina binario a BCD lo saque de internet. La conversion de numeros es de 16bits a BCD todos separados. Y la funcion ENVIA_NUMERO procede a enviar si es que no hay un cero, hay un error ya que la numeracion 10 por ejemplo solo quedaria el 1. lo hice rapido sin pensarlo demasiado, ya que lo importante era el tema de las tablas.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 13:56:39

buenas.

os dejo aquí un linck donde podéis descargar el editor que es gratuito y un archivo llamado prueba.HMI para

probar las subrutinas de texto

https://drive.google.com/drive/folders/1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 14:00:31

ok dame unas horas que lo mire.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 14:40:30

mira esta mañana empece algo parecido, es mas fácil crear tablas con los tipos de objetos tablas para las funciones etc etc

llamar a cada una en función de la necesidad e ir enviado datos, no te mentiré es una excelente idea pero aquí mis dudas:

la primera en en que afate esto al tiempo de envió entre byte y byte ay que recordar que estamos trabajando con un estándar rs232
(mi caso agrupa todo y luego envía) tu caso si no me equivoco usa menos pila y ademas es menos extenso

la segunda es mas una pregunta ¿ la directiva DT no tiene que esta obligatoria-mente en el programa principal al principio o al final ?
si la respuesta es si para una subrutina no si es muy aconsejable. abría mas preguntas que respuestas. recuerda que mi idea es crear una subrutina que en cualquier programa principal
solo aya que ingresar un dato mínimo y llamar a la subrutina como muestro en cada ejemplo.

si la respuesta es no. esto lo cambia todo (y lo ciento pero te recuerdo que mi nivel de assembles no es muy alto, me defiendo pero no iré a la luna)
tendría crear una subrutina nueva utilizando este método la subiría y comentaríamos el resultado, pero esta claro que si es así seria mas rápido porque solo abría que agregar cosas a la tabla y un par de llamadas y listo
pero para mi lo importante es que nuestro programa principal no se llene de lineas que dependen de la subrutina y que la subrutina dependa del programa principal

de momento tengo estas inquietudes se agradece mucho vuestra colaboración.

PD de todas formas probare con una sola rutina este método

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 18 de Agosto de 2018, 15:05:49

Citar

a primera en en que afate esto al tiempo de envió entre byte y byte ay que recordar que estamos trabajando con un estándar rs232
(mi caso agrupa todo y luego envía) tu caso si no me equivoco usa menos pila y ademas es menos extenso

Un CALL y un RETURN son 4 ciclos de reloj mas,,, o sea no vas a notar gran diferencia de velocidad.

Citar

la segunda es mas una pregunta ¿ la directiva DT no tiene que esta obligatoria-mente en el programa principal al principio o al final ?

La directiva DT en realidad para los PIC16 crea una tabla con RETLW,, si vos haces:

Código: ASM

EJEM: DT "hola",0x00

Eso se traduce a :

Código: ASM

EJEM:
    RETLW 'h'
    RETLW 'o'
    RETLW 'l'
    RETLW 'a'
    RETLW 0x00

Que es "identico" a una tabla.

Entonces cual es el problema, o de donde sale eso de que es necesario si o si que este al comienzo o al final?
Para indexar una tabla necesitas sumarle al PCL, el problema es que el PCL son 8 bits nomas. Lo cual limita las tablas y los saltos a 255 en este caso, se puede crear un codigo que salte esta limitacion porsupuesto. La parte superior luego de calcularse el PCL se toma de PCLATH. Esto limitaria la capacidad de direccionamiento de la tabla, asi que una solucion y no usar el PCLATH es mantenerlo menor a 255 y ubicarlas al comienzo de las paginas 0x100, 0x200, 0x300, 0x2100 etc

El otro limitante es donde va a estar este codigo... Ya que los CALL y GOTO solo poseen 10 bits en su operando, es decir faltarian 2 bits los cuales son tomados desde el PCLATH.
Asi que si haces un GOTO y tu subrutina o tablas se encuentran al final, seguramente tengas problemas y no vaya a donde queres. A no ser que tengas en cuenta de modificar el PCLATH.

El RETURN no tiene problema, ya que devuelve todos los bits al Contador de programa ( PC )

Citar

mi idea es crear una subrutina que en cualquier programa principal
solo aya que ingresar un dato mínimo y llamar a la subrutina como muestro en cada ejemplo.

Y por mas que lo hagas como quieras, si tenes un programa demasiado grande que supere los 10bits en lo que ocupa , vas a tener problema si es que no lo tenes en cuenta.

Citar

pero para mi lo importante es que nuestro programa principal no se llene de lineas que dependen de la subrutina y que la subrutina dependa del programa principal

Y tu codigo funciona si es que los textos se encuentran dentro de los 255 posiciones de memoria. Fuera de esto, ya no funcionaria mas, ni hablar si tenes varios textos que facilmente llevarian a superar esos 255 lugares.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 16:53:18

buenas.

comprendo tu análisis.

ahora analizamos pro y contas.

tu método como dije antes es mas rápido y simple nos basamos en un mar o tres de tablas donde encontraremos un conjunto de funciones y objetos y alguna cosa mas.

lo malo que yo veo ( siempre recordado mi falta de experiencia) es que en un programa principal abría que colocar todas las tablas y alguna cosa mas, a demás de las llamadas.

en ambos métodos tenemos unas rutinas obligatorias 1) es la comunicación usart que es estándar (no se limita solo a la pantalla) 2) el conversor binario a bdc 16bits que también es estándar (teniendo el de 16 podemos eliminar el de 8 )

con mi método la única rutina obligatoria es la de identificar el numero de objeto y el tren de datos , (de momento) porque el resto de rutinas son independiente una de la otra si solo quiero usar una rutina , el resto de rutinas las puedo anular. las tablas estarían cargadas aunque solo use un dato de cada una.

como tu bien comentas si nos pasamos con los caracteres se nos van a salir letras por los pines del micro. en mi caso cada rutina tiene su constante ya ubicada, que no supera a mas de 10 caracteres y estas no dependen una de la otra. solo de las que son obligatorias para ambos métodos bin a bcd y configuración transmisor y recepción usart, como dije son estándar .

ademas cuando hablamos de mensajes. esta rutina es simplemente para mandar algún mensaje puntual. la pantalla nextion es auto gestionarle, de echo ay muchos programas por ay que no requieren de un procesador externo, para que la pantalla realice varios procesos, a demás de la función principal que es la parte táctil y la pantalla.

y otra cosa que veo yo, es que el otro método es mas difícil (no imponible ) de entender. el que uso yo, se limita a rutinas en bloques pequeños, que si se le dedica unos minutos se entiende rápido, para el que tienen poco manejo del assembler.
esta claro que para un producto final es mejor la tabla porque tu incluirás en ellas solo lo necesario y nada mas, pero para pruebas es mejor una estructura en bloques pequeños. como dije, que en nuestro programa principal podamos con uno o dos datos y una llamada resolver.

ya me diréis como ven este análisis y continuamos.

PD: esta rutina de binario a bcd que esta con descripción en ingles esta funcionando ?? te lo agradezco me va a venir bien para saber como funciona

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 18:13:43

buenas.

corrección en la ultima rutina (fuentes)

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 18 de Agosto de 2018, 20:18:56

buenas

os dejo aquí un programa con todas las rutinas en marcha, del objeto texto y un linck
donde podéis descargar el archivo EJEMPLO_1HMI para simular

cuando tenga un segundo pondré en este mismo linck un vídeo

https://drive.google.com/open?id=1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt

ya comentareis si es viable o no
saludos

PD: añadido una rutina mas para objeto txt Nex_Texto_Borrar.
PD: ya esta el vídeo con una pantalla real todo en el linck

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 19 de Agosto de 2018, 06:40:42

buenas.

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

OPT_TABLA:
ADDWF PCL, F
RETLW TXT_OPT_TXT - TXT_OPT_TXT
RETLW TXT_OPT_BCO - TXT_OPT_TXT
RETLW TXT_OPT_PCO - TXT_OPT_TXT
RETLW TXT_OPT_FNT - TXT_OPT_TXT

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 19 de Agosto de 2018, 11:17:05

Cita de: estebanfolcher en 19 de Agosto de 2018, 06:40:42

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

OBTENER_OPT:
    ADDWF PCL, F
TXT_OPT_TXT:    DT "txt",0x00    
TXT_OPT_BCO:    DT "bco",0x00
TXT_OPT_PCO:    DT "pco",0x00   
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

OBTENER_OPT:
    ADDWF PCL, F
TXT_OPT_TXT:    DT "text",0x00    
TXT_OPT_BCO:    DT "bco",0x00
TXT_OPT_PCO:    DT "pco",0x00   
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

OPT_TABLA:
    ADDWF PCL, F
    RETLW   TXT_OPT_TXT - TXT_OPT_TXT    
    RETLW   TXT_OPT_BCO - TXT_OPT_TXT
    RETLW   TXT_OPT_PCO - TXT_OPT_TXT
    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:

Citar

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

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 20 de Agosto de 2018, 09:44:17

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

CBLOCK
                        AUX_MENSAJE
                         
                        ENDC    
 
#DEFINE                 OBJETO_TEXTO    d'0'
#DEFINE                 FUNCION_TEXTO   d'1'
#DEFINE                 FUNCION_FIN     d'2'
#DEFINE                 FUNCION_BCO     d'3'
#DEFINE                 FUNCION_PCO     d'4'                    
;#DEFINE                        OBJETO_TEXTO_S  d'0'
;#DEFINE                        FUNCION_TXT     d'0'                    
;#DEFINE                        FUNCION_FONT    d'0'        
;#DEFINE                        FUNCION_XCEN    d'0'          
;#DEFINE                        FUNCION_YCEN    d'0'         
;#DEFINE                        FUNCION_PW      d'0'        
;#DEFINE                        FUNCION_ISBR    d'0'         
;#DEFINE                        FUNCION_BORRA   d'0'        
 
Inicia_Nextion          
                        CALL    Retardo_200ms
                        
                        MOVLW   FUNCION_FIN
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        RETURN
;
;-------------------------------------------------------------------------------
Nex_Texto_Borra         
                        
                        MOVLW   OBJETO_TEXTO
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        CALL    Envia_Numero_Objeto
                        MOVLW   '.'
                        CALL    Envia_USART
                        
                        MOVLW   FUNCION_TEXTO
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        MOVLW   '='
                        CALL    Envia_USART
                        MOVLW   '"'
                        CALL    Envia_USART
                        MOVLW   '"'
                        CALL    Envia_USART
                        
                        MOVLW   FUNCION_FIN
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        RETURN
;-------------------------------------------------------------------------------                        
Nex_Texto_Envia         MOVWF   AUX_MENSAJE
                        MOVLW   OBJETO_TEXTO
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        CALL    Envia_Numero_Objeto
                        MOVLW   '.'
                        CALL    Envia_USART
                        
                        MOVLW   FUNCION_TEXTO
                        PAGESEL Tabla_Offset
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        MOVLW   '='
                        CALL    Envia_USART
                        MOVLW   '"'
                        CALL    Envia_USART
                        MOVF    AUX_MENSAJE,W
                        CALL    Envia_Mensaje
                        MOVLW   '"'
                        CALL    Envia_USART
                        
                        MOVLW   FUNCION_FIN
                        PAGESEL Tabla_Offset
                        
                        CALL    Tabla_Offset
                        CALL    Lee_Y_Envia_Items
                        RETURN
                        
;-------------------------------------------------------------------------------
 
                    ;ORG        0x1900
                    ORG         0x1800  
Tabla_Offset        
                    ADDWF       PCL,F
                    RETLW       SUTRAE_O_TXT - SUTRAE_F_TXT
                    RETLW       SUTRAE_F_TXT - SUTRAE_F_TXT                     
                    RETLW       SUTRAE_F_FIN - SUTRAE_F_TXT
                    RETLW       SUTRAE_F_BCO - SUTRAE_F_TXT
                    RETLW       SUTRAE_F_PCO - SUTRAE_F_TXT
                        
                        
Tabla_Items         
                    ADDWF       PCL,F
                        
SUTRAE_F_TXT        DT  "txt",0x00
SUTRAE_F_BCO        DT  "bco",0x00
SUTRAE_F_PCO        DT  "pco",0x00    
SUTRAE_F_FONT       DT  "font",0x00
SUTRAE_F_XCEN       DT  "xcen",0x00   
SUTRAE_F_YCEN       DT  "ycen",0x00  
SUTRAE_F_PW         DT  "pw",0x00 
SUTRAE_F_ISBR       DT  "isbr",0x00 
SUTRAE_F_FIN        DT  "ÿÿÿ",0x00
SUTRAE_O_TXT        DT  "t",0x00
            
            
 
                    
                    
                    
                    
                    INCLUDE     LEE_Y_ENVIA.INC
                    INCLUDE     BIN_BCD_16.INC
                    INCLUDE     USART.INC
                    INCLUDE     CRIBA_X3.INC

saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 20 de Agosto de 2018, 09:49:59

perdon:

dejo el programa completo para simular.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 20 de Agosto de 2018, 11:53:58

Citar

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:

Citar

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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 20 de Agosto de 2018, 12:39:50

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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 23 de Agosto de 2018, 15:56:45

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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 23 de Agosto de 2018, 21:12:00

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

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 24 de Agosto de 2018, 12:13:09

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

Citar

que te parece así killer?

Un gasto de Flash.

Citar

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

;Aca cargo OffsetH y OffsetL
    CALL    Table
; LLamada a la tabla
 
Table:   
        MOVLW   HIGH(TStart)
    ADDWF       OffsetH, W
    MOVWF       PCLATH
    MOVLW       LOW(TStart)
    ADDWF       OffsetL, W
    BTFSC       STATUS, C
    INCF        PCLATH,F
    MOVWF   PCL
    ; fin de la subrutina de la tabla, no se necesita return ni nada, ya que al mover al PCL salta
 
 
    ; La tabla donde se te ocurra ponerla
    ORG 0x????
TStart:
        RETLW   d'0'
    RETLW       d'1'
    RETLW       d'2'
    ;....
    ;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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 24 de Agosto de 2018, 16:32:44

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??

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 24 de Agosto de 2018, 16:57:19

Cita de: estebanfolcher en 24 de Agosto de 2018, 16:32:44

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:

Citar

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 :P... 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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 24 de Agosto de 2018, 17:15:41

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

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 24 de Agosto de 2018, 19:57:33

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

PRINCIPAL:
    MOVLW NXT_TEXT_T               ;El objeto TEXT
    MOVWF NXT_TIPO
    MOVLW .12                             ; El numero de objeto
    MOVWF NXT_NUMBER             
    MOVLW NXT_PCO_OPT            ; La propiedad del objeto
    MOVWF NXT_OPTION
    CALL  NXT_ENVIAR_INICIO      ; Que envie todo lo que pedi antes
    CALL  NXT_ENVIAR_MENSAJE  ; Envio el mensaje o numero segun lo que corresponda
    CALL  NXT_ENVIAR_FINAL       ; Envio la parte final, el cual se podria incluir en el anterior CALL
    
    
    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

; Defines para el uso de la libreria
NXT_TEXT_T      EQU  0
NXT_TXTSC_T     EQU  1
 
NXT_TXT_OPT     EQU  0
NXT_BCO_OPT     EQU  1  
NXT_PCO_OPT     EQU  2
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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 24 de Agosto de 2018, 23:26:40

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.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 24 de Agosto de 2018, 23:40:13

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

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 25 de Agosto de 2018, 00:29:58

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

;************************************************************************************************************************
;                                                                                               
;
;Macro y rutina de temporización que se ajustan en función de la frecuencia de trabajo Fosc. En el programa principal 
;se debe definir:
;a)     La frecuencia de trabajo (en hz) mediante ... "#define Fosc xxxxxxxx"
;b)     Las variables de trabajo Temporal_1, Temporal_2 y Temporal_3 mediante ... "Temporal_x   equ     0xXX"
;
;El usuario llama a la macro desde su programa principal mediante ... "Delay xxxx Milis"
;
;Se obtiene una precisión razonable con valores de temporización desde 1 hasta 2000 mS y a frecuencias Fosc 
;que van desde 1MHz hasta 48MHz
 
#define         Milis                   * D'1000000'
       
Delay   macro   tiempo_ns       ;tiempo_ns expresa en ns el tiempo de temporización deseado
        
        ifndef Fosc                     ;En el programa principal se ha definir la frecuencia de trabajo en Hz                                                          
        messg "ERROR !! - Establecer la frecuencia de trabajo (p.e. #define     Fosc 4000000)"
        exitm
        endif
 
        radix dec                                                                                               ;Operaciones en base decimal
        variable ciclo_instruc_ns =  (( 1000000000 ) / (Fosc / 4 ))     ;Calcula ciclo de instrucción en función de la frecuencia Fosc
        variable ciclos = (tiempo_ns / ciclo_instruc_ns)                ;Calcula el nº de ciclos necesarios para la temporización deseada
  
                                movlw   upper (ciclos/4)+1
                                movwf   Temporal_1
                                movlw   high (ciclos/4)+1
                                movwf   Temporal_2
                                movlw   low (ciclos/4)
                                movwf   Temporal_3              ;Carga las variables de temporización con el nº de ciclos calculado
                                call    MSE_Delay
 
 endm
 
MSE_Delay               clrwdt                                  ;Bucles de temporización
                                decfsz  Temporal_3,f
                                goto    MSE_Delay
                                decfsz  Temporal_2,f
                                goto    MSE_Delay
                                decfsz  Temporal_1,f
                                goto    MSE_Delay
                                return

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 25 de Agosto de 2018, 08:28:37

Citar

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.

Si es mas entendible... Pero eso significa que en cada lugar donde pongas la macro se va a repetir por completo el mismo. suponete que el macro sea:

Código: ASM

MOVLW
 CALL
 MOVWF
 ADDWF
 BTFSS
  INCF
 RETURN

Y en tu codigo tenes:

Código: ASM

MOVLW
 CALL MACRO
 MOVLW
 CALL MACRO

El macro es un simple reemplazo y quedaria:

Código: ASM

MOVLW
 ;Primer macro
 MOVLW
 CALL
 MOVWF
 ADDWF
 BTFSS
  INCF
 RETURN
 MOVLW
 ;Segundo Macro
 MOVLW
 CALL
 MOVWF
 ADDWF
 BTFSS
  INCF
 RETURN

La otra que te queda... es hacer el macro y dejar las funciones que ya tenes.. De esa forma tu macro lo explico con un ejemplo (rapido por que no poseo demasido tiempo para probarlo):

Código: ASM

TuMacro macro objeto,numer,propiedad
    MOVLW objeto               ;El objeto TEXT
    MOVWF NXT_TIPO
    MOVLW numero                             ; El numero de objeto
    MOVWF NXT_NUMBER             
    MOVLW propiedad            ; La propiedad del objeto
    MOVWF NXT_OPTION
    CALL  NXT_ENVIAR_INICIO      ; Que envie todo lo que pedi antes
    CALL  NXT_ENVIAR_MENSAJE  ; Envio el mensaje o numero segun lo que corresponda
    CALL  NXT_ENVIAR_FINAL       ; Envio la parte final, el cual se podria incluir en el anterior CALL

Entonces tu main quedaria simple como queres.

Citar

si el método para acede a la tabla en los dos últimos ejemplos son buenos

Si usas el modulo EEPROM si, no vas a tener limitantes de tabla. Y es mas simple de operar.
La discusion es sobre que poner o como poner en las tablas los datos. Si me limito a tus 2 opciones:
- Si queres que sea especifico (solo los envios que voy a usar ) a tu aplicacion entonces prefiero la que tiene completo el dato.
- Si lo que queres es algo mas generico, o que debas enviar muchos y distintos, y que se adapte a cualquier cosa, entonces prefiero el metodo de multiplicar.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 25 de Agosto de 2018, 14:14:24

KILLER.

mi pregunta es puedo llamar a un macro estando en un macro. si uso el método de tablas multiplicando objeto / función por el numero de columnas . queria meter un macro de multiplicación.

si esto es posible, el macro de multiplicación ¿también se multiplicaría por las veces que lo llamo dentro del pic?,¿ o mejor mantengo una rutina de multiplicación ?. colocar mínimo 3 tablas
tabla objeto, tabla función, tabla símbolos (tabla símbolo la coloco porque el punto, el igual y las comillas se repiten mucho)

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 26 de Agosto de 2018, 09:53:04

Nunca use macros anidadas, por lo que lei se puede realizar.

Citar

¿también se multiplicaría por las veces que lo llamo dentro del pic?

El/La MACRO su funcion es facilitar la lectura. Ya que vos creas una macro y se va a entender un poco mas, para no estar repitiendo como loco lo mismo siempre.
Pero en si, luego de que pasa el compilador hace un reemplazo, colocando TODO lo de la macro donde vos lo pusiste. Es decir lo va a repetir.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 26 de Agosto de 2018, 18:23:37

KIILLER.

dime como ves la administración de las tablas. el código funciona en el programa principal puse 4 cosas para la prueba de las tablas.

Código: ASM

list            p=16f877A,f=inhx32
        #include        <p16f877A.inc>   
        __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_ON & _BOREN_ON & _LVP_ON & _CPD_OFF & _WRT_OFF & _CP_OFF
         
STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
                    GOTO        COMIENZO
                    ORG         0x05
                    
    ;INCLUDE    <MACROS_NEX.inc>
 
            
COMIENZO        CALL    Configura_USART  
;               A PARTIR DE AQUI TODO ESTO IRIA EN UN MACRO    
PRINCIPAL       MOVLW   O_Text
                CALL    Objeto
                MOVLW   S_punto
                CALL    Simbolo
                MOVLW   F_txt
                CALL    Funcion
                MOVLW   S_igual
                CALL    Simbolo
                MOVLW   S_comillas
                CALL    Simbolo
                MOVLW   S_comillas
                CALL    Simbolo
                MOVLW   F_fin
                CALL    Funcion
                
                
                GOTO    PRINCIPAL
                    
                ;INCLUDE        RETARDOS.INC
                INCLUDE NEXTION_SUB_5.INC
                END

Código: ASM

PUERTO_TX           EQU         6       ;PIN DE TRANSMICION
PUERTO_RC           EQU         7       ;PINDE RECEPCION                        
O_Text              EQU d'1'
O_Scrolling_Text    EQU d'2'
O_123_Number        EQU d'3'
O_Button            EQU d'4'    
O_Progress_Bar      EQU d'5'    
O_Picture           EQU d'6'    
O_Crop              EQU d'7'
O_Hotspot           EQU d'8'
O_Gauge             EQU d'9'
O_waveform          EQU d'10'
O_Sider             EQU d'11'
O_Timer             EQU d'12' 
O_Variavle          EQU d'13'
O_Dual_State_Button EQU d'14'
O_Checkbox          EQU d'15'
O_Radio             EQU d'16'
O_QRcode            EQU d'17'
F_en                EQU d'1'
F_pw                EQU d'2'
F_fin               EQU d'3'
F_bco               EQU d'4'
F_pco               EQU d'5'
F_txt               EQU d'6'
F_dir               EQU d'7'
F_tim               EQU d'8'
F_dis               EQU d'9'
F_val               EQU d'10'
F_pic               EQU d'11' 
F_hig               EQU d'12'  
F_wid               EQU d'13'
F_gdc               EQU d'14'   
F_gdw               EQU d'15'
F_gdh               EQU d'16'
F_pco0              EQU d'17'
F_isbr              EQU d'18'
F_bco0              EQU d'19'
F_bco1              EQU d'20'
F_font              EQU d'21'
F_xcen              EQU d'22'
F_ycen              EQU d'23'
F_bco2              EQU d'24'
F_pco2              EQU d'25'
F_picc              EQU d'26'
F_maxval            EQU d'27'
F_minval            EQU d'28'
S_igual             EQU d'1'
S_punto             EQU d'2'
S_comillas          EQU d'3'
                        CBLOCK 0x20
;                       ------------------Multiplica                    
                        MULTI_DATO_1
                        MULTI_DATO_2
                        MULTI_8x8_BITS_L
                        MULTI_8x8_BITS_H
                        MULTI_T_1
                        MULTI_T_2
                        MULTI_T_5
                        MULTI_T_6
                        MULTI_T_9
                        MULTI_T_10
                        MULTI_T_11
                        MULTI_T_12
                        MULTI_T_13
;                       --------------- Objeto, Funcion, Simbolo                        
                        ORIGEN_DATO_H
                        ORIGEN_DATO_L
;                       --------------- Administra_envia                        
                        DATO_O_F_S
                        TEMP_DATO_H
                        TEMP_DATO_L
                        DATO_TABLA
                        ENDC
 
 
;-------------------------------------------------------------------------------
 
;                  CONFIGURA COMUNICACION U USART                       
Configura_USART         BSF     STATUS,RP0                              
                        BCF     TRISC,PUERTO_TX ;PONE A (0) ESTE PIN COMO SALIDA 
                        BSF     TRISC,PUERTO_RC ;PONE A (1) ESTE PIN COMO ENTRADA
                        MOVLW   0x24            ;TX HABILITADA, MODO ASINCRON0
                        MOVWF   TXSTA           ;CON 8 BITS Y ALTA VELOCIDAD
                        MOVLW   0x19            ;SET BAUDIOS A 9600  0x19 
                        MOVWF   SPBRG           ;CON Fosc = 4MHz
                        BCF     STATUS,RP0      ;ENTRO EN BANCO 0
                        MOVLW   0x90            ;AJUSTA RECEPTOR A 8 BITS, RECEPCION
                        MOVWF   RCSTA           ;CONTINUA HABILITADA USART EN ON
                        RETURN                  ;RETORNA
Envia_USART             BSF     STATUS,RP0
                        BCF     STATUS,RP1
                        BTFSS   TXSTA,TRMT
                        GOTO    Envia_USART
                        BCF     STATUS,RP0
                        MOVWF   TXREG
                        BCF     STATUS,RP0
                        BCF     STATUS,RP1
                        RETURN
Recibe_USART            BCF     STATUS,RP0
                        BTFSS   PIR1,RCIF
                        GOTO    Recibe_USART
                        MOVF    RCREG,W
DATO                    BCF     PIR1,RCIF
                        BSF     STATUS,RP0
                        RETURN
;-------------------------------------------------------------------------------                        
                        
Multiplicacion_1    MOVWF  MULTI_DATO_1
                    RETURN
Multiplicacion_2    MOVWF  MULTI_DATO_2     
                    movf MULTI_DATO_1,W; 
                    btfsc STATUS,Z          ; SI EL CONTENIDO DE COLUMNA ES 0 ATIVA FAG Z A 1 
                    goto Multiplica_da_0    ; PREGUNTA SI FLAG Z ES 0, SI SALTA NO CONTINUA 
paso5_d             movf MULTI_DATO_2,W
                    btfsc STATUS,Z
                    goto Multiplica_da_0
paso5_c             movf MULTI_DATO_1,W
                    movwf MULTI_T_1
                    clrf MULTI_T_2
                    movf MULTI_DATO_2,W
                    movwf MULTI_T_5
                    clrf MULTI_T_6
                    clrf MULTI_8x8_BITS_L
                    clrf MULTI_8x8_BITS_H
                    clrf MULTI_T_10
                    clrf MULTI_T_11
                    clrf MULTI_T_12
                    clrf MULTI_T_13
                    movlw .8
                    movwf MULTI_T_9
paso5_a             btfss MULTI_T_5,0
                    goto paso5_b
                    movf MULTI_T_1,W
                    addwf MULTI_T_10,1
                    bcf STATUS,Z
                    btfsc STATUS,C
                    incf MULTI_T_11,1
                    movf MULTI_T_2,W
                    addwf MULTI_T_11,1
paso5_b             bcf STATUS,C
                    rlf MULTI_T_1,1
                    rlf MULTI_T_2,1
                    bcf STATUS,C
                    btfsc MULTI_T_5,0
                    bsf STATUS,C
                    rrf MULTI_T_6,1
                    rrf MULTI_T_5,1
                    decfsz MULTI_T_9,1
                    goto paso5_a
                    movf MULTI_T_10,W
                    movwf MULTI_8x8_BITS_L
                    movf MULTI_T_11,W
                    movwf MULTI_8x8_BITS_H
                    goto paso5_s
Multiplica_da_0     clrf MULTI_8x8_BITS_L
                    clrf MULTI_8x8_BITS_H
paso5_s             return
;-------------------------------------------------------------------------------                    
Funcion             MOVWF   DATO_O_F_S
                    MOVLW   HIGH    Tabla_Funcion
                    MOVWF   ORIGEN_DATO_H
                    MOVLW   LOW     Tabla_Funcion
                    MOVWF   ORIGEN_DATO_L
                    CLRF    TEMP_DATO_H
                    CLRF    TEMP_DATO_L
                    CALL    Administra_Tablas
                    CLRF    PCLATH
                    CALL    Administra_envia
                    RETURN
;-------------------------------------------------------------------------------                    
Simbolo             MOVWF   DATO_O_F_S
                    MOVLW   HIGH    Tabla_Operadores
                    MOVWF   ORIGEN_DATO_H
                    MOVLW   LOW     Tabla_Operadores
                    MOVWF   ORIGEN_DATO_L
                    CLRF    TEMP_DATO_H
                    CLRF    TEMP_DATO_L
                    CALL    Administra_Tablas
                    CLRF    PCLATH
                    CALL    Administra_envia
                    RETURN
;-------------------------------------------------------------------------------
Objeto              MOVWF   DATO_O_F_S
                    MOVLW   HIGH    Tabla_Objeto
                    MOVWF   ORIGEN_DATO_H
                    MOVLW   LOW     Tabla_Objeto
                    MOVWF   ORIGEN_DATO_L
                    CLRF    TEMP_DATO_H
                    CLRF    TEMP_DATO_L
                    CALL    Administra_Tablas
                    CLRF    PCLATH
                    CALL    Administra_envia
                    RETURN
;-------------------------------------------------------------------------------                    
Administra_envia    CALL    Multiplicacion_1
                    MOVF    DATO_O_F_S,W
                    CALL    Multiplicacion_2
                    MOVF    MULTI_8x8_BITS_H,W  
                    MOVWF   TEMP_DATO_H
                    MOVF    MULTI_8x8_BITS_L,W  
                    MOVWF   TEMP_DATO_L
Sigue_o_Fin         CALL    Administra_Tablas
                    CLRF    PCLATH
                    MOVWF   DATO_TABLA
                    MOVF    DATO_TABLA,W            ;SI EL CONTENIDO DE 
                    BTFSC   STATUS,Z                ;DATO_TABLA ES CERO (NO ASCII)
                    GOTO    Fin_Administra_Envia    ;CONTINUA POR GOTO FIN
                    CALL    Envia_USART             ;ASI FINALIZO EL ENVIO
                    INCF    TEMP_DATO_L
                    GOTO    Sigue_o_Fin
Fin_Administra_Envia
                    RETURN
Administra_Tablas      
                    MOVF    ORIGEN_DATO_H,W
                    ADDWF   TEMP_DATO_H,W   
                    MOVWF   PCLATH
                    MOVF    ORIGEN_DATO_L,W
                    ADDWF   TEMP_DATO_L,W
                    BTFSC   STATUS, C
                    INCF    PCLATH,F
                    MOVWF   PCL
;-------------------------------------------------------------------------------
                    ORG 0X1900  
Tabla_Objeto        DT  .3,.0,.0                ;NUMERO DE COLUBMAS (MULTIPLICADOR)
                    DT  't',.0,.0               ;OBJETO TEXTO
                    DT  'g',.0,.0
                    DT  'n',.0,.0
                    DT  'b',.0,.0
                    DT  'j',.0,.0
                    DT  'p',.0,.0
                    DT  'q',.0,.0
                    DT  'm',.0,.0
                    DT  'z',.0,.0
                    DT  's',.0,.0
                    DT  'h',.0,.0
                    DT  't','m',.0
                    DT  'v','a',.0
                    DT  'b','t',.0
                    DT  'c',.0,.0
                    DT  'r',.0,.0
                    DT  'q','r',.0
 
Tabla_Funcion       DT  .7,.0,.0,.0,.0,.0,.0    ;NUMERO DE COLUBMAS (MULTIPLICADOR)
                    DT  'e','n',.0,.0,.0,.0,.0
                    DT  'p','w',.0,.0,.0,.0,.0
                    DT  'ÿ','ÿ','ÿ',.0,.0,.0,.0
                    DT  'b','c','o',.0,.0,.0,.0
                    DT  'p','c','o',.0,.0,.0,.0
                    DT  't','x','t',.0,.0,.0,.0
                    DT  'd','i','r',.0,.0,.0,.0
                    DT  't','i','m',.0,.0,.0,.0
                    DT  'd','i','s',.0,.0,.0,.0
                    DT  'v','a','l',.0,.0,.0,.0
                    DT  'p','i','c',.0,.0,.0,.0
                    DT  'h','i','g',.0,.0,.0,.0
                    DT  'w','i','d',.0,.0,.0,.0
                    DT  'g','d','c',.0,.0,.0,.0
                    DT  'g','d','w',.0,.0,.0,.0
                    DT  'g','d','h',.0,.0,.0,.0
                    DT  'p','c','o','0',.0,.0,.0
                    DT  'i','s','b','r',.0,.0,.0
                    DT  'b','c','o','0',.0,.0,.0
                    DT  'b','c','o','1',.0,.0,.0
                    DT  'f','o','n','t',.0,.0,.0
                    DT  'x','c','e','n',.0,.0,.0
                    DT  'y','c','e','n',.0,.0,.0
                    DT  'b','c','o','2',.0,.0,.0
                    DT  'p','c','o','2',.0,.0,.0
                    DT  'p','i','c','c',.0,.0,.0
                    DT  'm','a','x','v','a','l',.0
                    DT  'm','i','n','v','o','l',.0
                    
Tabla_Operadores    DT  .2,.0                   ;NUMERO DE COLUBMAS (MULTIPLICADOR)
                    DT  '=',.0
                    DT  '.',.0
                    DT  '"',.0

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 26 de Agosto de 2018, 18:41:52

Esta bien, lo que si tengo una duda y una idea para vos...

La duda es... si usas el PCLATH, tenes que tener cuidado luego de volver, de poner los bits que corresponden, sino un al ejecutar un GOTO va a tomar los bits mas importantes del PCLATH. No creo que se restablezca por si solo. Es una duda, y deberias tenerlo en cuenta. Lo que podes hacer es tomar el valor del PCLATH, guardarlo, y luego restablecerlo al terminar de llamar a la tabla.

La idea es generar un macro para "resumir" esto:

Código: ASM

PRINCIPAL       MOVLW   O_Text
                CALL    Objeto
                MOVLW   S_punto
                CALL    Simbolo
                MOVLW   F_txt
                CALL    Funcion
                MOVLW   S_igual
                CALL    Simbolo
                MOVLW   S_comillas
                CALL    Simbolo
                MOVLW   S_comillas
                CALL    Simbolo
                MOVLW   F_fin
                CALL    Funcion

Y el macro que sea:

Código: ASM

Enviar_a_pantalla O_Text, F_txt

PD:

Si no queres escribir tantos EQU como tenes, podes usar CBLOCK 1, ejemplor:

Código: ASM

S_igual             EQU d'1'
S_punto             EQU d'2'
S_comillas          EQU d'3'

por

Código: ASM

CBLOCK 1
S_igual
S_punto
S_comillas
ENDC

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 26 de Agosto de 2018, 18:47:11

gracias desconocía lo del cblock 1.

si lo del pclath como podes ver inmediatamente de retornar de la tabla lo pongo a cero.
CALL Administra_Tablas
CLRF PCLATH

pd; ¿cblock 1 finaliza igual con endc?

Pd falta acabar como veras aun queda por agregar el numero de objeto y las variables de texto o numéricas del usuario

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 26 de Agosto de 2018, 18:53:22

El CBLOCK casi siempre uno lo usa para designar los registros..

Pero en realidad lo unico que es el CBLOCK, es un "bloque de constantes", para no tener que escribir uno por uno con EQU, uno le da el comienzo luego del CBLOCK.. y hace que el texto tenga un valor. El cual va a ser reemplazado ANTES de compilarse. Es como un paso de precompilacion. Cada texto va a incrementarse en 1 respecto al anterior.

Observaras que yo puedo definir varias constantes con el mismo numero, no importa si luego esa constantes las uso como direcciones a los registros.
La verdadera forma de definir variables es una en la cual el mismo linker define donde se van a ubicar. Pero creo que solo Microchip hace archivos de ASM con eso. Casi todos los tutoriales y gente que usa ASM, hace uso del CBLOCK o EQU.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 26 de Agosto de 2018, 19:12:36

el macro así me funciona .

Código: ASM

list            p=16f877A,f=inhx32
        #include        <p16f877A.inc>   
        __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_ON & _BOREN_ON & _LVP_ON & _CPD_OFF & _WRT_OFF & _CP_OFF
         
STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
                    GOTO        COMIENZO
                    ORG         0x05
                    
    INCLUDE     <MACROS_NEX.inc>
 
            
COMIENZO        CALL    Configura_USART  
;                   
PRINCIPAL       
                Nex_Envia_texto
                
                
                
                GOTO    PRINCIPAL
                    
                ;INCLUDE        RETARDOS.INC
                INCLUDE NEXTION_SUB_5.INC
                END

Código: ASM

Nex_Envia_texto                 MACRO           
                        MOVLW   O_Text
                        CALL    Objeto
                        MOVLW   S_punto
                        CALL    Simbolo
                        MOVLW   F_txt
                        CALL    Funcion
                        MOVLW   S_igual
                        CALL    Simbolo
                        MOVLW   S_comillas
                        CALL    Simbolo
                        MOVLW   S_comillas
                        CALL    Simbolo
                        MOVLW   F_fin
                        CALL    Funcion
                        ENDM

PD yo dejo el macro armado ya solo pondré las variables que se modifica numero objeto y mensaje o numero de objeto y variable numérica bcd--> ascii.
luego el usuario cuando vea la dinámica el ara sus propios macros o subrutinas.
que te párese??

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 26 de Agosto de 2018, 21:29:48

El tema es que es tu libreria, vos vas a decidir que hacer y que no, que alguien luego use una libreria en ASM es mucho mas complicado que se llegue a lograr en C u otro lenguaje, porque es MUY especifico al micro que usas. Que posea todos los perifericos, que posea la memoria necesaria, etc. Por eso ASM es casi para uno mismo, o tal ves algun grupo de trabajo cerrado

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 27 de Agosto de 2018, 07:07:52

buenas

el tema de dejar definida los macros baciscos para el manejo es porque esa es la combinación no ay mas, si quiero mandar un texto por rs232 a nextion a de se así:

txxx.txt="AQUÍ MENSAJE"ÿÿÿ (donde las 3 x son el numero de objeto y AQUÍ MENSAJE el mensaje del usuario). no se puede hacer mas esta es la combinación.

si yo lo dejo preparado en un macro, el usuario solo se limitara a poner el numero de objeto y el mensaje que quiere. así no tendrá error.
si el usuario adquiere experiencia con la pantalla y ve que ay otro tipo de combinaciones a demás de las básicas presentadas aquí puede añadir mas objetos, funciones y símbolos a las tablas
y hacer su combinación en un macro nuevo o subrutina. solo tendrá que tener en cuenta que al añadir cosas a las tablas no supere la cantidad de caracteres mas cero, que indica en la tabla.
si es así lo único que ay que hacer es modificar el multiplicador de la tabla.

con respecto al micro usado. esta claro no todos los micros se pueden usar es recomendable mínimo que tenga puerto USART pero te diré que asta el 16f88 lo tiene y tiene 4 bancos y es de los baratos. solo tendrá que saetear binen los pines TX Y RC

en el caso de usar pic con comunicación USART por sofword tendrá que hacer unas modificaciones, pero solo a lo que refiere en comunicación porque lo demás sigue siendo lo mismo

pd dejo un ejemplo de dos macros para que veas como queda. yo lo veo muy limpio sobre todo en el programa principal. la ventaja del macro es que si no usas los macros estos no se cargan en el micro.
ya comentaras como lo ves y mi análisis. saludos y gracias de nuevo

pd:ya iré subiendo el resto de macros ( para algunos objetos aun tengo que saber su funcionamiento)

pd: para el que no tiene pantalla os dejo el linck donde podéis descargar el sofword de nextion y el EJEMPLO_1.HMI par las pruebas con el objeto texto
a medida que suba mas rutinas con otros objetos pondré los ejemplos aquí https://drive.google.com/open?id=1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 27 de Agosto de 2018, 08:15:33

buenas.

;SINTAXIS: NUMERO DE OBJETO, VARIABLE DECIMAL (0=OFF,1=ON)
   ; este macro no sé cuál sería el nombre más apropiado.
   ; su función es, cuando el mensaje es más largo que el ancho del
   ; recuadro, si está a cero el mensaje sigue viéndose en una línea
   ; si está a uno el mensa se escribe hasta el límite derecho y continua
   ; en la línea de abajo
   ; se acepta sugerencias

      Nex_Linea_Texto      d'3',d'1'

pd: aquí dejo todos los macros para el objeto texto. se puede hacer pruebas con el EJEMPLO_1.HMI

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 27 de Agosto de 2018, 15:12:24

buenas.

añado objeto scrollin text

PD; para las pruebas añadí un delay. https://drive.google.com/open?id=1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt EJEMPLO_2.HMI

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 01 de Septiembre de 2018, 14:24:28

buenas.

se añaden modificaciones.

se cambia el convertido bcd 16 bits por uno de 32 bits. ( esto es debido a que el objeto numérico ocupa 32 bits de dato y sera mas fácil para el usuario poder ingresar la constante o variable)

se añaden 3 macros a objeto texto y 3 mas a objeto scrolling texto.

PD: no las e probado todos los macros solo aquellos en los que influye mas el convertidor. si detectáis algún caso en el que un macro no funcione avisen.
pronto añadiré el objeto numérico
sludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 01 de Septiembre de 2018, 16:05:40

buenas.

aquí os dejo un macro con el objeto numerico.

me anticipo antes de tener todo el objeto completo porque quería consultar si se entiende la forma de ingresar un numero tan alto porque desconozco otro método

se que pata 16bit tenemos HIGH y LOW pero para 32 no conozco el método si lo ay

NOTA: según nextion para para darle un valor a este objeto, indica Initial value(-2147483648 to 2147483647)
para evitar confusiones, en el macro tenemos que indicar el signo.

PD: para probar este ejemplo esta ya compartido en el google drive el archivo EJEMPLO_3.HMI

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: KILLERJC en 01 de Septiembre de 2018, 16:30:20

Citar

se que pata 16bit tenemos HIGH y LOW pero para 32 no conozco el método si lo ay

Solo conozco hasta 24 ( UPPER, HIGH, LOW ) que es todo lo que necesitas, sino lo tratas como si fueran 4 bytes, o 2 de 16 bits.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 01 de Septiembre de 2018, 17:02:03

BUENAS.

killer. si de momento lo trataremos con 4 byts.

añado macro pero para variables con un mini programa que cuenta de 0 asta 65535.

NOTA: para este programa cambiamos el cristal de 4Mhaz por uno de 20Mhz y la velocidad del usart a 115200 baudios.
nosotros somo cambiamos el cristal, el programa ya esta modificado.
este cambio solo es para que cuente mas rápido

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 01 de Septiembre de 2018, 19:19:22

BUENAS.

añadido 4 macros a objeto numérico. suma y resta

PD: paso de nuevo a cristal 4Mhz

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 01 de Septiembre de 2018, 19:53:53

BUENAS.

añado dos macros de multiplicación. al contenido le multiplico dos asta que da cero

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 02 de Septiembre de 2018, 07:35:13

buenas.

añado dos macros para el objeto numérico. estos dividen el contenido del objeto numérico por la cantidad indicada.

NOTA: aqui hago un alto. dado que ya e puesto las 4 operaciones básicas el resto las dejo para el usuario. en la pagina de nextion se puede estudiar mas que otro tipo de operaciones se pueden aplicar. vasta con añadir mas símbolos o funciones a las tablas.( sera una oportunidad del usuario de probar el funcionamiento de la nextion).

continuo ahora con los atributos para dar por finalizado este objeto

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 02 de Septiembre de 2018, 11:05:42

BUENAS.

añado el resto de funciones a el objeto numérico.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 02 de Septiembre de 2018, 20:53:36

buenas.

añadido el reset para el inicio de pantalla. me párese adecuado que lo tengan ya para que no salgan errores

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 02 de Septiembre de 2018, 22:08:03

buenas.

añado objeto botón al completo.

PD: en el linck se puede encontrar el archivo EJEMPLO_4.HMI para probar
https://drive.google.com/open?id=1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 03 de Septiembre de 2018, 08:02:27

buenas

añado objeto barra progreso completo.

NOTA: como ya os daréis cuenta en las pruebas no e preparado imágenes para probar, intento emplear todo el tiempo en ir subiendo los macros tan rápido como pueda y el preparar imágenes para los ejemplos lleva mas tiempo. siempre estáis invitados a probar ustedes mismo. cuando termine ya le dedicare algo de tiempo y pondré ejemplos.

NOTA: recomiendo ir actualizando la subrutina a medida que subo un objeto nuevo ya que a medida que escribo los macros, encuentro funciones nuevas que voy añadiendo a las tablas.

pd: en el linck se puede encontrar el archivo EJEMPLO_5.HMI
https://drive.google.com/open?id=1mt9vtgACS-u02btLq0ngW_EgJd8fFvlt

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 03 de Septiembre de 2018, 09:17:26

BUENAS.

añado objeto picture. aquí si que le dedique unos minutos a hacer unas imágenes para mostrar un ejemplo ya que este objeto solo tiene una función.

recomiendo que lo probéis para ver en parte algo con imagen

PD: esto se puede probar con el archivo EJEMPLO_6.HMI lo pueden encontrar en el linck puesto anteriormente

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 03 de Septiembre de 2018, 17:29:18

BUENAS.

añado el objeto crop completo

PD: se puede probar con el EJEMPLO_7.HMI que se puede encontrar en el linck anterior

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 03 de Septiembre de 2018, 17:38:41

buenas.

NOTA: para el objeto hotspot no ay funciones que puedan ser enviadas por serial. aun así la mantengo añadida en las tablas para ver si en algún momento es posible combinarla con algún otro objeto.
este es un objeto que crea una zona activa en el touch. cosa que veremos mas adelante

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 04 de Septiembre de 2018, 11:12:36

buenas.

añado objeto gauge completo. en el ejemplo se puede observar como actúa la función crop image.

NOTA: un aspecto a tener en cuenta es que el cero (0) de la aguja siempre apunta a las 9:00 en punto el usuario debe crear una rutina para cuadrar su dato con la posición de la aguja.

PD: esto se puede probar en el EJEMPLO_8.HMI ubicado en el linck mencionado antes

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 05 de Septiembre de 2018, 09:30:57

BUENAS.

añado el objeto waveform al completo. con un programa que muestra 4 señales, cuadrada, cierra, triangular y plana

NOTA; montamos un cristal de 20Mhz el programa ya tiene modificado el usart a 115200 baudios. esto es para que la señal corra mas rápido, pero a 4Mhz 9600 baudios funciona sin problemas

PD: quise añadir una señal Sinusoide pero me llevaría mas tiempo y creo que las ya añadidas muestran el ejemplo perfectamente. si alguno quiere intentarlo que lo añada y lo suba

PD; recuerden que ay que ir actualizando los archivos macro y subrutena

PD; esto se puede probar en el EJEMPLO_9.HMI que se encuentra en el linck antes compartido

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 05 de Septiembre de 2018, 09:37:46

buenas.

una imagen
- Tienes que ingresar para ver archivos adjuntos -

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 05 de Septiembre de 2018, 17:14:20

buenas.

añado objeto slider completo.

se puede probar con el EJEMPLO_10.HMI

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 06 de Septiembre de 2018, 13:44:24

buenas.

añado objeto timer y objeto variable completo. estos son dos objetos que se utilizan en programas que vallamos a crear directamente en el editor de nextion, pero que se puede manipular su contenido o valor desde el serial

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 06 de Septiembre de 2018, 18:29:39

buenas

añado objeto doble botón completo.

NOTA: este sera el ultimo objeto al que me dedicare. quedan tres objetos mas (CIRCULO, CUADRADO y CÓDIGO QR) esto lo dejo a ustedes, ya se ve como mas o menos funciona

PD para probar el doble botón se puede utilizar el EJEMPLO_11.HMI

es posible que añada un par de macros mas como el cambio de pagina y ocultar y mostrar objetos, a partir de aquí dedicare un tiempo a crear una rutina para leer la pantalla pero quiero antes ver si puedo mejorar el tiempo de conversión bcd y la multiplicación

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 06 de Septiembre de 2018, 19:29:47

BUENS.

Estoy estudiando el modo de optimizar el uso del convertidor BCD. ya que usamos solo uno de 32 bit para todos los macros, cuando en algunas ocasiones solo es preciso convertir 8 o 16 bit
e modificado el que tengo en uso en este momento para hacerlo multiuso un convertidor bdc de 8,16,24,32 todo en uno.
dejo el programa para valorar si la idea es buena.
en el de 32 bits roto 32 veces el numero para revisar cada bit pero en este fijo el contador de bits antes de empezar a convertir, con la cantidad de bits/rotaciones a convertir.

Código: ASM

CBLOCK
                    DATO_HHH
                    DATO_HH
                    DATO_H
                    DATO_L
                    CONT_BITS
                    DIGI_0_1
                    DIGI_2_3
                    DIGI_4_5
                    DIGI_6_7
                    DIGI_8_9
                    TEMP_BIN_BCD
                    BIN_BCD_UNI
                    BIN_BCD_DEC
                    BIN_BCD_CEN
                    BIN_BCD_UNI_MIL
                    BIN_BCD_DEC_MIL
                    BIN_BCD_CEN_MIL
                    BIN_BCD_UNI_MILLON
                    BIN_BCD_DEC_MILLON
                    BIN_BCD_CEN_MILLON
                    BIN_BCD_UNI_BILLON
                    ENDC
                    
BIN_a_BCD_32_HHH    MOVWF   DATO_HHH        ;SINTAXIS
                    RETURN                  ;MOVLW  X
BIN_a_BCD_32_HH     MOVWF   DATO_HH         ;CALL   BIN_a_BCD_32_HHH
                    RETURN                  ;MOVLW  X
BIN_a_BCD_32_H      MOVWF   DATO_H          ;CALL   BIN_a_BCD_32_HH                 
                    RETURN                  ;MOVLW  X
BIN_a_BCD_32_L      MOVWF   DATO_L          ;CALL   BIN_a_BCD_32_H
                    MOVLW   d'32'           ;MOVLW  X
                    MOVWF   CONT_BITS       ;CALL   BIN_a_BCD_32_L
                    GOTO    BIN_a_BCD
;-------------------------------------------------------------------------------                    
BIN_a_BCD_24_HH     MOVWF   DATO_HH         ;SINTAXIS
                    RETURN                  ;MOVLW  X
BIN_a_BCD_24_H      MOVWF   DATO_H          ;CALL   BIN_a_BCD_24_HH         
                    RETURN                  ;MOVLW  X
BIN_a_BCD_24_L      MOVWF   DATO_L          ;CALL   BIN_a_BCD_24_H
                    MOVLW   d'24'           ;MOVLW  X
                    MOVWF   CONT_BITS       ;CALL   BIN_a_BCD_24_L
                    GOTO    BIN_a_BCD               
;-------------------------------------------------------------------------------                    
BIN_a_BCD_16_H      MOVWF   DATO_H          
                    RETURN                  ;SINTAXIS
BIN_a_BCD_16_L      MOVWF   DATO_L          ;MOVLW  X
                    MOVLW   d'16'           ;CALL   BIN_a_BCD_16_H
                    MOVWF   CONT_BITS       ;MOVLW  X
                    GOTO    BIN_a_BCD       ;CALL   BIN_a_BCD_16_L
;-------------------------------------------------------------------------------                    
BIN_a_BCD_8         MOVWF   DATO_L          ;SINTAXIS
                    MOVLW   d'8'            ;MOVLW  X
                    MOVWF   CONT_BITS       ;CALL   BIN_a_BCD_8
;-------------------------------------------------------------------------------                    
BIN_a_BCD           BSF     STATUS,C
                    ;MOVLW   d'32'              
                    ;MOVWF   CONT_BITS          
                    CLRF    DIGI_0_1
                    CLRF    DIGI_2_3
                    CLRF    DIGI_4_5
                    CLRF    DIGI_6_7
                    CLRF    DIGI_8_9
Rota_Datos          RLF     DATO_L,F        ;ROTAMOS A LA IZQUIERDA TODO EL CONTENIDO 
                    RLF     DATO_H,F        ;DE DATO, EN CADA ACARREO DEL BIT "C" SE DESPLAZA
                    RLF     DATO_HH,F       ;AL SIGIENTE REGISTRO
                    RLF     DATO_HHH,F
                    RLF     DIGI_0_1,F
                    RLF     DIGI_2_3,F
                    RLF     DIGI_4_5,F
                    RLF     DIGI_6_7,F
                    RLF     DIGI_8_9,F
                    DECFSZ  CONT_BITS,F     ;DECREMENTAMOS EL CONTARO DE BITS ASTA QUE DE 
                    GOTO    Apuntador       ;CERO. SI ES ASI TERMINAMOS LA CONVERCION
                    GOTO    Organiza_BCD
Apuntador           MOVLW   DIGI_0_1        ;PONGO EN EL PUNTERO FSR EL REGISTRO  
                    MOVWF   FSR             ;LO QUE OPERE SOBRE INDF SERA SOBRE LA DIRECCION
                    CALL    Pregunta_Suma   ;APUNTADA EN FSR. EN ESTE CASO DIRECCION DONDE 
                    MOVLW   DIGI_2_3        ;ESTA EL CONTENIDO DE DATO_X_X
                    MOVWF   FSR
                    CALL    Pregunta_Suma 
                    MOVLW   DIGI_4_5
                    MOVWF   FSR
                    CALL    Pregunta_Suma 
                    MOVLW   DIGI_6_7
                    MOVWF   FSR
                    CALL    Pregunta_Suma
                    MOVLW   DIGI_8_9
                    MOVWF   FSR
                    CALL    Pregunta_Suma 
                    GOTO    Rota_Datos
Pregunta_Suma       MOVF    INDF,W
                    MOVLW   d'3'
                    ADDWF   INDF, w
                    MOVWF   TEMP_BIN_BCD
                    BTFSC   TEMP_BIN_BCD, 3
                    MOVWF   INDF
                    MOVLW   d'48'
                    ADDWF   INDF, w
                    MOVWF   TEMP_BIN_BCD
                    BTFSC   TEMP_BIN_BCD, 7
                    MOVWF   INDF
                    RETURN
Organiza_BCD        MOVF    DIGI_0_1,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_UNI
                    SWAPF   DIGI_0_1,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_DEC
                    MOVF    DIGI_2_3,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_CEN
                    SWAPF   DIGI_2_3,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_UNI_MIL
                    MOVF    DIGI_4_5,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_DEC_MIL
                    SWAPF   DIGI_4_5,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_CEN_MIL
                    MOVF    DIGI_6_7,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_UNI_MILLON
                    SWAPF   DIGI_6_7,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_DEC_MILLON
                    MOVF    DIGI_8_9,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_CEN_MILLON
                    SWAPF   DIGI_8_9,W
                    ANDLW   d'15'
                    MOVWF   BIN_BCD_UNI_BILLON
                    RETURN

espero sus comentarios. saludos

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 07 de Septiembre de 2018, 11:26:57

BUENAS.

bueno aquí dejo la mejora del bcd implementada. hice una par de pruebas y parece que funciona. pero no esta de mas echar un vistoso

para que se entienda mas o menos, este conversor rota los 4 byts a la izquierda hhh, hh, h, y l y van pasando a los registros dígito, y lo hace por orden, primero L, segundo H, tercero HH y por ultimo HHH. y a medida que que este ultimo rota, va entrando por orden en los registros dígito. que pasa si solo ponemos un dato de 8 bits (L), pues que cuando rote los 8, el dato abra pasado (H)
y nunca llegara a los dígitos, se quedara en cero. entonces la solución es cuando quiero convertir un dato de 8 bits, lo almaceno en HHH, si es de 16 en HHH y HH, si es de 24 HHH, HH y H
y cuando es de 32 como es de esperar HHH, HH, H y L. de esta manera aseguro que cuando inicio la rotación sea cual sea el tamaño siempre entra completo en los registros dígito

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 07 de Septiembre de 2018, 19:57:25

BUENAS.

os dejo los macros y la subrutina con la mejora en el convertidor. se a eliminado la criba de ceros para indicar el numero objeto. y se añadió una criba para los 10 dígitos.

así no confundimos al usuario y con la criaba de todos los dígitos también ganamos tiempo al no enviar ceros innecesarios. la rutina ocupa un pilen mas de espacio pero es mas rápida.
pero al modificar los macros ganamos espacio porque ay menos lineas

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 08 de Septiembre de 2018, 15:02:09

buenas.

os dejo una simulación de una onda senoidal. esta se puede ver con el EJEMPLO_9.HMI

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 09 de Septiembre de 2018, 14:19:01

buenas

añado una función, oculta y muestra objetos. es muy útil si no quieres que un objeto se muestre asta que se lo requiera.

pd: recuerden actualizar la subrutina y los macros a medida que añado alguna cosa.

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: estebanfolcher en 09 de Septiembre de 2018, 15:44:27

BUENAS

añado función para cambio de pagina

Título: Re:Subrutina para el manejo de pantalla Nextion
Publicado por: manuel-241 en 15 de Abril de 2023, 20:51:05

Hola, he leído el hilo y queria comentar el problema, estoy comunicando la pantalla nextion con un plc siemens s71200 a través de RS232, la parte de la recepción en el plc está hecha pero el envío no consigo que por ejemplo un numero se me muestre en un cuadro numérico en la pantalla nextion, estoy casi seguro de que es por la trama en hexadecimal que tengo que enviar que es incorrecta. El cuadro numérico tiene el ID2 y está en la página 0. Alguien puede decirme la cadena en hexadecimal que debo de enviar para probar el envío y ver como se hace?

TODOPIC

Microcontroladores PIC => Almacén del Assembler => Mensaje iniciado por: estebanfolcher en 14 de Agosto de 2018, 16:55:42