Hola que tal me dio mucho gusto recibir tu contestacion, mira este programa lo comence para simplemente ver un contador de cero hasta 65535 que es el valor máximo que vas a obtener al usar 2 registros de 8 bits consecutivamente en hiperterminal ó en lab view en el "VISA read" de labVIEW solo tienes que decirle cuantos BYTES va a leer que en este caso es 5 y es la terminal "Byte count". ahora este es solo un ejemplo de lo que tienes que hacer pero te va ha servir lo que hago en este programa es que tengo 2 registros de 8 bits uno es un contador parte baja y el otro es parte alta, una vez que incremento la parte baja la convierto quitando un bit del registro e incrementado en uno el registro para mandar al UART cuando se termina de llenar la parte baja y se incrementa la parte alta, hago lo siguiente primero me acabo la parte baja sea el valor que sea una vez que me acabe la parte baja me voy a preguntar por la alta si hay ceros quiere decir que ya no hay dato que convertir entonces llamo a la sibrritina exhibir (aqui en el programa viene), ahora si no hay ceros decremento en uno la parte alta y decremento en uno la parte baja si era antes 00 ahora es FF convierto todos esos bits y una vez dejados en cero vuelvo a preguntar ya fue cero la parte baja "SI" ya fue cero la parte alta? "NO" ahh entonces has lo mismo decrementa la parte alta en uno y la parte baja en uno y de 00 que habia pasa a ser FF y se decrementa hasta llegar a cero, y asi hasta que en a parte baja como en la alta haya puros ceros ok.
Ahora a que va todo este choro bueno a que tu tienes 2 registros tambien uno de 8 bits ADRESL y 2 bits ADRESH cual es el detalle que cada bit se incrementa por cada 48 milivolts entonces tu vas a hacer una sub-rutina que haga lo siguiente decrementa en uno laparte baja y CALL contador_48 (por ejemplo) esta subrrutina va a cargar el 48 en decimal que es el 30 en hex y vas a decrementar ese contador e incrementar unidad tal como se ve en el programa contador 48 ya fue cero? NO, decrementa contador_48 e incrementa unidad y asi sucesivamente,Contador 48 ya fué Cero '0' SI, la parte baja (ADRESL) ya fue cero NO, decrementa en uno y llama CALL a contador_48 y asi hasta que te acabes la parte baja ahora ya tienes ceros en la parte baja pues ahora checa si la parte alta vale ceros, NO bueno decrementa en uno la parte alta y decrementa en uno la parte baja de 00 que te quedó vas a tener FF y por cada uno que decrementes incrementa 48 a las memorias se oye tedioso pero la verdad solo es una subrrutina que va a estar ciclada, no hay problema ahi te va este programa. se ve un poco feo pero aun nose como adjunar archivos bueno ahi se ve el punto y coma que indica los cometarios ahora algo muy importante que tal se enciendes primero el pic y despues corres el programa en labVIEW pues te va a leer mal los datos los leera de forma desfasada si vas a mandar 2.345 volts a lo mejor te lee 452.3 volts puesto que cuando arranco labVIEW el pic apenas estaba acabando de mandar tus 2 últimos bytes y labVIEWte los tomo como los primeros, a menos que arranques los 2 al mismo tiempo que es imposible, ó usando un caracter verificador que le indique a labVIEW apartir de donde comienza la cadena, aqui te pongo unas imagenes del como lo puedes hacer hijole no me deja bueno mira en el read VISA le vas a mandar toda la cadena de caracteres y le vas a poner que solo quieres leer un byte y a la salida del visa read vas a poner un comparador de igual con el caracter arroba como constante y la salida del comparador lo vas a mandar a una estructura case donde si es verdadero 'TRUE' vas aponer otro VISA read pero dicendo que solo quieres leer 3 bytes (bueno los bytes que vallas a mandar donde esta la lectura de temperatura) y esa cadena de caracteres la metes a un convertidor que se llama "Decimal string to Number" y listo solo pones un termometro ó un indicador numerico o donde sea que vallas a mostrar la temperatura que esta en el salon despues de esto no olvides cerrar el puerto como se indica en el ejemplo de advanced read write que te habia mencionado y en dado caso que no sea arroba ó sea que la salida del comparador sea FALSE solo cierra el puerto. te mando mi correo para cualquier cosa creo que por el correo te puedo mandar mas cosas porque bueno aun falta mandarle datos al pic desde labVIEW para controlar la temperatura ahorita solo la estamos recibiendo pero falta controlarla Espero y esto te sirva saludos colega jeje tambienestudio electrónica y estoy enamorado de esta carrera asi que cualquiero cosa me puedes comentar. Que padre conocer gente de otros lugares hasta pronto.
alberto_electronica18@hotmail.com
unidad equ 20h
decena equ 21h
centena equ 22h
Millar equ 23h
Decena_d_Millar equ 24h
respaldo_bajo equ 25h
respaldo_alto equ 26h
contador_bajo equ 27h
contador_alto equ 28h
reg1 equ 29h
reg2 equ 2Ah
org 0x00
goto inicio
org 0x05
;////////////////////////////////////////////////PROGRAMA PRINCIPAL////////////////////////////////////////
inicio: bsf status,rp0 ;Cambio al banco 1
movlw 24h ;palabra de control para la transmision
movwf TXSTA ;Transmisión configurada
movlw 0x19 ;palabra de control para 9600 baudios
movwf SPBRG ;Configurado a 9600 baudios
bcf status,rp0 ;regreso al banco cero
movlw 90h ;Palabra de control para recepción
movwf RCSTA ;recepción configurada
clrf contador_bajo ;limpiando contador bajo solo para asegurar
clrf contador_alto ;limpiando contador bajo solo para asegurar
;///////////////////////PROCESO QUE SE ENCARGA DE INICIALIZAR LAS MEMORIAS EN CEROS ASCII///////////////////
movlw 30h
movwf unidad
movwf decena
movwf centena
movwf millar
movwf Decena_d_millar
;//////////////////CICLADO DEL PROGRAMA PARA QUE TODO EL TIEMPO INCREMENTE Y EXHIBA EN RS232///////////////
d_nuez: incf contador_bajo,1
movf contador_bajo,0
movwf respaldo_bajo
movf contador_alto,w
movwf respaldo_alto
call convertir
call exhibir
;///////////PROCESO QUE SE ENCARGA DE LLENAR NUEVAMENTE LAS MEMORIAS CON CEROS PARA QUE NO SE INCREMENTE//////
;///////////////////////////////////////////SOBRE EL VALOR ANTERIOR///////////////////////////////////////////
movlw 30h
movwf unidad
movwf decena
movwf centena
movwf Millar
movwf Decena_d_Millar
movlw 0xff
subwf contador_bajo,w
btfss status,2h
goto d_nuez
incf contador_alto,f
goto d_nuez
end
;/////////////////////////////////////////FIN DEL PROGRAMA PRINCIPAL///////////////////////////////////////////
;/////////////////////////////////////////////////SUBRUTINAS///////////////////////////////////////////////////
;/////SUBRUTINA QUE SE ENCARGA DE MOSTRAR LA CONVERSION DE UN NUMERO BINARIO A ASCII MOSTRANDO LOS VALORES/////
;///////////DE LAS MEMORIAS UNIDAD,DECENA,CENTENA...... PROPORCIONADAS POR LA SUBRUTINA CONVERTIR//////////////
Exhibir: movf Decena_d_Millar,w
movwf TXREG
call retardo_1ms ;da el tiempo necesario para que se transmita el dato la configuracion es
movf Millar,w ;9600 baudios el inverso de 9600 son 104 micro segundos pero el pic no
movwf TXREG ;da este baudaje exacto entonces en un milisegundo transmite muy bien
call retardo_1ms ;el bit de inicio, los 8 bits de datos y el bit de stop
movf centena,w
movwf TXREG
call retardo_1ms
movf decena,w
movwf TXREG
call retardo_1ms
movf unidad,w
movwf TXREG
call retardo_1ms
movlw 40h ;Se manda un arroba @ como codificador para saber el orden de la cadena
movwf TXREG ;al momento de decodificar solo se elimina el @ y se toma la cadena
call retardo_1ms ;También se pueden oner codigos especiales como el enter 0x0D
;/////////////////SUBRUTINA QUE SE ENCARGA DE CONVERTIR UN VALOR BINARIO A SU EQUIVALENTE ASCII////////////////
convertir: movlw 0x00 ;Checa si el respaldo bajo es cero
subwf respaldo_bajo,w
btfss status,z
goto llena ;Si no lo es comienza a llenar las memorias
goto checa_alto ;Si NO checa si el repaldo alto vale cero
checa_alto: movlw 00h
subwf respaldo_alto,w
btfss status,z
goto resta_alto ;Va a quitarle un bit al respaldo alto
return
resta_alto: decf respaldo_alto,f ;le quita un bit al respaldo bajo
goto llena
;//SUBRITINA QUE DE ENCARGA DE LLENAR LAS MEMORIAS CON ASCII DEPENDIENDO DE EL VALOR NUMERICO EN EL ARCHIVO//
llena: decf respaldo_bajo,f ;Resta uno a la parte baja
incf unidad,f ;Incremeta en uno la unidad
sigue: movlw 3ah ;¿Ya llegó a 3A?
subwf unidad,w ;Compara el valor con Unidad
btfss status,z ;¿Si es 3A?
goto checa_0 ;No, entonces checa se ya es cero la parte baja
movlw 30h ; Si es 3A, entonces pon un cero (en ASCII) a 'W'
movwf unidad ; Ese valor ponlo en unidad
incf decena,f ; E incrementa en uno decena
movlw 3Ah ;¿Ya fué 3A?
subwf decena,w ;Compara el valor con el Acumulador 'W'
btfss status,z ;¿Si es 3A?
goto checa_0 ; NO, Checa si ya fue cero la parte baja
movlw 30h ; SI Fue 3A, entonces pon un cero (en ASCII) a 'W'
movwf decena ;Pon ese cero en decena
incf centena,f ;E incrementa centena en uno
movlw 3Ah ;¿Ya fue centena 3A?
subwf centena,w ;Compara este valor con centena
btfss status,z ;¿Si Fué 3A?
goto checa_0 ;No, entonces checa si la parte baja ya fue cero
movlw 30h ; Si Fué 3A, entonces carga al acumulador el Numero Cero
movwf centena ;Pon ese valor a centena
incf Millar,f ; E incrementa en uno Millar
movlw 3Ah ;¿Ya fue Unidad_d_Millar 3A?
subwf Millar,w ;Compara este valor con Millar (3A)
btfss status,z ;¿Si Fué 3A?
goto checa_0 ;No, entonces checa si la parte baja ya fue cero
movlw 30h ; Si Fué 3A, entonces carga al acumulador el Numero Cero
movwf Millar ;Pon ese valor a Unidad_d_Millar
incf Decena_d_millar,f ; E incrementa en uno Decena_d_millar
goto checa_0 ;REGRESA, puesto que no se ocuparan mas localidades
;///////////////////////SUBRUTINA QUE SE ENCARGA DE VER SI YA ES CERO LA PARTE BAJA //////////////////////////
checa_0: movlw 0h
subwf respaldo_bajo,w
btfss status,z
goto llena
goto checa_alto
;////////////////////SUBRUTINA QUE SE ENCARGA DE GENERAR UN RETARDO DE 1 MILISEGUNDO///////////////////////////
retardo_1ms: movlw d'1'
movwf reg2
mas2: movlw d'249'
movwf reg1
mas: nop
decfsz reg1,f
goto mas
decfsz reg2,f
goto mas2
return