Autor Tema: Subrutina para el manejo de pantalla Nextion  (Leído 16905 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Subrutina para el manejo de pantalla Nextion
« 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.

Desconectado Pinolillo16

  • PIC18
  • ****
  • Mensajes: 324
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #1 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
  1. CONVERSION_BCD
  2.         MOVWF   AUXILIAR
  3.         CLRF    AUX_UNIDADES
  4.         CLRF    AUX_DECENAS
  5.         CLRF    AUX_CENTENAS
  6. S_CENTENAS
  7.         MOVLW   .100
  8.         SUBWF   AUXILIAR,W
  9.         BTFSC   STATUS,C
  10.         GOTO    SUMA_CENTENAS
  11.         GOTO    S_DECENAS
  12. SUMA_CENTENAS
  13.         MOVWF   AUXILIAR
  14.         INCF    AUX_CENTENAS,F
  15.         GOTO    S_CENTENAS
  16. S_DECENAS
  17.         MOVLW   .10
  18.         SUBWF   AUXILIAR,W
  19.         BTFSC   STATUS,C
  20.         GOTO    SUMA_DECENAS
  21.         GOTO    SUMA_UNIDADES
  22. SUMA_DECENAS
  23.         MOVWF   AUXILIAR
  24.         INCF    AUX_DECENAS,1
  25.         GOTO    S_DECENAS
  26. SUMA_UNIDADES
  27.         MOVF    AUXILIAR,W
  28.         MOVWF   AUX_UNIDADES
  29.         MOVLW   B'00110000'
  30.         ADDWF   AUX_UNIDADES,F
  31.         ADDWF   AUX_DECENAS,F
  32.         ADDWF   AUX_CENTENAS,F
  33.         RETURN

Desconectado Pinolillo16

  • PIC18
  • ****
  • Mensajes: 324
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #2 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

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #3 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

 


                                                             


Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #4 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
« Última modificación: 15 de Agosto de 2018, 20:36:41 por estebanfolcher »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #5 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.

Desconectado Pinolillo16

  • PIC18
  • ****
  • Mensajes: 324
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #6 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
  1. MOVF  DATO,W
  2. 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

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #7 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.



Desconectado Pinolillo16

  • PIC18
  • ****
  • Mensajes: 324
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #8 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

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #9 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.

 

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #10 en: 16 de Agosto de 2018, 08:34:18 »
Código: ASM
  1. ;------------------------------------------------------------
  2. ; Código assembler
  3. ; Proyecto: usart_prueba
  4. ; Autor:
  5. ; Fecha: 06/08/2018
  6. ; PIC: 16F877A
  7. ; Velocidad de reloj: 4 Mhz
  8. ; Descripcion:
  9. ;------------------------------------------------------------
  10.                     LIST    P=PIC16F877A
  11.                     INCLUDE P16F877A.INC
  12.  
  13.         __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
  14.    
  15.                    
  16.                    
  17.    
  18.  
  19. PUERTO_TX           EQU         6       ;PIN DE TRANSMICION
  20. PUERTO_RC           EQU         7       ;PINDE RECEPCION               
  21.                
  22.                     CBLOCK      0x20
  23.                     ENDC
  24.                    
  25.                
  26. STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
  27.                     PAGESEL     COMIENZO
  28.                     GOTO        COMIENZO    ;COMIENZO DEL PROGRAMA
  29.                
  30.                     CODE
  31.                    
  32.                    
  33. COMIENZO            CALL        Inicia_USART_Nextion
  34.                     MOVLW       d'191'
  35.                     CALL        CONVERSION_BCD
  36.                    
  37.                     MOVLW       'n'
  38.                     MOVWF       Dato_TX_1
  39.                     MOVLW       '0'
  40.                     MOVWF       Dato_TX_2
  41.                     MOVLW       '.'
  42.                     MOVWF       Dato_TX_3
  43.                     MOVLW       'v'
  44.                     MOVWF       Dato_TX_4
  45.                     MOVLW       'a'
  46.                     MOVWF       Dato_TX_5
  47.                     MOVLW       'l'
  48.                     MOVWF       Dato_TX_6
  49.                     MOVLW       '='
  50.                     MOVWF       Dato_TX_7
  51.                     MOVF        BCD_UNIDADES,W
  52.                     MOVWF       Dato_TX_8
  53.                     MOVF        BCD_DECENAS,W
  54.                     MOVWF       Dato_TX_9
  55.                     MOVF        BCD_CENTENAS,W
  56.                     MOVWF       Dato_TX_10
  57.                    
  58. Principal           CALL        Nextion
  59.                     CALL        Retardo_1s
  60.                     GOTO        Principal
  61.                     INCLUDE     <BINARIO_A_BCD.INC>
  62.                     INCLUDE     <Nextion_TX_RC.INC>
  63.                     INCLUDE     <RETARDOS.INC>
  64.  
  65.                  
  66.                     END
Código: ASM
  1. ;****************************BINARIO_A_BCD:INC**********************************
  2.         CBLOCK                 
  3.         AUXILIAR
  4.         BCD_UNIDADES
  5.         BCD_DECENAS
  6.         BCD_CENTENAS   
  7.         ENDC
  8.  
  9. CONVERSION_BCD
  10.         MOVWF   AUXILIAR
  11.         CLRF    BCD_UNIDADES
  12.         CLRF    BCD_DECENAS
  13.         CLRF    BCD_CENTENAS
  14. S_CENTENAS
  15.         MOVLW   d'100'
  16.         SUBWF   AUXILIAR,W
  17.         BTFSC   STATUS,C
  18.         GOTO    SUMA_CENTENAS
  19.         GOTO    S_DECENAS
  20. SUMA_CENTENAS
  21.         MOVWF   AUXILIAR
  22.         INCF    BCD_CENTENAS,F
  23.         GOTO    S_CENTENAS
  24. S_DECENAS
  25.         MOVLW   d'10'
  26.         SUBWF   AUXILIAR,W
  27.         BTFSC   STATUS,C
  28.         GOTO    SUMA_DECENAS
  29.         GOTO    SUMA_UNIDADES
  30. SUMA_DECENAS
  31.         MOVWF   AUXILIAR
  32.         INCF    BCD_DECENAS,1
  33.         GOTO    S_DECENAS
  34. SUMA_UNIDADES
  35.         MOVF    AUXILIAR,W
  36.         MOVWF   BCD_UNIDADES
  37.         MOVLW   d'48'
  38.         ADDWF   BCD_UNIDADES,F
  39.         ADDWF   BCD_DECENAS,F
  40.         ADDWF   BCD_CENTENAS,F
  41.         RETURN

Código: ASM
  1. ;********************NEXTION_TX_RC.INC******************************************
  2. ;****************  SUBRUTINA INICIALISA, ENVIA Y RECIBE  ***********************
  3. ;*******************************************************************************
  4. ;               BIT A DECLARAR PARA ESTA SUBRUTINA
  5. ;                  
  6. ;   PUERTO_TX   EQU     6       ;PIN DE TRANSMICION
  7. ;   PUERTO_RC   EQU     7       ;PINDE RECEPCION
  8. ;                  
  9. ;                  
  10. ;******************************  INICIO  ***************************************
  11.                         CBLOCK
  12.                         Dato_TX_1
  13.                         Dato_TX_2
  14.                         Dato_TX_3
  15.                         Dato_TX_4
  16.                         Dato_TX_5
  17.                         Dato_TX_6
  18.                         Dato_TX_7
  19.                         Dato_TX_8
  20.                         Dato_TX_9
  21.                         Dato_TX_10
  22.                         Dato_TX_11
  23.                         Dato_TX_12
  24.                         Dato_TX_13
  25.                         Dato_TX_Fin             ;FIN DE TRANSMICION ENVIAR E
  26.                         ENDC                    ;VECES PARA QUE LA PANTALLA
  27.                                                 ;LEA FIN DE TRANSMICION
  28. Inicia_USART_Nextion    BSF     STATUS,RP0      ;ENTRO EN BANCO 1
  29.                         BCF     STATUS,RP1                     
  30.                         BCF     TRISC,PUERTO_TX ;PONE A (0) ESTE PIN COMO SALIDA
  31.                         BSF     TRISC,PUERTO_RC ;PONE A (1) ESTE PIN COMO ENTRADA
  32.                         MOVLW   0x24            ;TX HABILITADA, MODO ASINCRON0
  33.                         MOVWF   TXSTA           ;CON 8 BITS Y ALTA VELOCIDAD
  34.                         MOVLW   0x19            ;SET BAUDIOS A 9600  
  35.                         MOVWF   SPBRG           ;CON Fosc = 4MHz
  36.                         BCF     STATUS,RP0      ;ENTRO EN BANCO 0
  37.                         BCF     STATUS,RP1
  38.                         MOVLW   0x90            ;AJUSTA RECEPTOR A 8 BITS, RECEPCION
  39.                         MOVWF   RCSTA           ;CONTINUA HABILITADA USART EN ON
  40.                         MOVLW   'ÿ'   
  41.                         MOVWF   Dato_TX_Fin
  42.                         RETURN
  43.  
  44.  
  45.                    
  46. Envia_USART_Nextion     BSF     STATUS,RP0
  47.                         BCF     STATUS,RP1
  48.                         BTFSS   TXSTA,TRMT
  49.                         GOTO    Envia_USART_Nextion
  50.                         BCF     STATUS,RP0
  51.                         BCF     STATUS,RP1
  52.                         MOVWF   TXREG
  53.                         RETURN
  54.                    
  55. Recibe_USART_Nextion    BCF     STATUS,RP0
  56.                         BCF     STATUS,RP1
  57.                         BTFSS   PIR1,RCIF
  58.                         GOTO    Recibe_USART_Nextion
  59.                         MOVF    RCREG,W
  60. DATO                    BCF     PIR1,RCIF
  61.                         BSF     STATUS,RP0
  62.                         BCF     STATUS,RP1
  63.                        
  64.                         RETURN
  65.  
  66. Nextion                 MOVf    Dato_TX_1,W
  67.                         CALL    Envia_USART_Nextion
  68.                         MOVF    Dato_TX_2,W
  69.                         CALL    Envia_USART_Nextion
  70.                         MOVF    Dato_TX_3,W
  71.                         CALL    Envia_USART_Nextion
  72.                         MOVF    Dato_TX_4,W
  73.                         CALL    Envia_USART_Nextion
  74.                         MOVF    Dato_TX_5,W
  75.                         CALL    Envia_USART_Nextion
  76.                         MOVF    Dato_TX_6,W
  77.                         CALL    Envia_USART_Nextion
  78.                         MOVF    Dato_TX_7,W
  79.                         CALL    Envia_USART_Nextion
  80.                         MOVF    Dato_TX_8,W
  81.                         CALL    Envia_USART_Nextion
  82.                         MOVF    Dato_TX_9,W
  83.                         CALL    Envia_USART_Nextion
  84.                         MOVF    Dato_TX_10,W
  85.                         CALL    Envia_USART_Nextion
  86.                         MOVF    Dato_TX_Fin,W
  87.                         CALL    Envia_USART_Nextion
  88.                         MOVF    Dato_TX_Fin,W
  89.                         CALL    Envia_USART_Nextion
  90.                         MOVF    Dato_TX_Fin,W
  91.                         CALL    Envia_USART_Nextion
  92.                         RETURN

Código: ASM
  1. ;**************************** Librería "RETARDOS.INC" *********************************
  2. ; Librería con múltiples subrutinas de retardos, desde 4 microsegundos hasta 20 segundos.
  3. ; Además se pueden implementar otras subrutinas muy fácilmente.
  4. ;
  5. ; Se han calculado para un sistema microcontrolador con un PIC trabajando con un cristal
  6. ; de cuarzo a 4 MHz. Como cada ciclo máquina son 4 ciclos de reloj, resulta que cada
  7. ; ciclo máquina tarda 4 x 1/4MHz = 1 µs.
  8. ;
  9. ; En los comentarios, "cm" significa "ciclos máquina".
  10. ;
  11. ; ZONA DE DATOS *********************************************************************
  12.  
  13.         CBLOCK
  14.         R_ContA                         ; Contadores para los retardos.
  15.         R_ContB
  16.         R_ContC
  17.         ENDC
  18. ;
  19. ; RETARDOS de 4 hasta 10 microsegundos ---------------------------------------------------
  20. ;
  21. ; A continuación retardos pequeños teniendo en cuenta que para una frecuencia de 4 MHZ,
  22. ; la llamada a subrutina "call" tarda 2 ciclos máquina, el retorno de subrutina
  23. ; "return" toma otros 2 ciclos máquina y cada instrucción "nop" tarda 1 ciclo máquina.
  24. ;
  25. Retardo_10micros                                ; La llamada "call" aporta 2 ciclos máquina.
  26.         nop                             ; Aporta 1 ciclo máquina.
  27.         nop                             ; Aporta 1 ciclo máquina.
  28.         nop                             ; Aporta 1 ciclo máquina.
  29.         nop                             ; Aporta 1 ciclo máquina.
  30.         nop                             ; Aporta 1 ciclo máquina.
  31. Retardo_5micros                         ; La llamada "call" aporta 2 ciclos máquina.
  32.         nop                             ; Aporta 1 ciclo máquina.
  33. Retardo_4micros                         ; La llamada "call" aporta 2 ciclos máquina.
  34.         return                          ; El salto del retorno aporta 2 ciclos máquina.
  35. ;
  36. ; RETARDOS de 20 hasta 500 microsegundos ------------------------------------------------
  37. ;
  38. Retardo_500micros                               ; La llamada "call" aporta 2 ciclos máquina.
  39.         nop                             ; Aporta 1 ciclo máquina.
  40.         movlw   d'164'                  ; Aporta 1 ciclo máquina. Este es el valor de "K".
  41.         goto    RetardoMicros           ; Aporta 2 ciclos máquina.
  42. Retardo_200micros                               ; La llamada "call" aporta 2 ciclos máquina.
  43.         nop                             ; Aporta 1 ciclo máquina.
  44.         movlw   d'64'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
  45.         goto    RetardoMicros           ; Aporta 2 ciclos máquina.
  46. Retardo_100micros                               ; La llamada "call" aporta 2 ciclos máquina.
  47.         movlw   d'31'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
  48.         goto    RetardoMicros           ; Aporta 2 ciclos máquina.
  49. Retardo_50micros                                ; La llamada "call" aporta 2 ciclos máquina.
  50.         nop                             ; Aporta 1 ciclo máquina.
  51.         movlw   d'14'                   ; Aporta 1 ciclo máquina. Este es el valor de "K".
  52.         goto    RetardoMicros           ; Aporta 2 ciclos máquina.
  53. Retardo_20micros                                ; La llamada "call" aporta 2 ciclos máquina.
  54.         movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "K".
  55. ;
  56. ; El próximo bloque "RetardoMicros" tarda:
  57. ; 1 + (K-1) + 2 + (K-1)x2 + 2 = (2 + 3K) ciclos máquina.
  58. ;
  59. RetardoMicros
  60.         movwf   R_ContA                 ; Aporta 1 ciclo máquina.
  61. Rmicros_Bucle
  62.         decfsz  R_ContA,F               ; (K-1)x1 cm (cuando no salta) + 2 cm (al saltar).
  63.         goto    Rmicros_Bucle           ; Aporta (K-1)x2 ciclos máquina.
  64.         return                          ; El salto del retorno aporta 2 ciclos máquina.
  65. ;
  66. ;En total estas subrutinas tardan:
  67. ; - Retardo_500micros:  2 + 1 + 1 + 2 + (2 + 3K) = 500 cm = 500 µs. (para K=164 y 4 MHz).
  68. ; - Retardo_200micros:  2 + 1 + 1 + 2 + (2 + 3K) = 200 cm = 200 µs. (para K= 64 y 4 MHz).
  69. ; - Retardo_100micros:  2     + 1 + 2 + (2 + 3K) = 100 cm = 100 µs. (para K= 31 y 4 MHz).
  70. ; - Retardo_50micros :  2 + 1 + 1 + 2 + (2 + 3K) =  50 cm =  50 µs. (para K= 14 y 4 MHz).
  71. ; - Retardo_20micros :  2     + 1     + (2 + 3K) =  20 cm =  20 µs. (para K=  5 y 4 MHz).
  72. ;
  73. ; RETARDOS de 1 ms hasta 200 ms. --------------------------------------------------------
  74. ;
  75. Retardo_200ms                           ; La llamada "call" aporta 2 ciclos máquina.
  76.         movlw   d'200'                  ; Aporta 1 ciclo máquina. Este es el valor de "M".
  77.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  78. Retardo_100ms                           ; La llamada "call" aporta 2 ciclos máquina.
  79.         movlw   d'100'                  ; Aporta 1 ciclo máquina. Este es el valor de "M".
  80.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  81. Retardo_50ms                            ; La llamada "call" aporta 2 ciclos máquina.
  82.         movlw   d'50'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
  83.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  84. Retardo_20ms                            ; La llamada "call" aporta 2 ciclos máquina.
  85.         movlw   d'20'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
  86.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  87. Retardo_10ms                            ; La llamada "call" aporta 2 ciclos máquina.
  88.         movlw   d'10'                   ; Aporta 1 ciclo máquina. Este es el valor de "M".
  89.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  90. Retardo_5ms                             ; La llamada "call" aporta 2 ciclos máquina.
  91.         movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
  92.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  93. Retardo_2ms                             ; La llamada "call" aporta 2 ciclos máquina.
  94.         movlw   d'2'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
  95.         goto    Retardos_ms             ; Aporta 2 ciclos máquina.
  96. Retardo_1ms                             ; La llamada "call" aporta 2 ciclos máquina.
  97.         movlw   d'1'                    ; Aporta 1 ciclo máquina. Este es el valor de "M".
  98. ;
  99. ; El próximo bloque "Retardos_ms" tarda:
  100. ; 1 + M + M + KxM + (K-1)xM + Mx2 + (K-1)Mx2 + (M-1) + 2 + (M-1)x2 + 2 =
  101. ; = (2 + 4M + 4KM) ciclos máquina. Para K=249 y M=1 supone 1002 ciclos máquina
  102. ; que a 4 MHz son 1002 µs = 1 ms.
  103. ;
  104. Retardos_ms
  105.         movwf   R_ContB                 ; Aporta 1 ciclo máquina.
  106. R1ms_BucleExterno
  107.         movlw   d'249'                  ; Aporta Mx1 ciclos máquina. Este es el valor de "K".
  108.         movwf   R_ContA                 ; Aporta Mx1 ciclos máquina.
  109. R1ms_BucleInterno
  110.         nop                             ; Aporta KxMx1 ciclos máquina.
  111.         decfsz  R_ContA,F               ; (K-1)xMx1 cm (cuando no salta) + Mx2 cm (al saltar).
  112.         goto    R1ms_BucleInterno               ; Aporta (K-1)xMx2 ciclos máquina.
  113.         decfsz  R_ContB,F               ; (M-1)x1 cm (cuando no salta) + 2 cm (al saltar).
  114.         goto    R1ms_BucleExterno       ; Aporta (M-1)x2 ciclos máquina.
  115.         return                          ; El salto del retorno aporta 2 ciclos máquina.
  116. ;
  117. ;En total estas subrutinas tardan:
  118. ; - Retardo_200ms:      2 + 1 + 2 + (2 + 4M + 4KM) = 200007 cm = 200 ms. (M=200 y K=249).
  119. ; - Retardo_100ms:      2 + 1 + 2 + (2 + 4M + 4KM) = 100007 cm = 100 ms. (M=100 y K=249).
  120. ; - Retardo_50ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  50007 cm =  50 ms. (M= 50 y K=249).
  121. ; - Retardo_20ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  20007 cm =  20 ms. (M= 20 y K=249).
  122. ; - Retardo_10ms :      2 + 1 + 2 + (2 + 4M + 4KM) =  10007 cm =  10 ms. (M= 10 y K=249).
  123. ; - Retardo_5ms  :      2 + 1 + 2 + (2 + 4M + 4KM) =   5007 cm =   5 ms. (M=  5 y K=249).
  124. ; - Retardo_2ms  :      2 + 1 + 2 + (2 + 4M + 4KM) =   2007 cm =   2 ms. (M=  2 y K=249).
  125. ; - Retardo_1ms  :      2 + 1     + (2 + 4M + 4KM) =   1005 cm =   1 ms. (M=  1 y K=249).
  126. ;
  127. ; RETARDOS de 0.5 hasta 20 segundos ---------------------------------------------------
  128. ;
  129. Retardo_20s                             ; La llamada "call" aporta 2 ciclos máquina.
  130.         movlw   d'200'                  ; Aporta 1 ciclo máquina. Este es el valor de "N".
  131.         goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
  132. Retardo_10s                             ; La llamada "call" aporta 2 ciclos máquina.
  133.         movlw   d'100'                  ; Aporta 1 ciclo máquina. Este es el valor de "N".
  134.         goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
  135. Retardo_5s                              ; La llamada "call" aporta 2 ciclos máquina.
  136.         movlw   d'50'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
  137.         goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
  138. Retardo_2s                              ; La llamada "call" aporta 2 ciclos máquina.
  139.         movlw   d'20'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
  140.         goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
  141. Retardo_1s                              ; La llamada "call" aporta 2 ciclos máquina.
  142.         movlw   d'10'                   ; Aporta 1 ciclo máquina. Este es el valor de "N".
  143.         goto    Retardo_1Decima         ; Aporta 2 ciclos máquina.
  144. Retardo_500ms                           ; La llamada "call" aporta 2 ciclos máquina.
  145.         movlw   d'5'                    ; Aporta 1 ciclo máquina. Este es el valor de "N".
  146. ;
  147. ; El próximo bloque "Retardo_1Decima" tarda:
  148. ; 1 + N + N + MxN + MxN + KxMxN + (K-1)xMxN + MxNx2 + (K-1)xMxNx2 +
  149. ;   + (M-1)xN + Nx2 + (M-1)xNx2 + (N-1) + 2 + (N-1)x2 + 2 =
  150. ; = (2 + 4M + 4MN + 4KM) ciclos máquina. Para K=249, M=100 y N=1 supone 100011
  151. ; ciclos máquina que a 4 MHz son 100011 µs = 100 ms = 0,1 s = 1 décima de segundo.
  152. ;
  153. Retardo_1Decima
  154.         movwf   R_ContC                 ; Aporta 1 ciclo máquina.
  155. R1Decima_BucleExterno2
  156.         movlw   d'100'                  ; Aporta Nx1 ciclos máquina. Este es el valor de "M".
  157.         movwf   R_ContB                 ; Aporta Nx1 ciclos máquina.
  158. R1Decima_BucleExterno
  159.         movlw   d'249'                  ; Aporta MxNx1 ciclos máquina. Este es el valor de "K".
  160.         movwf   R_ContA                 ; Aporta MxNx1 ciclos máquina.
  161. R1Decima_BucleInterno          
  162.         nop                             ; Aporta KxMxNx1 ciclos máquina.
  163.         decfsz  R_ContA,F               ; (K-1)xMxNx1 cm (si no salta) + MxNx2 cm (al saltar).
  164.         goto    R1Decima_BucleInterno   ; Aporta (K-1)xMxNx2 ciclos máquina.
  165.         decfsz  R_ContB,F               ; (M-1)xNx1 cm (cuando no salta) + Nx2 cm (al saltar).
  166.         goto    R1Decima_BucleExterno   ; Aporta (M-1)xNx2 ciclos máquina.
  167.         decfsz  R_ContC,F               ; (N-1)x1 cm (cuando no salta) + 2 cm (al saltar).
  168.         goto    R1Decima_BucleExterno2  ; Aporta (N-1)x2 ciclos máquina.
  169.         return                          ; El salto del retorno aporta 2 ciclos máquina.
  170. ;
  171. ;En total estas subrutinas tardan:
  172. ; - Retardo_20s:        2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 20000807 cm = 20 s.
  173. ;                       (N=200, M=100 y K=249).
  174. ; - Retardo_10s:        2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) = 10000407 cm = 10 s.
  175. ;                       (N=100, M=100 y K=249).
  176. ; - Retardo_5s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  5000207 cm =  5 s.
  177. ;                       (N= 50, M=100 y K=249).
  178. ; - Retardo_2s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  2000087 cm =  2 s.
  179. ;                       (N= 20, M=100 y K=249).
  180. ; - Retardo_1s:         2 + 1 + 2 + (2 + 4N + 4MN + 4KMN) =  1000047 cm =  1 s.
  181. ;                       (N= 10, M=100 y K=249).
  182. ; - Retardo_500ms:      2 + 1     + (2 + 4N + 4MN + 4KMN) =   500025 cm = 0,5 s.
  183. ;                       (N=  5, M=100 y K=249).

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #11 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
  1. ;------------------------------------------------------------
  2. ; Código assembler
  3. ; Proyecto: usart_prueba
  4. ; Autor:
  5. ; Fecha: 06/08/2018
  6. ; PIC: 16F877A
  7. ; Velocidad de reloj: 4 Mhz
  8. ; Descripcion:
  9. ;------------------------------------------------------------
  10.                     LIST    P=PIC16F877A
  11.                     INCLUDE P16F877A.INC
  12.  
  13.         __CONFIG _FOSC_XT & _WDTE_OFF & _PWRTE_OFF & _BOREN_ON & _LVP_OFF & _CPD_OFF & _WRT_OFF & _CP_OFF
  14.    
  15.                    
  16.                    
  17.  
  18.  
  19.  
  20. PUERTO_TX           EQU         6       ;PIN DE TRANSMICION
  21. PUERTO_RC           EQU         7       ;PINDE RECEPCION               
  22.                
  23.                     CBLOCK      0x20
  24.                     ENDC
  25. STAR                ORG         0x00        ;DIRECCION DE VECTOR RESET
  26.                     PAGESEL     COMIENZO
  27.                     GOTO        COMIENZO    ;COMIENZO DEL PROGRAMA
  28.                     CODE
  29. T_Texto_NEX         MOVWF       PCL
  30. Mensaje_NEX_1       DT          "HOLA MUNDO", 0x00
  31. ;////////           //          //        2,0X00  
  32.  
  33.            
  34.            
  35. COMIENZO            MOVLW       d'1'
  36.                     MOVWF       NUM_OBJ
  37.                     CALL        Nex_Texto_Inicializa
  38.                
  39.                    
  40. Principal           MOVLW       Mensaje_NEX_1
  41.                     CALL        Nex_Texto
  42.                     CALL        Retardo_1s
  43.                     GOTO        Principal
  44.                     INCLUDE     <NEXTION_SUB.INC>
  45.                     INCLUDE     <RETARDOS.INC>
  46.  
  47.                  
  48.                     END

