Autor Tema: Múltiples SRF04  (Leído 769 veces)

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

Desconectado mariacontenis

  • PIC16
  • ***
  • Mensajes: 114
Múltiples SRF04
« en: 16 de Febrero de 2023, 04:37:35 »
Por favor, requiero de su ayuda para este tema.

Tengo un sensor de distancia por ultrasonido el SRF-04 funcionando con el siguiente codigo..

Código: C++
  1. #include <18f4550.h>                                                          // #include <18f4550.h>                              
  2.          #fuses XT,NOWDT,PUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT,NOPROTECT
  3.          #use delay(clock=4000000, crystal=4000000)  
  4.          #byte PORTA=0xf80 #byte TRISA=0xf92 #byte PORTB=0xf81 #byte TRISB=0xF93 #byte PORTC=0xf82 #byte TRISC=0xF94 #byte PORTD=0xf83 #byte TRISD=0xF95 #byte PORTE=0xf84 #byte TRISE=0xF96
  5.          //#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, parity=N, bits=8, stop=1, stream=HYPERTERMINAL, ERRORS)
  6.          #ignore_warnings 216,230
  7.          #include <lcd4x20.c>
  8.  
  9.          #define BIT_TEST_ON     output_high(PIN_C0)
  10.          #define BIT_TEST_OFF    output_low(PIN_C0)
  11.  
  12.          void pulso_test(void);                                                       // da pulso y calcula distancia al obstáculo
  13.  
  14.          int1 nuevopulso=0;                                                            // Entra otro pulso de lectura
  15.          int16 TFB=0,TFS=0,TF=0;                                                       // Tiempo flancos
  16.          float AP=0.0;                                                                 // Valor del pulso del obstáculo en microsegundos
  17.          float distancia=0;                                                            // Valor distancia al obstáculo
  18.          int1 cambio=0;                                                                // Control flanco subida o bajada del impulso leido
  19.  
  20.          void pulso_test(){
  21.          enable_interrupts(INT_CCP2);                                                  // Habilitación interrupción para medida de pulso eco
  22.          delay_us(10);
  23.          BIT_TEST_ON;                                                                  // salida de pulso test durante 10us por Bit 0 puerto C
  24.          delay_us(10);                
  25.          BIT_TEST_OFF;
  26.          while(nuevopulso==0)                                                          // Espera a finalizar el pulso eco
  27.          {}
  28.          if(nuevopulso==1){                                                            // Finalizado el pulso eco se calcula su valor.      
  29.          TF=(TFB-TFS);                                                                 // Valor entre pulso de subida y bajada.
  30.          AP=TF*1.0;                                                                    // Valor pulso leido en us(obstáculo) de 100u a 25ms
  31.          AP = AP/58;                                                                   // Distancia del obstáculo en cm
  32.          distancia = AP;                                                               // paso de flotante a entero largo
  33.          nuevopulso=0;                                                                 // Listo para recibir nuevo pulso
  34.          }
  35.          disable_interrupts(INT_CCP2);
  36.          }          
  37.  
  38.          #int_ccp2                                                                     // LLamada por interrupción flanco en RC2
  39.          void ccp2_int(){
  40.          if(cambio==0)                                                                 // Si es flanco de subida...
  41.          {
  42.          TFS=CCP_2;                                                                    // Carga  en valor flanco subida valor registro ccpr1
  43.          setup_ccp2(CCP_CAPTURE_FE);                                                   // Configuración modo captura en flanco de bajada
  44.          cambio=1;                                                                     // Próximo flanco debe ser de bajada
  45.          }
  46.          else {                                                                        // Si es flanco de bajada...    
  47.          TFB=CCP_2;                                                                    // Carga  en valor flanco bajada valor registro ccpr1
  48.          setup_ccp2(CCP_CAPTURE_RE);                                                   // Configuración modo captura en flanco de subida
  49.          cambio=0;                                                                     // Próximo flanco debe ser de subida
  50.          if(nuevopulso==0)                                                             // Fin de pulso...
  51.          nuevopulso=1;                                                                 // Pulso finalizado.
  52.          }
  53.          }        
  54.    
  55.          void main(){
  56.          lcd_init();
  57.          porta=0x00; set_tris_a(0b00000000); portb=0x00; set_tris_b(0b00000000); portc=0x00; set_tris_c(0b00000010); portd=0x00; set_tris_d(0b00000000); porte=0x00; set_tris_e(0b00001000);
  58.          port_b_pullups(true);
  59.          
  60.          setup_timer_1(T1_INTERNAL);                                                   // Configuración timer1 para lectura obstáculo
  61.          setup_ccp2(CCP_CAPTURE_RE);                                                   // Configuración modo captura en flanco de subida
  62.          disable_interrupts(INT_TIMER1);
  63.          disable_interrupts(INT_CCP2);                                                 // Deshabilitación interrupción modo comparación
  64.          enable_interrupts (GLOBAL);        
  65.          delay_ms(100);                                                                // Estabilización en el arranque del sistema
  66.          
  67.          while(TRUE)
  68.          {
  69.          pulso_test();  
  70.          lcd_gotoxy(3,2); printf(lcd_putc,"Dist: %f cm  ",distancia);
  71.          }
  72.          }


