TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: hernanutn en 26 de Octubre de 2017, 20:39:02

Título: Usar ADC con interrupciones
Publicado por: hernanutn en 26 de Octubre de 2017, 20:39:02

Hola, mi consulta es que quiero usar el adc del pic pero con interrupciones, el pic es un 18f4553 que tiene adc de 12 bits el cual lo tengo configurado de esta manera o como deberia configurar el adc para usarlo con interrupciones ya que ante utilizaba un adc externo y andaba bien, hice la configuracion similar a lo que ante usaba pero no funciona.
El funcionamiento  es que tomo una muestra con frecuencia de 12 Khz usando un comparador CPP
 desde ya gracias

Código: [Seleccionar]

#include <18f4553.h>

#device adc=12

#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
#use delay(clock=48M)


#DEFINE USB_HID_DEVICE FALSE
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 2
#define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
#define USB_EP1_RX_SIZE   2

#include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
#include "usb_desc_scope.h"
#include <usb.c>        //libreria para el manejo del usb



int16 dato[1];
int16 dato1;
int8 k=0;
int8 flujol,flujoh,entrada[3];
int16 flujo16bits=0;
float temp=0;
float frec=0;



//#int_timer1
#int_ccp1
void CCP1(){

     
        dato1= read_adc();
        flujoh = dato1 & 0x7F;
        flujol = dato1;   
         flujo16bits = make16(flujoh,flujol);    // Creo la variable de 16 bits
        flujo16bits >>= 3;// Divido por 8
         dato[0]= flujo16bits;
       
     
       
         
         
}


     
 



void main(){



setup_timer_1(T1_INTERNAL |T1_DIV_By_4 );
setup_ccp1(CCP_COMPARE_RESET_TIMER);

setup_adc_ports(ALL_ANALOG);
setup_adc(adc_clock_internal);
set_adc_channel(1);

CCP_1=251; //Fs=12000hz


enable_interrupts(GLOBAL); //Habilita int. general


 

usb_init();                   //Inicialización del control del USB
usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado

enable_interrupts(INT_CCP1);
enable_interrupts(INT_SSP);


 
   
while(TRUE)
{
 
        // temp=(dato1*0.12207);
         // printf("%f\r",temp);
 

         usb_task();            //Detección de la conexión de dispositivo USB
      if(usb_enumerated())
             usb_put_packet(1, dato,2, USB_DTS_TOGGLE);
           
           
       
       
     
}
}

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 28 de Octubre de 2017, 15:29:19

Bueno pude solucionar el problema usando un codigo del libro de microcontroladores que tiene un ejemplo para muestrear una onda senoidal y mostrarlo en un lcd grafico y lo adapte a lo que yo necesitaba y poder mandarlo por usb. Dejo el codigo por si alguno le interesa.

Saludos..

Código: [Seleccionar]

#include <18f4553.h>



#device adc=12

//#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,PLL1,CPUDIV1,VREGEN,USBDIV,PUT
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
#use delay(clock=48M)

#DEFINE USB_HID_DEVICE FALSE
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
#define USB_EP1_TX_SIZE 2
#define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
#define USB_EP1_RX_SIZE   2

#include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
#include "usb_desc_scope.h"
#include <usb.c>        //libreria para el manejo del usb

int16 valor;


int16 dato[1];
int16 dato1;


int8 muestras[1];



#int_ad                 
void ad_int(){              //Función interrupción AD

valor=read_adc(ADC_READ_ONLY);          //Valor de fuente analógica...

ccp_2=251;        //reinicia cuenta

}
                                             
void main() {
 
   
  disable_interrupts(global);
   
  setup_adc_ports(AN0_TO_AN3);                              //Habilitación RA0 analógico
  setup_adc(ADC_CLOCK_INTERNAL);   //Reloj interno RC
  set_adc_channel(1);              //Canal 0
 
setup_ccp2(CCP_COMPARE_RESET_TIMER);     //CCP2 modo COMPARACION…
                                                                                         // y disparo especial
 setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);    //Configuración TMR1
  set_timer1(0);                           //Puesta a 0
 ccp_2=251;                              //Muestreo 12khz a 20MHz
 
 usb_init();                   //Inicialización del control del USB
 usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
  usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado
 
 
 
 
 
  enable_interrupts(INT_AD);      //Habilitación Interrupción AD
  enable_interrupts(global);           //Habilitación Interrupción global
 