Código: ASM
  1. CBLOCK
  2.                         Guarda_Posicion_Tabla
  3.                         Guarda_Caracter
  4.                         NUM_OBJ
  5.                         DATO_TX_0
  6.                         DATO_TX_1
  7.                         DATO_TX_2
  8.                         DATO_TX_3
  9.                         DATO_TX_4
  10.                         DATO_TX_5
  11.                         DATO_TX_6
  12.                         DATO_TX_7
  13.                         DATO_TX_8
  14.                         DATO_TX_9
  15.                         DATO_TX_10
  16.                         ENDC
  17. Nex_Texto_Inicializa    CALL    Inicia_USART_Nextion
  18.                         MOVLW   't'
  19.                         MOVWF   DATO_TX_0
  20.                         MOVF    NUM_OBJ,W
  21.                         CALL    BIN_BCD
  22.                         CALL    Si_Uni_Dec_Cen
  23.                         MOVLW   '.'
  24.                         MOVWF   DATO_TX_4
  25.                         MOVLW   't'
  26.                         MOVWF   DATO_TX_5
  27.                         MOVLW   'x'
  28.                         MOVWF   DATO_TX_6
  29.                         MOVLW   't'
  30.                         MOVWF   DATO_TX_7
  31.                         MOVLW   '='
  32.                         MOVWF   DATO_TX_8
  33.                         MOVLW   '"'
  34.                         MOVWF   DATO_TX_9
  35.                         RETURN
  36. Nex_Texto               MOVWF   Guarda_Posicion_Tabla
  37.                         MOVf    DATO_TX_0,W
  38.                         CALL    Envia_USART_Nextion
  39.                         MOVf    DATO_TX_1,W
  40.                         CALL    Envia_USART_Nextion
  41.                         MOVF    DATO_TX_2,W
  42.                         CALL    Envia_USART_Nextion
  43.                         MOVF    DATO_TX_3,W
  44.                         CALL    Envia_USART_Nextion
  45.                         MOVF    DATO_TX_4,W
  46.                         CALL    Envia_USART_Nextion
  47.                         MOVF    DATO_TX_5,W
  48.                         CALL    Envia_USART_Nextion
  49.                         MOVF    DATO_TX_6,W
  50.                         CALL    Envia_USART_Nextion
  51.                         MOVF    DATO_TX_7,W
  52.                         CALL    Envia_USART_Nextion
  53.                         MOVF    DATO_TX_8,W
  54.                         CALL    Envia_USART_Nextion
  55.                         MOVF    DATO_TX_9,W
  56.                         CALL    Envia_USART_Nextion
  57. Nex_Texto_1             MOVF    Guarda_Posicion_Tabla,W
  58.                         CALL    T_Texto_NEX
  59.                         MOVWF   Guarda_Caracter
  60.                         MOVF    Guarda_Caracter,F
  61.                         BTFSS   STATUS,Z
  62.                         GOTO    Nex_Texto_2
  63.                         MOVF    DATO_TX_9,W
  64.                         CALL    Envia_USART_Nextion
  65.                         MOVLW   'ÿ'
  66.                         CALL    Envia_USART_Nextion
  67.                         MOVLW   'ÿ'
  68.                         CALL    Envia_USART_Nextion
  69.                         MOVLW   'ÿ'
  70.                         CALL    Envia_USART_Nextion
  71.                         RETURN 
  72. Nex_Texto_2             CALL    Envia_USART_Nextion
  73.                         INCF    Guarda_Posicion_Tabla,F
  74.                         GOTO    Nex_Texto_1
  75.  
  76.                        
  77.                        
  78.                        
  79. ;********************BIN_BCD_ASCII**********************************************
  80.                                
  81.                                 CBLOCK                 
  82.                                 AUXILIAR
  83.                                 BCD_UNIDADES
  84.                                 BCD_DECENAS
  85.                                 BCD_CENTENAS   
  86.                                 ENDC
  87. BIN_BCD
  88.                         MOVWF   AUXILIAR
  89.                         CLRF    BCD_UNIDADES
  90.                         CLRF    BCD_DECENAS
  91.                         CLRF    BCD_CENTENAS
  92. S_Centenas
  93.                         MOVLW   d'100'
  94.                         SUBWF   AUXILIAR,W
  95.                         BTFSC   STATUS,C
  96.                         GOTO    Suma_Centenas
  97.                         GOTO    S_Decenas
  98. Suma_Centenas
  99.                         MOVWF   AUXILIAR
  100.                         INCF    BCD_CENTENAS,F
  101.                         GOTO    S_Centenas
  102. S_Decenas
  103.                         MOVLW   d'10'
  104.                         SUBWF   AUXILIAR,W
  105.                         BTFSC   STATUS,C
  106.                         GOTO    Suma_Decenas
  107.                         GOTO    Suma_Unidades
  108. Suma_Decenas
  109.                         MOVWF   AUXILIAR
  110.                         INCF    BCD_DECENAS,1
  111.                         GOTO    S_Decenas
  112. Suma_Unidades
  113.                         MOVF    AUXILIAR,W
  114.                         MOVWF   BCD_UNIDADES
  115.                         BCF     STATUS,Z
  116.                         BCF     STATUS,C
  117.                        
  118.                         RETURN
  119. ;***************** SOLO SI CUALQUIERA DE LOS REGISTROS BCD>0********************
  120. Si_Uni_Dec_Cen      MOVF        BCD_CENTENAS,W     
  121.                     SUBLW       d'0'
  122.                     BTFSS       STATUS,Z
  123.                     GOTO        Todo_UDC
  124.                     GOTO        Pregunta_Dec
  125. Todo_UDC            MOVLW       d'48'
  126.                     ADDWF       BCD_UNIDADES,F
  127.                     ADDWF       BCD_DECENAS,F
  128.                     ADDWF       BCD_CENTENAS,F
  129.                    
  130.                     MOVF        BCD_UNIDADES,W
  131.                     MOVWF       DATO_TX_3
  132.                     MOVF        BCD_DECENAS,W
  133.                     MOVWF       DATO_TX_2
  134.                     MOVF        BCD_CENTENAS,W
  135.                     MOVWF       DATO_TX_1
  136.                     BCF         STATUS,Z
  137.                     BCF         STATUS,C
  138.                     RETURN
  139.                    
  140. Pregunta_Dec        MOVF        BCD_DECENAS,W      
  141.                     SUBLW       d'0'
  142.                     BTFSS       STATUS,Z
  143.                     GOTO        Todo_UD
  144.                     GOTO        Solo_Uni
  145. Todo_UD             MOVLW       d'48'
  146.                     ADDWF       BCD_UNIDADES,F
  147.                     ADDWF       BCD_DECENAS,F
  148.                     MOVF        BCD_UNIDADES,W
  149.                     MOVWF       DATO_TX_3
  150.                     MOVF        BCD_DECENAS,W
  151.                     MOVWF       DATO_TX_2
  152.                     MOVLW       d'0'
  153.                     MOVWF       DATO_TX_1
  154.                     BCF         STATUS,Z
  155.                     BCF         STATUS,C
  156.                     RETURN
  157.  
  158. Solo_Uni            MOVLW       d'48'
  159.                     ADDWF       BCD_UNIDADES,F
  160.                     MOVF        BCD_UNIDADES,W
  161.                     MOVWF       DATO_TX_3
  162.                     MOVLW       d'0'
  163.                     MOVWF       DATO_TX_2
  164.                     MOVLW       d'0'
  165.                     MOVWF       DATO_TX_1
  166.                     RETURN
  167.                    
  168. ;******************INICIA COMUNICACION USART************************************                   
  169. Inicia_USART_Nextion    BSF     STATUS,RP0     
  170.                         BCF     STATUS,RP1                     
  171.                         BCF     TRISC,PUERTO_TX ;PONE A (0) ESTE PIN COMO SALIDA
  172.                         BSF     TRISC,PUERTO_RC ;PONE A (1) ESTE PIN COMO ENTRADA
  173.                         MOVLW   0x24            ;TX HABILITADA, MODO ASINCRON0
  174.                         MOVWF   TXSTA           ;CON 8 BITS Y ALTA VELOCIDAD
  175.                         MOVLW   0x19            ;SET BAUDIOS A 9600  
  176.                         MOVWF   SPBRG           ;CON Fosc = 4MHz
  177.                         BCF     STATUS,RP0      ;ENTRO EN BANCO 0
  178.                         BCF     STATUS,RP1
  179.                         MOVLW   0x90            ;AJUSTA RECEPTOR A 8 BITS, RECEPCION
  180.                         MOVWF   RCSTA           ;CONTINUA HABILITADA USART EN ON
  181.                         RETURN
  182. ;*****************ENVIA Y RECIBE USART******************************************
  183. Envia_USART_Nextion     BSF     STATUS,RP0
  184.                         BCF     STATUS,RP1
  185.                         BTFSS   TXSTA,TRMT
  186.                         GOTO    Envia_USART_Nextion
  187.                         BCF     STATUS,RP0
  188.                         BCF     STATUS,RP1
  189.                         MOVWF   TXREG
  190.                         RETURN
  191. Recibe_USART_Nextion    BCF     STATUS,RP0
  192.                         BCF     STATUS,RP1
  193.                         BTFSS   PIR1,RCIF
  194.                         GOTO    Recibe_USART_Nextion
  195.                         MOVF    RCREG,W
  196. DATO                    BCF     PIR1,RCIF
  197.                         BSF     STATUS,RP0
  198.                         BCF     STATUS,RP1
  199.                         RETURN

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #12 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 )

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #13 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

Desconectado estebanfolcher

  • PIC12
  • **
  • Mensajes: 70
Re:Subrutina para el manejo de pantalla Nextion
« Respuesta #14 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.
 



 

anything