Ahora requiero poner 3 sensores de ultrasonido (es decir 2 srf-04 más) y me preguntaba si me podrían orientar en como lograrlo. Gracias por leer y por ayudarme.


Desconectado DominusDRR

  • PIC24H
  • ******
  • Mensajes: 1937
    • Sicoy
Re:Múltiples SRF04
« Respuesta #1 en: 16 de Febrero de 2023, 10:21:09 »
El problema sería debido a que sólo tienes dos ccp y necesitarías unos más para el tercer sensor.

Si los tres sensores no funcionan al mismo tiempo, podrías usar una compuerta OR o usar tres diodos para crear una OR, similar al esquemático de la izquierda de la siguiente imagen.



A las entradas de las OR irían los sensores y en la salida (A+B +C) se conectarían a CCP2.

Ahora bien, cuando cualquiera de los sensores cambien de o a 1 lógico, producirán la interrupción. Dentro de la interrupción deberás determinar cual de los 3 fueron, esto implica que los sensores también deben conectarse cada uno a un terminal o pin GPIO del microcontrolador.

Como dije antes sólo sería útil si los sensores no funcionan al mismo tiempo.

Tengo una idea algo difusa sobre MPLAB Harmony, XC32 con PIC32

Desconectado Ruco

  • PIC12
  • **
  • Mensajes: 62