do {

 
        muestras[0]=make8(valor,1);
        muestras[1]=make8(valor,0);
     
 
     usb_task();            //Detección de la conexión de dispositivo USB
      if(usb_enumerated())
             usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
         
           
       }
   while (TRUE);
}


Título: Re:Usar ADC con interrupciones
Publicado por: KILLERJC en 28 de Octubre de 2017, 16:42:26

Cambialo a:

Código: C

1. #include <18f4553.h>
2.  
3. #device adc=12
4.  
5. //#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,PLL1,CPUDIV1,VREGEN,USBDIV,PUT
6. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
7. #use delay(clock=48M)
8.  
9. #DEFINE USB_HID_DEVICE FALSE
10. #define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
11. #define USB_EP1_TX_SIZE 2
12. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
13. #define USB_EP1_RX_SIZE   2
14.  
15. #include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
16. #include "usb_desc_scope.h"
17. #include <usb.c>        //libreria para el manejo del usb
18.  
19. volatile int16 valor;
20. volatile int1 datolisto = FALSE;
21.  
22.  
23. int16 dato[1];
24. int16 dato1;
25.  
26.  
27. int8 muestras[1];
28.  
29.  
30.  
31. #int_ad                
32. void ad_int(){              //Función interrupción AD
33.  
34.   valor=read_adc(ADC_READ_ONLY);          //Valor de fuente analógica...
35.   cp_2=251;        //reinicia cuenta
36.   datolisto = TRUE;
37.  
38. }
39.                                              
40. void main(void)
41. {
42.  
43.    
44.   disable_interrupts(global);
45.    
46.   setup_adc_ports(AN0_TO_AN3);                              //Habilitación RA0 analógico
47.   setup_adc(ADC_CLOCK_INTERNAL);   //Reloj interno RC
48.   set_adc_channel(1);              //Canal 0
49.  
50.   setup_ccp2(CCP_COMPARE_RESET_TIMER);     //CCP2 modo COMPARACION…
51.                                                                                          // y disparo especial
52.   setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);    //Configuración TMR1
53.   set_timer1(0);                           //Puesta a 0
54.   ccp_2=251;                              //Muestreo 12khz a 20MHz
55.  
56.   usb_init();                   //Inicialización del control del USB
57.   usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
58.   usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado
59.  
60.   enable_interrupts(INT_AD);      //Habilitación Interrupción AD
61.   enable_interrupts(global);           //Habilitación Interrupción global
62.  
63.  
64.   while(TRUE) {
65.  
66.     if(datolisto)
67.     {
68.       muestras[0]=make8(valor,1);
69.       muestras[1]=make8(valor,0);
70.       datolisto = FALSE;
71.     }  
72.  
73.      usb_task();            //Detección de la conexión de dispositivo USB
74.       if(usb_enumerated())
75.              usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
76.   }
77. }

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 28 de Octubre de 2017, 18:05:35

Cita de: KILLERJC en 28 de Octubre de 2017, 16:42:26

Cambialo a:

Código: C

1. #include <18f4553.h>
2.  
3. #device adc=12
4.  
5. //#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,PLL1,CPUDIV1,VREGEN,USBDIV,PUT
6. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
7. #use delay(clock=48M)
8.  
9. #DEFINE USB_HID_DEVICE FALSE
10. #define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
11. #define USB_EP1_TX_SIZE 2
12. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
13. #define USB_EP1_RX_SIZE   2
14.  
15. #include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
16. #include "usb_desc_scope.h"
17. #include <usb.c>        //libreria para el manejo del usb
18.  
19. volatile int16 valor;
20. volatile int1 datolisto = FALSE;
21.  
22.  
23. int16 dato[1];
24. int16 dato1;
25.  
26.  
27. int8 muestras[1];
28.  
29.  
30.  
31. #int_ad                
32. void ad_int(){              //Función interrupción AD
33.  
34.   valor=read_adc(ADC_READ_ONLY);          //Valor de fuente analógica...
35.   cp_2=251;        //reinicia cuenta
36.   datolisto = TRUE;
37.  
38. }
39.                                              
40. void main(void)
41. {
42.  
43.    
44.   disable_interrupts(global);
45.    
46.   setup_adc_ports(AN0_TO_AN3);                              //Habilitación RA0 analógico
47.   setup_adc(ADC_CLOCK_INTERNAL);   //Reloj interno RC
48.   set_adc_channel(1);              //Canal 0
49.  
50.   setup_ccp2(CCP_COMPARE_RESET_TIMER);     //CCP2 modo COMPARACION…
51.                                                                                          // y disparo especial
52.   setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);    //Configuración TMR1
53.   set_timer1(0);                           //Puesta a 0
54.   ccp_2=251;                              //Muestreo 12khz a 20MHz
55.  
56.   usb_init();                   //Inicialización del control del USB
57.   usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
58.   usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado
59.  
60.   enable_interrupts(INT_AD);      //Habilitación Interrupción AD
61.   enable_interrupts(global);           //Habilitación Interrupción global
62.  
63.  
64.   while(TRUE) {
65.  
66.     if(datolisto)
67.     {
68.       muestras[0]=make8(valor,1);
69.       muestras[1]=make8(valor,0);
70.       datolisto = FALSE;
71.     }  
72.  
73.      usb_task();            //Detección de la conexión de dispositivo USB
74.       if(usb_enumerated())
75.              usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
76.   }
77. }

