pic 16F877 con interfaz RS-232 para LABVIEW

[alexlarrain]

Buenas amigos. Soy un estudiante de Ing. Electronica.

En mi proyecto de titulo tendre que usar la comunicacion RS-232 con un pic 16F877. Y tengo que realizar una interfaz usando LabView... ya que tengo que controlar la temperatura de una planta academica , necesito saber como cambia la temperatura .Lo que quiero saber es como comunicar el PIC para que muestre en el Labview la temperatura que a este le llega desde la planta. Si tienen alguna información con la que me puedan ayudar se los agradeceria mucho.

 

[migueljbravo]

que tal, te recomiendo visites la pag web www.roso-control.com ahi hay uno q otro proyecto del pic 16f876 con labview... yo todavia no manejo labview con el pic, pero creo q es una funcion de comunicacion serial...

 

[shougo]

Asumiré que de alguna forma (ya sea por ADC o algún periférico) ya tienes el dato de temperatura en el PIC. Lo que debes hacer es utilizar el módulo USART del PIC que para comunicación serie asíncrona. En las notas de aplicación de microchip o en el datasheet del micro salen los registros de configuración

La comunicación entre el PIC y la PC la puedes hacer con un MAX232 siempre y cuando la distancia entre el PIC y la PC no sea mayor a 15 metros.

Con respecto a LabView, puedes utilizar las cajitas de serial VISA, son muy sencillas de usar. Estoy casi seguro que en las notas de aplicación de National Instruments www.ni.com habrán ejemplos al respecto

Saludos

PS si lo que deseas es "controlar" la temperatura. las mismas señales de control las puedes generar con el mismo PIC

 

[Jrkike]

Buenas amigos. Soy un estudiante

Tengo un laboratorio que debe usar la comunicacion RS-232 con un pic 16F877. Y tengo que realizar una interfaz usando LabView... Lo que quiero saber es como comunicar el PIC para que muestre en el Labview ademas como realizar la converaion de Db9 a Usb. Si tienen alguna información con la que me puedan ayudar se los agradeceria mucho.

 

[coco1986]

Bueno yo estoy un poco familiarizado con eso lo que te recomiendo es usar una interfaz MAX232, con respecto alo de db9 a USB yo que se no se puede pero si puedes manejar información mediante el USB y aparte con el puerto serial y a su vez controlarlo con el PIC. Aqui te dejo la conexion de max232 hacia el db9 y hacia el PIC, cualquier duda me lo haces saber; tambien te puedo proporcionar lo del uso USB.

 

[cripty]

hola amigos, yo tengo un problema algo similar, mi laptop solo tiene puertos usb y deseo comunicarme con un pic de modo serial, utilizo para eso un cable conversor que tiene un instalador y crea un puerto com virtual; pero el labview no lo reconoce por nada, para el no existen puertos seriales. como arreglaria ese problema????

 

[yojoey]

requiero algo similar captar los pulsos de un encoder o de uno de fotoceldas pero
necesito un captador de pulsos, con interface a pc con salida rs232 o db9, rs485,
les agradesco mucho.

 

[samm]

hola soy nuevo en labview, apenas stoy comenzando ya e buscado informacion acerca del puerto serial db-25 y encontre el significado de cada pin. mi pregunta como puedo mandar mis bits de salida de un adc0804 a mi pc atraves del puerto db-25.????
si segun los pines de datos del db-25 son solo de salida????
agradeceria mucho si porfavor me pudiera ayudar alguien???.
lo que quiero hacer es un termometro con ayuda del adc0804 y un sensor de temperatura lm35

 

[marwuin]

Saludos estimados compañeros del foro.


Resulta que tengo un PIC 16F877 el cual programo con PROTO IDE a travez del puerto USB, para la comunicacion utilizo el integrado FT232R, todo anda perfectamente, ya he corrido varias aplicaciones.

Resulta que necesito ayuda para generar un codigo para comunicar este PIC con LabView... Si tiene alguna informacion que me sea de utilidad seria de gran ayuda. Gracias de antemano por la ayuda.

 

[marwuin]

Problema solucionado.

 

[neoakira]

Hola a todos.
Estoy realizando un proyecto final de carrera y realizo una simulacion de la red electrica con un generador de funciones, 50hz y 2Vpp, el pic16f690 lee datos en el momento que el labview no esta ejecutado y los almacena en una memoria 24aa1025 y despues enviarlos por puerto serie, tambien realiza mientras esta activado enviarlos directamente, pero cuando los recibe el labview me lee algunos valores seguidos de caracteres y su representacion en grafica no semeja a ninguna señal senoidal. Si hubiese alguien que me ayudara estaria muy agradecido.

Os dejo el programa en CCS y en labview.

****************************************************************
                                                    Principal