Re:Múltiples SRF04
« Respuesta #2 en: 16 de Febrero de 2023, 11:48:18 »
Creo que ese pic solo tiene 2 módulos ccp. Pero habrá alguna manera de hacerlo funcionar un ccp para los 3 sensores. Aunque tampoco no se cómo hacerlo.  :(
« Última modificación: 16 de Febrero de 2023, 11:50:44 por Ruco »

Desconectado Eduardo2

  • PIC24F
  • *****
  • Mensajes: 965
Re:Múltiples SRF04
« Respuesta #3 en: 16 de Febrero de 2023, 12:42:21 »
El 18F4550 tiene 2 CCP,  luego te falta uno --> Podrías usar las interrupciones externas.

Como el sonido se propaga a 330m/s , con un retraso para atender la interrupcion y leer el contador como 10us el error es de 3.3mm. Que es del orden del supuesto error propio del SFR04. 

Si ese orden de error no te afecta podrías usar mas sensores todavía.

Desconectado mariacontenis

  • PIC16
  • ***
  • Mensajes: 114
Re:Múltiples SRF04
« Respuesta #4 en: 17 de Febrero de 2023, 20:50:06 »
Disculpa mi ignorancia Eduardo2 cómo sería eso que me comentas en código?.

Por favor podrías poner aunque sea un poco de ello?.

Desconectado Eduardo2

  • PIC24F
  • *****
  • Mensajes: 965
Re:Múltiples SRF04
« Respuesta #5 en: 18 de Febrero de 2023, 02:54:19 »
Disculpa mi ignorancia Eduardo2 cómo sería eso que me comentas en código?.

Para poner algo del mismo estilo que habías escrito:
Código: [Seleccionar]
int16 Tiempo0;
int1  T0ok=false;

#INT_EXT
void  EXT_isr(void) {
    int16 t = get_timer1() ;
     
    if(bit_test(INTCON2,6)){           // Rising edge ?
        Tiempo0 = t ;
        ext_int_edge(0, H_TO_L);   
    }
    else{                              // Falling edge ?
        Tiempo0 = t-Tiempo0 ;
        T0ok = true ;
    }
}

Es similar a lo que hacías antes, pero la gran diferencia es que mientras CCP te copia el timer1 al instante, acá hay que esperar hasta que se atienda la interrupción.

Pero ojo, no sé que tendrás en mente, pero la solución satisfactoria depende de si los emisores se activan de a uno o simultáneamente.




Desconectado Ruco

  • PIC12
  • **
  • Mensajes: 62
Re:Múltiples SRF04
« Respuesta #6 en: 23 de Febrero de 2023, 15:26:06 »
Hola, yo quiero hacer esto... Mi idea era hacer un robot evita obstáculos como el que enuncio en la siguiente pagina: http://robotypic.blogspot.com/2010/09/proyecto-de-robot-que-evita-obstaculos.html

y el video es el siguiente:

Sin embargo este código original esta realizado en un pic16F876A y yo lo estoy compilando con un pic18f4620. Pero arme todo físicamente y no funciona.

Pongo el código original:

Código: C#
  1. #include <16F876A.h>
  2.  
  3. #FUSES NOWDT              
  4. #fuses XT                  //Oscilador por cristal entre 4Mhz y 10Mhz                
  5. #fuses NOPROTECT
  6.  
  7. #use delay(clock=4000000)  //Frecuencia del cristal oscilador 4MHz
  8. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
  9.  
  10. #priority rtcc
  11.  
  12. #byte PIR1=0x0C
  13.  
  14. #byte trisa=0x85
  15. #byte porta=0x05
  16. #byte trisb=0x86
  17. #byte portb=0x06
  18. #byte trisc=0x87
  19. #byte portc=0x07
  20.  
  21. #define BIT_TEST_ON     output_high(PIN_C0)
  22. #define BIT_TEST_OFF    output_low(PIN_C0)
  23. #define AVANCE          output_high(PIN_C2),output_high(PIN_C4),output_low(PIN_C3),output_low(PIN_C5)
  24. #define RETROCESO       output_low(PIN_C2),output_low(PIN_C4),output_high(PIN_C3),output_high(PIN_C5)
  25. #define PARO            output_low(PIN_C2),output_low(PIN_C4),output_low(PIN_C3),output_low(PIN_C5)
  26. #define GIRO_DERECHA    output_high(PIN_C2),output_low(PIN_C4),output_low(PIN_C3),output_high(PIN_C5)
  27. #define GIRO_IZQUIERDA  output_low(PIN_C2),output_high(PIN_C4),output_high(PIN_C3),output_low(PIN_C5)
  28.  
  29. #bit  Bit_PWM =  PORTB.7     //Bit 7 puerto B Salida modulación 1
  30.  
  31. /********************** Prototipos de las funciones ***************************/
  32.  
  33. void main (void);             //función principal
  34. void Generacion_pwm (void);   //genera señales moduladas para control de servos
  35. void pulso_test (void);       //da pulso y calcula distancia al obstáculo
  36. void ccp2_int (void);         //mide pulso de eco ultrasonidos
  37. void navegacion (void);       //avance sorteando obstáculos
  38.  
  39. /********************** Variables para generación PWM *************************/
  40.  
  41. int8 PWM=0;          //Guardará los valores de la señal PWM
  42. int8 Pulso_pwm=0;    //Ancho del pulso de control del servo
  43.  
  44. /******************** Variables para lectura obstáculo ************************/
  45.  
  46. int1 nuevopulso=0;            //Entra otro pulso de lectura
  47. int16 TFB=0,TFS=0,TF=0;       //Tiempo flancos
  48. float AP=0.0;                 //Valor del pulso del obstáculo en microsegundos
  49. int16 distancia=0;            //Valor distancia al obstáculo
  50. int16 distancia_derecha=0;
  51. int16 distancia_izquierda=0;
  52. int1 cambio=0;                //Control flanco subida o bajada del impulso leido
  53.  
  54. /******************************************************************************/
  55. /******************* FUNCIÓN GENERACIÓN MODULACIONES PWM **********************/
  56.  
  57. #int_Timer0
  58. void Generacion_pwm() {
  59.    Pulso_pwm++;                //Incremento cada rebose del timer0
  60.  
  61.    if (Pulso_pwm==0)  {
  62.       Bit_PWM=1;
  63.       }
  64.    if (Pulso_pwm==PWM){
  65.       Bit_PWM=0;
  66.       }
  67.    delay_us(5);
  68.    set_timer0(255);        
  69.    }
  70.  
  71. /******************************************************************************/
  72. /*********************** FUNCIÓN PULSO DE TEST ********************************/
  73.  
  74. void pulso_test() {
  75.    enable_interrupts(INT_CCP2);  //Habilitación interrupción para medida de pulso eco
  76.    BIT_TEST_ON;                  //salida de pulso test durante 10us por Bit 0 puerto C
  77.    delay_us(10);                
  78.    BIT_TEST_OFF;
  79.    while(nuevopulso==0)    //Espera a finalizar el pulso eco
  80.       {}
  81.    if(nuevopulso==1) {      //Finalizado el pulso eco se calcula su valor.
  82.      
  83.       TF=(TFB-TFS);        //Valor entre pulso de subida y bajada.
  84.       AP=TF*1.0;           //Valor pulso leido en us(obstáculo) de 100u a 25ms
  85.       AP = AP/58;          //Distancia del obstáculo en cm
  86.       distancia =(int16)AP;   //paso de flotante a entero largo
  87.       nuevopulso=0;        //Listo para recibir nuevo pulso
  88.       }
  89.    disable_interrupts(INT_CCP2);
  90.    }
  91.  
  92. /******************************************************************************/
  93. /************************ FUNCIÓN LECTURA OBSTÁCULO ***************************/
  94.  
  95. #int_ccp2                           //LLamada por interrupción flanco en RC2
  96. void ccp2_int() {
  97.    if(cambio==0)                    //Si es flanco de subida...
  98.       {
  99.       TFS=CCP_2;                    //Carga  en valor flanco subida valor registro ccpr1
  100.       setup_ccp2(CCP_CAPTURE_FE);   //Configuración modo captura en flanco de bajada
  101.       cambio=1;                     //Próximo flanco debe ser de bajada
  102.       }
  103.    else {                      //Si es flanco de bajada...
  104.      
  105.       TFB=CCP_2;                    //Carga  en valor flanco bajada valor registro ccpr1
  106.       setup_ccp2(CCP_CAPTURE_RE);   //Configuración modo captura en flanco de subida
  107.       cambio=0;                     //Próximo flanco debe ser de subida
  108.       if(nuevopulso==0)             //Fin de pulso...
  109.          nuevopulso=1;              //Pulso finalizado.
  110.       }
  111.     }
  112.  
  113. /******************************************************************************/
  114. /********************* FUNCIÓN AVANCE - DETECCIÓN OBSTÁCULO *******************/
  115.  
  116. void navegacion()  {
  117.    pulso_test();        
  118.    if (distancia>30) {      //Si distancia >30cm avanza
  119.      
  120.       AVANCE;
  121.       }
  122.    else {
  123.       PARO;
  124.      
  125.       pwm=8;
  126.       delay_ms(700);
  127.       pulso_test();
  128.       distancia_derecha=distancia;
  129.       pwm=25;
  130.       delay_ms(700);
  131.       pulso_test();
  132.       distancia_izquierda=distancia;
  133.       pwm=16;
  134.       if (distancia_derecha>distancia_izquierda) {
  135.          GIRO_DERECHA;
  136.          delay_ms(500);
  137.          }
  138.       else {
  139.          GIRO_IZQUIERDA;
  140.          delay_ms(500);
  141.          }
  142.       }
  143.    }
  144.    
  145. /******************************************************************************/
  146. /*************************** FUNCIÓN PRINCIPAL ********************************/
  147.  
  148. void main() {
  149.    trisb=0x00;                   //Puerto B todo salidas
  150.    trisc=0b00000010;             //Puerto C definición de entradas y salidas
  151.    
  152.    pwm=16;                      //Impulso de 1,5 msg de pwm posición 0º
  153.    
  154.    
  155.    PARO;
  156.  
  157.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32); //Configuración interrupción generación PWM
  158.    setup_timer_1(T1_INTERNAL);               //Configuración timer1 para lectura obstáculo
  159.    setup_ccp2(CCP_CAPTURE_RE);               //Configuración modo captura en flanco de subida
  160.    
  161.    enable_interrupts(INT_TIMER0);    //Habilitación interrupción generación pwm
  162.    disable_interrupts(INT_TIMER1);
  163.    disable_interrupts(INT_CCP2);     //Deshabilitación interrupción modo comparación
  164.    enable_interrupts (GLOBAL);
  165.    
  166.    delay_ms(500);             //Estabilización en el arranque del sistema
  167.      
  168.    while (1) {
  169.       delay_ms(500);             //Tiempo entre impulsos test
  170.       navegacion();              //Salto a la función navegacion
  171.       }
  172.  
  173. }