Ok, Gracias por la corrección..

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 30 de Octubre de 2017, 16:31:16

Cita de: KILLERJC en 28 de Octubre de 2017, 16:42:26

Cambialo a:

Código: C

1. #include <18f4553.h>
2.  
3. #device adc=12
4.  
5. //#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,PLL1,CPUDIV1,VREGEN,USBDIV,PUT
6. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
7. #use delay(clock=48M)
8.  
9. #DEFINE USB_HID_DEVICE FALSE
10. #define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
11. #define USB_EP1_TX_SIZE 2
12. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
13. #define USB_EP1_RX_SIZE   2
14.  
15. #include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
16. #include "usb_desc_scope.h"
17. #include <usb.c>        //libreria para el manejo del usb
18.  
19. volatile int16 valor;
20. volatile int1 datolisto = FALSE;
21.  
22.  
23. int16 dato[1];
24. int16 dato1;
25.  
26.  
27. int8 muestras[1];
28.  
29.  
30.  
31. #int_ad                
32. void ad_int(){              //Función interrupción AD
33.  
34.   valor=read_adc(ADC_READ_ONLY);          //Valor de fuente analógica...
35.   cp_2=251;        //reinicia cuenta
36.   datolisto = TRUE;
37.  
38. }
39.                                              
40. void main(void)
41. {
42.  
43.    
44.   disable_interrupts(global);
45.    
46.   setup_adc_ports(AN0_TO_AN3);                              //Habilitación RA0 analógico
47.   setup_adc(ADC_CLOCK_INTERNAL);   //Reloj interno RC
48.   set_adc_channel(1);              //Canal 0
49.  
50.   setup_ccp2(CCP_COMPARE_RESET_TIMER);     //CCP2 modo COMPARACION…
51.                                                                                          // y disparo especial
52.   setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);    //Configuración TMR1
53.   set_timer1(0);                           //Puesta a 0
54.   ccp_2=251;                              //Muestreo 12khz a 20MHz
55.  
56.   usb_init();                   //Inicialización del control del USB
57.   usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
58.   usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado
59.  
60.   enable_interrupts(INT_AD);      //Habilitación Interrupción AD
61.   enable_interrupts(global);           //Habilitación Interrupción global
62.  
63.  
64.   while(TRUE) {
65.  
66.     if(datolisto)
67.     {
68.       muestras[0]=make8(valor,1);
69.       muestras[1]=make8(valor,0);
70.       datolisto = FALSE;
71.     }  
72.  
73.      usb_task();            //Detección de la conexión de dispositivo USB
74.       if(usb_enumerated())
75.              usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
76.   }
77. }

Hola, te consulto porque cuando publique el codigo andaba pero despue manda cualquier dato(no por la modificacion del codigo), por ejemplo mido una tension de 2.5 y  en labview muestra el valor con otros valores  y si mido una tension 0.20 voltios muestra  valores constantes pero mucho mayor, lo he hecho con el pic18f4550 y 53 y hace lo mismo.
Los valores lo muestro en un display lcd(ver si hay error en la toma de datos) y da los valores correcto pero en labview hace cualquier cosa.
El programa de labview anda bien por que lo uso ademas con el pic+adc externo de 12 bits por spi.
Probe poner el adc en ciclo while y enviar los datos, y eliminando las interrupciones y hace lo mismo, no le encuentro el error.

Título: Re:Usar ADC con interrupciones
Publicado por: KILLERJC en 30 de Octubre de 2017, 21:25:32