****************************************************************
#include <Memoexterna.h>
#include <24AA1025.c>

int16 address=0;
int16 adc_value;
int contador, recive, count; 
//int h, j;

void main()
{

   setup_adc_ports(sAN9|VSS_VDD);
   setup_adc(ADC_CLOCK_INTERNAL);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
//Setup_Oscillator parameter not selected from Intr Oscillator Config tab

   // TODO: USER CODE!!
contador=0;
   while(true==1)
   {  
      recive=getc();
      if(recive=='1')
      {
         count=0;
         for(count=0;count<contador;count++)
         {  
            adc_value=read_eeprom_external(address);
            printf("\n%4ld", adc_value);
         }  
         while(recive=='1')
         {
            set_adc_channel(9); //canal AN0 para la Tension de la fase 1
            delay_us(10);
            adc_value=read_adc(); // mide la Tension de la fase 1
            printf("\n%4ld", adc_value);
         }
         contador=0;
         address=0;
      }
      if(recive=='0')
      {
         set_adc_channel(9); //canal AN0 para la Tension de la fase 1
         delay_us(10);
         adc_value=read_adc(); // mide la Tension de la fase 1
         write_eeprom_external(address, adc_value);
         address++;
         contador++;
      }
      
   }  
}

****************************************************************
24AA1025.c
****************************************************************


#define Wrmm 0xA0        //Slave address 24AA1025 in Write
#define Rrmm 0xA1        //Slave address 24AA1025 in Read

void write_eeprom_external(long int address,int16 value)
{
   int lo_value,hi_value,i;
   int start=0;
   int go=0;
   
   lo_value=make8(value,0);
   hi_value=make8(value,1);
   for(i=0;i<1;i++)
   {
      i2c_start(); 
      i2c_write(Wrmm);            // WR to Memory Eeprom 
      i2c_write(address>>8);      
      i2c_write(address);         
      if((start==0)&&(go==0))
      {
         i2c_write(lo_value);
         start=1;
      }
      if((start==1)&&(go==1))
      {
         i2c_write(hi_value); 
         start=0;
      }
      if((start==1)&&(go==0))
      {
         go=1;
      }
      if((start==0)&&(go==1))
      {
         go=0;
      }
      i2c_stop();
      address++;
   }      
}    
    
int read_eeprom_external(long int address) 
{
   int lo_value,hi_value,i;
   int start=0;
   int go=0;
   int16 value;
   
   for(i=0;i<1;i++)
   {
      i2c_start(); 
      i2c_write(Wrmm);           // WR to Memory Eeprom  
      i2c_write(address>>8);       
      i2c_write(address);         
      i2c_start(); 
      i2c_write(Rrmm);           // WR to Memory Eeprom
      if((start==0)&&(go==0))
      {
         lo_value=i2c_read(0);
         start=1;
      }
      if((start==1)&&(go==1))
      {
         hi_value=i2c_read(0); 
         start=0;
      }
      if((start==1)&&(go==0))
      {
         go=1;
      }
      if((start==0)&&(go==1))
      {
         go=0;
      }
      i2c_stop();
      address++;
      
   }
      
   value=make16(hi_value,lo_value);
   return (value);
}

void write_memory_external_eeprom(long int address, BYTE value)
{
   short int status;
 
   i2c_start(); 
   i2c_write(Wrmm);           // WR to Memory Eeprom 
   i2c_write(address>>8);       
   i2c_write(address);         
   i2c_write(value);           
   i2c_stop(); 
   i2c_start(); 
   status=i2c_write(0xa0);
   while(status==1)
   {
      i2c_start(); 
      status=i2c_write(0xa0);
   }
}  

BYTE read_memory_external_eeprom(long int address)
{
   BYTE value;
   i2c_start(); 
   i2c_write(Wrmm);           // WR to Memory Eeprom  
   i2c_write(address>>8);      // REG 0 
   i2c_write(address);         // REG 0 
   i2c_start(); 
   i2c_write(Rrmm);           // WR to Memory Eeprom  
   value=i2c_read(0);
   i2c_stop(); 
   return (value);
}

void write_int16_ext_eeprom(long int address,long int value)
{
   int i;
   for(i=0; i<2; i++)  
   {
      write_memory_external_eeprom(i+address,*((int8*)(&value)+i)); 
   }
}

int16 read_int16_ext_eeprom(long int address)
{
   int i;
   float value;
   for(i=0; i<2; i++)  
   {
      *((int8*)(&value)+i)=read_memory_external_eeprom(i+address);
      return(value);
   }
}

void write_float_ext_eeprom(long int address,float value)
{
   int i;
   for(i=0; i<4; i++)  
   {
      write_memory_external_eeprom(i+address,*((int8*)(&value)+i)); 
   }
}