Y aqui el codigo con el PIC18F4620 que yo compile...

Código: C#
  1. #include <18f4620.h>                                                          // #include <18f4550.h>                              
  2.          #fuses XT,NOWDT,PUT,NOBROWNOUT,NOLVP,NOCPD,NOWRT,NOPROTECT
  3.          #use delay(clock=4000000, crystal=4000000)  
  4.          #priority timer0
  5.          #byte PORTA=0xf80 #byte TRISA=0xf92 #byte PORTB=0xf81 #byte TRISB=0xF93 #byte PORTC=0xf82 #byte TRISC=0xF94 #byte PORTD=0xf83 #byte TRISD=0xF95 #byte PORTE=0xf84 #byte TRISE=0xF96
  6.          //#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7, parity=N, bits=8, stop=1, stream=HYPERTERMINAL, ERRORS)
  7.          #ignore_warnings 216,230
  8.          //#include <lcd4x20.c>
  9.            
  10.          #define BIT_TEST_ON     output_high(PIN_C0)
  11.          #define BIT_TEST_OFF    output_low(PIN_C0)
  12.          
  13.          #define AVANCE          output_high(PIN_B2),output_high(PIN_B4),output_low(PIN_B3),output_low(PIN_B5)
  14.          #define RETROCESO       output_low(PIN_B2),output_low(PIN_B4),output_high(PIN_B3),output_high(PIN_B5)
  15.          #define PARO            output_low(PIN_B2),output_low(PIN_B4),output_low(PIN_B3),output_low(PIN_B5)
  16.          #define GIRO_DERECHA    output_high(PIN_B2),output_low(PIN_B4),output_low(PIN_B3),output_high(PIN_B5)
  17.          #define GIRO_IZQUIERDA  output_low(PIN_B2),output_high(PIN_B4),output_high(PIN_B3),output_low(PIN_B5)
  18.          
  19.          #bit Bit_PWM =  PORTB.7                                                      // Bit 7 puerto B Salida modulación 1
  20.          
  21.          void pulso_test(void);                                                       // da pulso y calcula distancia al obstáculo
  22.          void navegacion(void);                                                       // avance sorteando obstáculos
  23.          
  24.          int8 PWM=0;                                                                   // Guardará los valores de la señal PWM
  25.          int8 Pulso_pwm=0;                                                             // Ancho del pulso de control del servo
  26.          
  27.          int1 nuevopulso=0;                                                            // Entra otro pulso de lectura
  28.          int16 TFB=0,TFS=0,TF=0;                                                       // Tiempo flancos
  29.          float AP=0.0;                                                                 // Valor del pulso del obstáculo en microsegundos
  30.          float distancia=0;                                                            // Valor distancia al obstáculo
  31.          int16 distancia_derecha=0;
  32.          int16 distancia_izquierda=0;
  33.          int1 cambio=0;                                                                // Control flanco subida o bajada del impulso leido
  34.          
  35.          #int_Timer0
  36.          void Generacion_pwm(){
  37.          set_timer0(255);
  38.          Pulso_pwm++;                                                                  // Incremento cada rebose del timer0
  39.          
  40.          if (Pulso_pwm==0){Bit_PWM=1;}
  41.          if (Pulso_pwm==PWM){Bit_PWM=0;}
  42.          //delay_us(5);  
  43.          }
  44.    
  45.          void pulso_test(){
  46.          enable_interrupts(INT_CCP2);                                                  // Habilitación interrupción para medida de pulso eco
  47.          delay_us(10);
  48.          BIT_TEST_ON;                                                                  // salida de pulso test durante 10us por Bit 0 puerto C
  49.          delay_us(10);                
  50.          BIT_TEST_OFF;
  51.          while(nuevopulso==0)                                                          // Espera a finalizar el pulso eco
  52.          {}
  53.          if(nuevopulso==1){                                                            // Finalizado el pulso eco se calcula su valor.      
  54.          TF=(TFB-TFS);                                                                 // Valor entre pulso de subida y bajada.
  55.          AP=TF*1.0;                                                                    // Valor pulso leido en us(obstáculo) de 100u a 25ms
  56.          AP = AP/58;                                                                   // Distancia del obstáculo en cm
  57.          distancia = AP;                                                               // paso de flotante a entero largo
  58.          nuevopulso=0;                                                                 // Listo para recibir nuevo pulso
  59.          }
  60.          disable_interrupts(INT_CCP2);
  61.          }
  62.          
  63.          void navegacion(){
  64.          pulso_test();        
  65.          if (distancia>30){                                                           //Si distancia >30cm avanza    
  66.          AVANCE;
  67.          }
  68.          else{
  69.          PARO;      
  70.          pwm=8;
  71.          delay_ms(500);                                                                // Cuanto mayor es este valor mayor tiempo permanecerá la cabeza del robot girada a la derecha
  72.          pulso_test();
  73.          distancia_derecha=distancia;
  74.          pwm=25;
  75.          delay_ms(500);                                                                // Cuanto mayor es este valor mayor tiempo permanecerá la cabeza del robot girada a la izquierda
  76.          pulso_test();
  77.          distancia_izquierda=distancia;
  78.          pwm=16;
  79.          if (distancia_derecha>distancia_izquierda){
  80.          GIRO_DERECHA;
  81.          delay_ms(500);                                                                // Cuanto mayor es este valor mayor será el ángulo de giro del robot a la derecha
  82.          }
  83.          else {
  84.          GIRO_IZQUIERDA;
  85.          delay_ms(500);                                                                // Cuanto mayor es este valor mayor será el ángulo de giro del robot a la izquierda
  86.          }  
  87.          }
  88.          }
  89.  
  90.          #int_ccp2                                                                     // LLamada por interrupción flanco en RC2
  91.          void ccp2_int(){
  92.          if(cambio==0)                                                                 // Si es flanco de subida...
  93.          {
  94.          TFS=CCP_2;                                                                    // Carga  en valor flanco subida valor registro ccpr1
  95.          setup_ccp2(CCP_CAPTURE_FE);                                                   // Configuración modo captura en flanco de bajada
  96.          cambio=1;                                                                     // Próximo flanco debe ser de bajada
  97.          }
  98.          else {                                                                        // Si es flanco de bajada...    
  99.          TFB=CCP_2;                                                                    // Carga  en valor flanco bajada valor registro ccpr1
  100.          setup_ccp2(CCP_CAPTURE_RE);                                                   // Configuración modo captura en flanco de subida
  101.          cambio=0;                                                                     // Próximo flanco debe ser de subida
  102.          if(nuevopulso==0)                                                             // Fin de pulso...
  103.          nuevopulso=1;                                                                 // Pulso finalizado.
  104.          }
  105.          }        
  106.    
  107.          void main(){
  108.          //lcd_init();
  109.          porta=0x00; set_tris_a(0b00000000); portb=0x00; set_tris_b(0b00000000); portc=0x00; set_tris_c(0b00000010); portd=0x00; set_tris_d(0b00000000); porte=0x00; set_tris_e(0b00001000);
  110.          pwm=16;                                                                       // Impulso de 1,5 msg de pwm posición 0º
  111.          PARO;
  112.          
  113.          setup_timer_1(T1_INTERNAL);                                                   // Configuración timer1 para lectura obstáculo
  114.          setup_ccp2(CCP_CAPTURE_RE);                                                   // Configuración modo captura en flanco de subida
  115.          setup_timer_0(T0_INTERNAL|T0_DIV_32|T0_8_BIT);                                // Configuración interrupción generación PWM, internat counter, prescaler 256, 8 bits
  116.          set_timer0(255);
  117.          enable_interrupts(INT_TIMER0);                                                // Habilitación interrupción generación pwm
  118.          disable_interrupts(INT_TIMER1);
  119.          disable_interrupts(INT_CCP2);                                                 // Deshabilitación interrupción modo comparación
  120.          enable_interrupts (GLOBAL);        
  121.          delay_ms(100);                                                                // Estabilización en el arranque del sistema
  122.          
  123.          while(TRUE)
  124.          {
  125.          navegacion();                                                                 // Salto a la función navegacion
  126.          lcd_gotoxy(3,2); printf(lcd_putc,"Dist: %f cm  ",distancia);
  127.          }
  128.          }

Alguien ,me puede ayudar a adaptarlo o que mas cambiar de un codigo a otro?.

Algo que observe es que si pongo set_timer0(255); el LDC no se ve y si bajo ese valor el LCD si muestra la distancia del sensor ultrasonido.

Después pensaba meter mas sensores ultrasónicos srf04 pero por lo pronto hallar el hilo negro de este código para que funcione.
Gracias por leer.
« Última modificación: 23 de Febrero de 2023, 15:47:10 por Ruco »


 

anything