En si odio labview xD, que cosa tan rebuscada para hacer algo.

Pero no se como es que estas intentando mostrar esos datos en Labview. Recorda que estas enviando 2 valores por USB, que luego tenes que unir para formar uno de 16 bits (seguramente multiplicar uno de ellos por 256 y luego sumarle el otro).

Entonces el primer paso seria mostrar en el Labview lo que recibis del USB. Que son valores que irian de 0 a 4096.
El proximo paso seria convertir ese numero al voltaje correspondiente.

Posibles problemas con el programa:
- Es posible de que exista algun momento que recibas cualquier cosa. Caso que puede ocurrir cuando la parte del USB tarde demasiado, pero no significaria que de alli en adelante envie cualquier cosa, sino que habra 1 dato entre varios que tenga problemas.
- Otra cosa que ahora veo, es que nunca se inicia la conversion del ADC, solo se lee el registro en la interrupcion, pero jamas se da inicio.

Para solucionar ambos, solo se inicia la lectura cuando se separa el dato.

Código: C

1. #include <18f4553.h>
2.  
3. #device adc=12
4.  
5. //#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,PLL1,CPUDIV1,VREGEN,USBDIV,PUT
6. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,PUT
7. #use delay(clock=48M)
8.  
9. #DEFINE USB_HID_DEVICE FALSE
10. #define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
11. #define USB_EP1_TX_SIZE 2
12. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
13. #define USB_EP1_RX_SIZE   2
14.  
15. #include <pic18_usb.h>//Funciones de bajo nivel(hardware) para la serie PIC 18Fxx5x que serviran en usb.c
16. #include "usb_desc_scope.h"
17. #include <usb.c>        //libreria para el manejo del usb
18.  
19. volatile int16 valor;
20. volatile int1 datolisto = FALSE;
21.  
22.  
23. int16 dato[1];
24. int16 dato1;
25.  
26.  
27. int8 muestras[1] = {0,0};
28.  
29.  
30.  
31. #int_ad                
32. void ad_int(){              //Función interrupción AD
33.  
34.   valor = read_adc(ADC_READ_ONLY);          //Valor de fuente analógica...
35.   datolisto = TRUE;
36.  
37. }
38.                                              
39. void main(void)
40. {
41.  
42.    
43.   disable_interrupts(global);
44.    
45.   setup_adc_ports(AN0_TO_AN3);                              //Habilitación RA0 analógico
46.   setup_adc(ADC_CLOCK_INTERNAL);   //Reloj interno RC
47.   set_adc_channel(1);              //Canal 0
48.  
49.   setup_ccp2(CCP_COMPARE_RESET_TIMER);     //CCP2 modo COMPARACION…
50.                                                                                          // y disparo especial
51.   setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);    //Configuración TMR1
52.   set_timer1(0);                           //Puesta a 0
53.  
54.   usb_init();                   //Inicialización del control del USB
55.   usb_task();   //Monitorea el estado de la coneccion conectandose y desconectandose automaticamente
56.   usb_wait_for_enumeration();  //espera infinitamente hasta que el dispositivo fue enumerado
57.  
58.   clear_interrupt(INT_AD);
59.   enable_interrupts(INT_AD);      //Habilitación Interrupción AD
60.   enable_interrupts(global);           //Habilitación Interrupción global
61.  
62.   read_adc(ADC_START_ONLY);       // Iniciamos conversion
63.  
64.   while(TRUE) {
65.  
66.     if(datolisto)
67.     {
68.       muestras[0]=make8(valor,1);     // Si entro aca tenemos los datos, solo falta separarlos y enviarlos
69.       muestras[1]=make8(valor,0);
70.       datolisto = FALSE;            
71.       read_adc(ADC_START_ONLY);       // Iniciamos la nueva conversion
72.     }  
73.  
74.      usb_task();            //Detección de la conexión de dispositivo USB
75.       if(usb_enumerated())
76.              usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
77.   }

En la interrupción solo se va a leer el dato del ADC y luego salir, no se va a iniciar, por eso el ADC_READ_ONLY.

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 30 de Octubre de 2017, 21:53:10