float read_float_ext_eeprom(long int address)
{
   int i;
   float value;
   for(i=0; i<4; i++)  
   {
      *((int8*)(&value)+i)=read_memory_external_eeprom(i+address);
      return(value);
   }
}

 

[jimmyneutron]

Este programa genera unas señales seno, cuadrada y sierra con un pic16f877, este contiene el circuito simulado en proteus, el codigo compilado y sin compilar. Es un proyecto que se les solicita a muchos estudiantes de electirica y electronica.
Espero les sirva de mucha ayuda.

 

[darktiger]

Saludos Amigos.. Buen dia para todos.. Necesito su ayuda.. Soy estudiante de Ingenieria de Sistemas en Venezuela, me han pedido realizar una aplicacion en Labview, pero nunca en mi vida habia trabajdo con este software y pues, toy totalmente nuevo, he aprendido mediante los foros, leyendo, investigando, leyendo manuales, puesto que no tengo un profesor que me enseñe..

Bueno, la aplicacion consiste en recibir las señales de un PLC's Basado en Control Logic, esta señal sera de entrada de petroleo o de gas en una planta especifica, y pues me pide que le establezca unos parametros, de convergencia, fiscalizacion y sin convergencia y si solo quiero evaluar el crudo o el gas o ambos, ademas me tiene que arrojar un aviso en caso que de los resultados esten por encima de los parametros establecidos, es decir los limites de producción o en su defecto los normales, tambien cuando finalize la prueba y la comunicacion con el Hardware, es decir el PL'Cs.. Ya todo eso lo hice, incluyendo la interfaz Grafica, pero estoy parado por unas cositas, las cuales son donde necesito su ayuda.. Tengo que establecer un tiempo de Muestreo para la prueba, este tiempo debe estar en Segundos (Seg.) y el tiempo de duracion de la Prueba la cual debe estar en Horas(Hrs.) Así como estabecer un indicador donde me muestre la Hora y la Fecha en que inicio y termino la prueba unicamente.. No que siga corriendo como un relog, ya eso lo puse.. Tal vez para muchos de ustedes les resulte una pollada de mi parte.. Jeje.. Pero como dije soy complemente nuevo en esto y pues he visto que aqui ayudan mucho..

Espero me puedan ayudar.. Saludos a todos....!!

 

[beto Salda]

Hola que tal amigo mira estoy trabajando en un proyecto similar ve el ejemplo en labVIEW llamado "advanced serial write and read.vi" que es un ejemplo de comunicacion serial funciona muy bien ahi vas a ver las funciones para configurara el puerto y los pasos para hacer la comunicacion que son abrir puerto escribir en puerto y al final de cada lectura ó escritura debes cerrar el puerto este ejemplo que te digo te puede ayudar mucho para la comunicacion serial con labVIEW, ahora par el pic bueno yo programo hasta el momento con ensamblador y tienes que configurar el UART que son el TXSTA (Transmicion) yo escribo la palabra 24h para habilitarla, tambien necesitas configurar el baudaje que lo común son 9600 baudios que es la palabra 19h y por último en el banco cero esta la recepcion llamada RCSTA qye para habilitar los puertos recepcion continua y todo eso (el manual del pic te ayudara a saber el porque estas palabras )yo escribo aqui la palabra 90h y listo ya esta configurado tu pic para comunicacion serial cuando quieras transmitir un dato solo escribelo en el TXREG y es el valor que saldra por el RC6/TX si mas no recuerdo y el dato enviado por la PC lo vas a recibir en el RCREG del pic, es importante que uses el max 232 como ya te habian mencionado mis compañeros del foro, ahora tienes que activar un canal analogo digital y hacer tu termometro el lm35 te entrega 10mV /ºC y el pic tiene una resolucion de 48mV por bit ó sea puedes tener una resolucon minima de 4.8 ºC has la conversion de temperatura y almacena las unidades decenas etc en localicades de memoria del pic y una vez hecha la conversion haz una subrutina que te lea digamos tu registro donde esta la decena y lo escriba al TXREG luego lea la unidad y la mande al TXREG en dado caso que digamos sean 24ºC que solo ocupes 2 bytes a mi me ayudo comenzar con ejemplos sencillos escribir un dato en lab VIEW digamos el 5 y me lo muestre en el puerto D del pic que seria un 35 en hexadecimal. no se vallas a utilizar un ventilador y un calentador para en control pero si digamos estas leyendo la temperatura actual y son 24º y quieres 30 entonces 24 esmenor que 30 sacas un dato por lab view puede ser una letra o cualquier caracter digamos el caracter mas "+" y si quieres 15º pues 15 es menor que la temperatura actual entonces mandas el caracter menos "-" checa su codigo ASCII en hexadecimal para que hagas un control donde leas el puerto serial del pic y digas recibio menos "no" recibio mas "SI" entonces puedes usar un bit set file "bsf" en el puerto no sé D de tal manerera que ese bit te active un relevador ó un moc y triac para que aumente la temperatura asi aumenta y la estas manando al lab VIEW hasta que llegue al valor deseado ya si quieres enfriar solo apagas ese bit "bcf portd,1"(por ejemplo) y enciendes el ventilador bsf portd,0 (digamos que usas el puerto d como control para las cargas) te iba enviar un programa con pic pero aun no le se bien al foro no puedo adjuntar archivos me aparece como inválidos espero y esto te haya podido ayudar saludos.

 

