ADC con pic18f4550

[kesk69]

Buenos dias,
estoy acabando ya con mi proyecto y tengo una pequña duda con el conversor A/D de mi pic.

He conseguido hacer un divisor de tension con un potenciometro y una resistencia fija y mandar una entrada de voltage variable al PIC, de esa manera he conseguido visualizar el voltage que tengo en el pin RA2 del pic.

Lo que ahora me piden los tutores del proyecto es que "haga lo mismo pero mediendo intensidad" (palabras textuales).

No se si me estan pidiendo que haga lo mismo quitando la resistencia fija y asi tener una intensidad variable en la entrada, o simplemente que divida por las resistencias y obtener el valor de la intensidad.

Hay algun metodo para poder tratar la intensidad directamente?

Gracias!

 

[Basalto]

Hola, supongo que se refiere a poder medir la intensidad que circula por un circuito.
Por lo cual tienes que colocar una resistencia de muy bajo valor en serie con el circuito y con el CAD mides que tensión cae, a partir de ahí con el valor de la resistencia conocida sacar la Intensidad. Eso es básicamente lo que hace en Amperimetro comercial.
También te aconsejo proteger el circuito con un fusible de rápida actuación, mira la referencia de algún fusible de Fluke.

 

[arrivaellobo]

También puedes hacer un arreglo con un operacional, en configuración Conversor de Corriente a tensión, y sólo te resta medir la tensión a su salida, proporcional a la corriente.
En el archivo que subo, mira la página 32.

 

[atv]

Hola, que tal! Estoy haciendo un electrocardiograma, se lo elemental de PIC y busque el datasheet el PIC18f4550. termine mi ADC pero no se si esta bien hecho y si va a funcionar. La entrada va a ser RA0 que va a provenir de una etapa de adquisicion de la señal del corazon realizada con amplificadores, despues de que la señal sea convertida a digital quiero mandarla al puero USB de la PC pero no tengo claro como hacerlo, espero me puedan ayudar!
Gracias.....el codigo es este:

;PROGRAMA PRINCIPAL


                #INCLUDE<P18F4550.INC>
                
                
                
                ORG        0
                GOTO    PRINCIPAL
                ORG        4
                GOTO    INT_ADC
                
            
    PRINCIPAL
                
                MOVLW     B'00000001' ;se activa el conversor A/D y se selecciona el canal AN0
                MOVWF    ADCON0
                MOVLW      B'00001110' ; Se habilita RA0 como entrada analogica y el resto como entradas igitales
                MOVWF    ADCON1
                MOVLW     B'00100101' ; Se justifica el resultado a la izquierda y TAD=8 y TOSC=16
                MOVWF     ADCON2

                BSF        PIE1,ADIE ; HABILITA LA INTERRUPCION DE CONVERTIDOR
                BSF        INTCON,PEIE ; HABILITA LAS INTERRUPCIONES DE PERIFERICOS Y GENERALES...
                BSF        INTCON,GIE  ; ....
                
                


    DE_NUEVO
                BSF        ADCON0,GO_DONE ; INICIO DE LA CONVERSION
                MOVLW    B'10001000' ; SE CONFIGURA EL TEMPORIZADOR 0 EN MODO DE 16 BITS
                MOVWF    T0CON
                MOVLW    0XFB    ;SE INICIALIZA EL TMR0 PARA UNA TEMPORIZACION DE 500US
                MOVWF    TMR0H    ; LEER VALOR ALTO DEL TMR0
                MOVLW    0X1E ;
                MOVWF    TMR0L ; LEER VALOR BAJO DEL TMR0
                    
                GOTO    DE_NUEVO
                
                
    CONVERSION_ADC
            WAIT    BTFSC    ADCON0,GO_DONE    ; ESPERA HASTA QUE FINALICE LA CONVERSION
                GOTO    WAIT
                MOVF    ADRESH,W                    
                MOVWF    PORTD   
                
                MOVF    ADRESL,W
                
                MOVWF    PORTD
                RETURN



                    
;...................
    INT_ADC
            BCF        PIR1,ADIF
            MOVF    ADRESH,W
            MOVWF    PORTD
            
            MOVF    ADRESL,W
            
            MOVWF    PORTC
            RETFIE


END

 

[tnxhawks]

Hola estoy desarrollando un proyecto en el cual necesito leer 2 canales de ADC, estoy utilizando el Pic18f4550 y Mplab, el problema es que primero lo configure para el canal 0 osea RA0, y funciono a la perfección, pero cuando quise configurarlo para el canal 1 osea RA1 no funciono, hasta el momento no he trabajado con ambos al mismo tiempo, he intentado utilizar cada uno independientemente pero no me ha resultado el canal 1. Les dejo mi código esperando que me puedan ayudar, Gracias y animo con ese foro tan completo.