(http://www.todopic.com.ar/foros/imgtiny/14m5a1h.png)

Este uso para testear los datos.

Cuando uso el pic+adc externo con spi hago esto antes de enviar y utilizo el ese  mismo programa para testear.

Código: [Seleccionar]

datoh = spi_read(0) & 0x7F;
      datol = spi_read(0);                    // Tomo el segundo valor
        output_high(CS);                         // Finalmente apago el CS
      dato16bits = make16(flujoh,flujol);    // Creo la variable de 16 bits
      dato16bits >>= 3;// Divido por 8
tambien utilize adc_read() y hace lo mismo, pero como comente en un display lcd muestra bien lo que muestreo.
Esto lo hago para eliminar el adc externo, pero si no logro solucionarlo seguire como venia pic + adc externo.
Probare lo que me decis gracias.

Título: Re:Usar ADC con interrupciones
Publicado por: KILLERJC en 30 de Octubre de 2017, 22:08:49

Es simple (aunque tu respuesta no me da demasiados detalles)... es separar los posibles problemas. Hasta ahora tenemos:

ADC --- Transformacion de datos para USB - Envio USB - Recepcion Labview (0 a 4096) - Muestra LabView (Pasarlo a voltaje)
       |_ Transformar a ASCII - Muestra en LCD

Si decis que el programa de labview es correcto porque lo usas con el SPI + ADC externo y te funciona. Eso elimina: El envio USB, La recepcion Labview y la muestra de Labview,
Decis que Mostrandolo por el LCD se muestra correcto, entonces quiere decir que tomar del ADC funciona, transformarlo a ASCII y Mostrar en el LCD tambien esta funcionando
Y la unica que queda es la transformacion de datos para el USB.

Ponele un numero fijo. Ahi te vas a dar cuenta cual es el problema. Vas a saber si lo tenes alreves, si estas recibiendo lo correcto en el LabView, etc, si es el ADC, etc.

Código: C

1. while(TRUE) {
2.  
3.      muestras[0]=0x10;     // Si entro aca tenemos los datos, solo falta separarlos y enviarlos
4.      muestras[1]=0x01;
5.  
6.      usb_task();            //Detección de la conexión de dispositivo USB
7.       if(usb_enumerated())
8.              usb_put_packet(1, muestras,2, USB_DTS_TOGGLE);
9.   }

Respecto al Labview como te dije, no me gusta y nunca le preste atencion, solo recuerdo que un compañero para leer un dato del ADC que eran de 16bits, debia multiplicar por 256 ( que es lo mismo que rotar el valor 8 veces a la izquierda) y sumarle el byte de menor peso, de esa forma tenia su numero de 16bits armado con los 2 de 8 bits.

Ahora si vos envias ese numero fijo y recibis otra cosa, entonces en algun lado esta el problema, y me juego mas por el tratamiento en el labview que en el envio del dato.

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 31 de Octubre de 2017, 18:34:54

Bueno ahi pude solucionar el probema, primero cuando dividia en 2 bytes y los enviaba el byte   muestras[1]=(probe diferentes valores); siempre quedaba en 1 no variaba, entonces mande un dato de 16bits y en labview  la conexion para armar la variable lo tengo cruzado es lo mismo que me comentaba que multiplicaba por 256 y sumaba.
Otra cosa, el ERROR estaba tambien el hardware que uso para hacer el test porque enviando de la 2 formas que comente daba error pero al cambiarlo de placa anda el modo de enviar dato 16bits como utilizo originalmente en el proyecto con el mismo pic.

Gracias por la ayuda....

Título: Re:Usar ADC con interrupciones
Publicado por: hernanutn en 03 de Noviembre de 2017, 11:23:31

Hola, se me presento otra duda con el codigo, se puede hacer por ejemplo configurar esta parte del codigo que cuando llame a una funcion modifique los valores ante de enviar, en si mi idea es tener 2 funciones y que cuando llame alguna modificar esta parte del codigo

Código: CSS

1. #DEFINE USB_HID_DEVICE FALSE
2. #define USB_EP1_TX_ENABLE USB_ENABLE_BULK  //turn on EP1 for IN bulk/interrupt transfers  USB_ENABLE_INTERRUPT
3. #define USB_EP1_TX_SIZE 2
4. #define USB_EP1_RX_ENABLE  USB_ENABLE_BULK  //turn on EP1 for OUT bulk/interrupt transfers
5. #define USB_EP1_RX_SIZE   2

Título: Re:Usar ADC con interrupciones
Publicado por: KILLERJC en 03 de Noviembre de 2017, 14:04:57

Los define son directivas de precompilacion, por lo cual no vas a poder modificarlas a medida que se ejecuta el codigo.