[akiva]

Es cierto ese programa es bueno agradeceria el .asm ya que estudio electronica .Exitos

Es cierto ese programa es bueno agradeceria el .asm ya que estudio electronica .Exitos

Respuesta: pic 16F877 como generador de señales

--------------------------------------------------------------------------------
Este programa genera unas señales seno, cuadrada y sierra con un pic16f877, este contiene el circuito simulado en proteus, el codigo compilado y sin compilar. Es un proyecto que se les solicita a muchos estudiantes de electirica y electronica.
Espero les sirva de mucha ayuda.

 

[beto Salda]

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

 

[AERO1987]

saludos beta salda...comentart que estuve leyendo el post que pusiste y me parece interesante..largo pero preciso, y hubiera sido tambien bienvenido una ayuda un poco + detallada en cuanto a como realizar la comunicación con el labview...comentarte que estoy realizando un trabajjo de grado en cual tengo que monitorear la temperatura de tres sensores y estos datos deben ser enviados a la pc a través del usart del pic 16f877a, la interfaz que pretendo usar para la visualización de los datos es el labview, pero es en esta parte en la que estoy tropezando ya que soy muy novato en el uso de esta aplicacion. Como te decia el trabajo trata de monitorear el estado de tres sensores de temperatura y la idea es mostrar estos datos en una misma pantalla, en tres graficos de temperatura de los que tiene el labview y qisiera pedirles un ayuda de como hacer esto, osea separar los datos enviados por el pic y mostrarlos en distintas graficas (sensor1 = grafico1, sensor2=grafico2, sensor3=grafico3 y asi sucesivamente)......esperando tu pronta reespuesta saludos...

 

[hijase]

Este programa genera unas señales seno, cuadrada y sierra con un pic16f877, este contiene el circuito simulado en proteus, el codigo compilado y sin compilar. Es un proyecto que se les solicita a muchos estudiantes de electirica y electronica.
Espero les sirva de mucha ayuda.

Muy buen aporte Jimmy !!
Gracias por compartirlo, quisiera trabajarlo con valores más pequeños de frecuencia
por debajo de 1KHz que es tu valor mínimo ojala puedas ayudarme si me atoro en algo
pero tu muy bien

 

[mikromax]

9Amigos:

quizas este cerrado este tema, pero tengo el siguiente problema.
con un pic 16F873A estoy leyendo 2 señales analogicas provenientes de 20amplificadores de instrumentacion usados para amplificar la señal de 2 celdas de carga.
La salida del Amplif instr esta conectadas a las patas ADC del PIC y luego usando un MAX232 conecto ese proyectyo a una PC con Labview.

El pic esta configurado para convertir las señales analogicas y enviar la conversion por UART a la pc. El labview levanta esos datos y los traduce a peso.

Simulando todo el proyecto con proteus y labview la conversion es perfecta. no hay perdida de bits en la comunicacion.

ahora cuando utilizo el sistema de celdas+amplif de instru+pic+max232+labview al leer los datos con hyperterminal veo que la señal convertida por el pic oscila entre +- 20 bits. Es decir si la conversion ADC deberia ser 128 bits , con simulacion en proteus y viendo los datos recibidos por hyperterminal recibo los 128+-1 bit. Ahora cuando energizo el sistema pic+max232 la lectura con el hyperterminal de los datos enviados por el pic correspondientes a la conversion tienen un error de +-20 bits.

La complicacion surge cuando al medir la calidad de la señal de 0-5v provenientes de la placa amplificadora de la señal de las celdas, esta medicion es muy estable incluso medida en los bornes previos a las patas ADC del PIC. Pero si tomamos los datos enviados por el pic al puerto seria como si la señal analogica variara en +-5% del valor original lo cual es imposible ya que el peso colocado sobre las pesas esta fijo.

Alguna sugerencia en cuanto al armado de la placa del pic con el 232.

Adicional quiero comentar que en una misma placa estan conectados los bornes para conectar las señales analogicas, esta alojado el MAX232, el pic. Es recomendable esta configuracion?
Estoy seguro que es ruido pero de que forma podria mejorarlo??