/******************************* Archivos de cabecera ***************************/
#include <p18f4550.h>
#include <delays.h>
/**************************** Bits de configuracion *****************************/
#pragma config PLLDIV   = 5
#pragma config CPUDIV   = OSC1_PLL2	
#pragma config USBDIV   = 2         
#pragma config FOSC     = HSPLL_HS
#pragma config LVP      = OFF
#pragma config WDT      = OFF
#pragma config PWRT     = OFF
#pragma config MCLRE    = ON
#pragma config VREGEN   = ON
#pragma config BOR      = ON
#pragma config BORV     = 3
#pragma config CCP2MX   = ON
#pragma config STVREN   = ON
#pragma config WRTB     = ON
#pragma config FCMEN    = OFF
#pragma config IESO     = OFF
#pragma config WDTPS    = 32768
#pragma config LPT1OSC  = OFF
#pragma config PBADEN   = OFF
#pragma config ICPRT    = OFF       
#pragma config XINST    = OFF       
#pragma config CP0      = OFF
#pragma config CP1      = OFF
#pragma config CP2      = OFF
#pragma config CP3      = OFF
#pragma config CPB      = OFF
#pragma config CPD      = OFF
#pragma config WRT0     = OFF
#pragma config WRT1     = OFF
#pragma config WRT2     = OFF
#pragma config WRT3     = OFF       
#pragma config WRTC     = OFF
#pragma config WRTD     = OFF
#pragma config EBTR0    = OFF
#pragma config EBTR1    = OFF
#pragma config EBTR2    = OFF
#pragma config EBTR3    = OFF
#pragma config EBTRB    = OFF

/************************ Variables y redefiniciones ****************************/
#define			byteAlto	209
#define			byteBajo	32
#define 		SALIDA		LATCbits.LATC1
unsigned char 	Ticks 		= 0;
unsigned char 	sendata		= 0;
unsigned char 	flag 		= 0;
unsigned char 	flag2 		= 0;
int 			contador 	= 0;
int 			i			= 0;
long 			m1			= 0x01;
long 			mascara		= 0;
char			opcion		= 1;
unsigned int 	valorADC;
unsigned int 	valorADC2;
unsigned int 	reduccion;

/****************************** Prototipos de funcion ********************************/
void miInterrupcionAlta(void);
void inicializar(void);
void configurar_TMR0(void);
void inicializar_ADC(void);
int obtener_ADC(void);
int obtener_ADC2(void);

/***************************** Remapeo ******************************************/

#pragma code alto = 0x08
void alto(void)
{
	_asm goto miInterrupcionAlta _endasm
}
#pragma code

#pragma interrupt miInterrupcionAlta
void miInterrupcionAlta(void)
{
	if((INTCONbits.T0IE && INTCONbits.T0IF) == 1)
	{
		TMR0L = byteBajo;
		TMR0H = byteAlto;
		INTCONbits.T0IF = 0;
		//SALIDA ^= 1;
		Ticks ++;
	}

}
/******************************* Programa principal **********************************/
void main(void)
{
	inicializar();
	while(1)
	{	
		//if(opcion)
		//{
			obtener_ADC2();
			reduccion=(valorADC2/16);
		/*}
		else 
		{
			obtener_ADC2();
			reduccion=(valorADC2/16);
		}*/
		opcion^=1;
		sendata=reduccion;
		while (contador<10)
		{
			SALIDA=1;
			Delay10TCYx(180);
			Delay10TCYx(180);
			SALIDA=0;
			Delay10TCYx(180);
			Delay10TCYx(180);
			contador ++;	
		}
		contador=0;
		//Empieza a mandar datos
		SALIDA=1;
		Delay100TCYx(240);	//Retardo de 2ms
		SALIDA=0;
		Delay100TCYx(240);
		
	for(i=0;i<=7;i++)      
   	 {
   		mascara=sendata&m1;    //compara bit por bit del con una mascara m1para enviar

   		if(mascara)      //si el resultado de la and es 1:
   			{
      			SALIDA=1;
      			Delay100TCYx(120);
      			SALIDA=0;
      			Delay100TCYx(120);
  			 }   // termina if para valor de and =1
 
   		else      // si resultado de and=0:
    		{  
				SALIDA=0;
      			Delay100TCYx(120);
      			SALIDA=1;
      			Delay100TCYx(120);
   			}  
   
   		m1=m1*2;
    }
    SALIDA=0;
  	//Delay1KTCYx (240);
	//Delay1KTCYx (240);
	//Delay1KTCYx (240);
    m1=0x01;   

	}
}
/************************ Prototipos de funcion, definiciones ************************/
void inicializar(void)
{
	TRISCbits.TRISC1 = 0;
	TRISAbits.TRISA0 = 1;
	TRISAbits.TRISA1 = 1;
	TRISB = 0X0F;
	configurar_TMR0();
	inicializar_ADC();
}
void configurar_TMR0(void)
{
	INTCON = 0b10100000;
	TMR0L = byteBajo;
	TMR0H = byteAlto;
	T0CON = 0b10000000;
}
void inicializar_ADC(void)
 {
 	ADCON2=0X8E;
	ADCON1=0B00001101;
	ADCON0=0B00001001;
 }
int obtener_ADC(void)
 {
	ADCON0=0B00000001;
	Nop();
	Nop();
 	ADCON0bits.GO=1;
	while(ADCON0bits.GO);
	valorADC=(int)(ADRESH*256) + ADRESL; 
    	return valorADC;
 }
int obtener_ADC2(void)
 {
	ADCON0=0B00001001;
	Nop();
	Nop();	
 	ADCON0bits.GO=1;
	while(ADCON0bits.GO);
	valorADC2=(int)(ADRESH*256) + ADRESL; 
    	return valorADC2;
 }

Lo he probado fisicamente y el funcionamiento de este programa, es para mandar un dato serial que corresponde a el valor obtenido de la señal del adc.Gracias de verdad