Répondre à la discussion
Affichage des résultats 1 à 2 sur 2

Mesures la vitesse du vent Mikro c



  1. #1
    Leif34

    Post Mesures la vitesse du vent Mikro c


    ------

    Bonjour a tous !
    J'ai un projet que je dois réaliser avant fin mai mais j'ai du mal a terminer mon code mikroC je dois mesurer en Km/h mais le programme ne marche pas des avis ?=)
    je tien à préciser que les prof nous laisse nous débrouiller sans nous aidée.

    Merci beaucoup bonne journée

    Code:
    /*********************************************************************************************************
    *     Tachymètre (compte-tour) numérique à base de capteur à effet Hall                                  *
    *     Quartz 8Mhz         PIC 18f4520                                                                    *
    *     fusibles par defaut -                                                                              *
    *     MikroC Pro 6                                                                                       *
    *     easypic4                                                                                           *
    *     Formule de calcul du timer0 :                                                                      *
    *     Temps=(256-valeur Décimale chargée TMR0) * 4 * (prescaler T0CON) * 1/Oscillateur en Hz        *
    *     Ce qui donne:                                                                                      *
    *     T=(256-56)*4*(1/8000000)= 100us  >> pour avoir 1 seconde  à multiplier par cnt=10000   *
    *     0,999424 étant pour ce quartz  la valeur la plus proche de 1 seconde avec le timer0                *
    *                                                                                                        *
    *     Le capteur est inductif la roue de mesure fait 60 dents cela permet d'avoir directement la vitesse *
    *     en tr/mn . pour les tests un sgnal de 1000hz corresponds à une vitesse de 1000tr/mn                *
    *                                                                                                        *
    *                                                                                                        *
    *********************************************************************************************************/
    
     #include "built_in.h"
    /*
    // Configuration des ports sur le LCD
    sbit LCD_RS at RD2_bit;
    sbit LCD_EN at RD3_bit;
    sbit LCD_D7 at RD7_bit;
    sbit LCD_D6 at RD6_bit;
    sbit LCD_D5 at RD5_bit;
    sbit LCD_D4 at RD4_bit;
    // Orientation des ports
    sbit LCD_RS_Direction at TRISD2_bit;
    sbit LCD_EN_Direction at TRISD3_bit;
    sbit LCD_D7_Direction at TRISD7_bit;
    sbit LCD_D6_Direction at TRISD6_bit;
    sbit LCD_D5_Direction at TRISD5_bit;
    sbit LCD_D4_Direction at TRISD4_bit;       */
    
    
    // Lcd pinout settings
    sbit LCD_RS at RB4_bit;
    sbit LCD_EN at RB5_bit;
    sbit LCD_D7 at RB3_bit;
    sbit LCD_D6 at RB2_bit;
    sbit LCD_D5 at RB1_bit;
    sbit LCD_D4 at RB0_bit;
    
    // Pin direction
    sbit LCD_RS_Direction at TRISB4_bit;
    sbit LCD_EN_Direction at TRISB5_bit;
    sbit LCD_D7_Direction at TRISB3_bit;
    sbit LCD_D6_Direction at TRISB2_bit;
    sbit LCD_D5_Direction at TRISB1_bit;
    sbit LCD_D4_Direction at TRISB0_bit;
    
    
    
    //Déclaration des variables
    unsigned int temp,compteur,cnt,tour ;
    unsigned int rotation_brute;
    unsigned  int seconde;
    
    int vitesse;
    char uart_rd;
    
    
    
    
    
    
    
    
    void Affiche_Compteur (void);
     //char txt[7];
    //******************************************************************************
    //Interruption
    void interrupt() {
                     cnt++;
                      TMR0L   = 55;                          // Valeur décimale préchargée à soustraire à 255
                      INTCON.TMR0IF = 0;     //remise à 0 flag interuption
                      //  portc=cnt;      //pour test
    
                     if(INT0IF_bit==1){                   // Si une interruption du port B0 est détectée
                                        tour++;            // incrémenter la variable de tour
                                     //   porta.f2=1;    //pour test
                                      //  INT0IF_bit=0;
    
                                        }                  // fin if
    
                      INTCON = 0x20;       //  INTCON.TMR0IE = 1;
    
                                         // Initialisation du registre timer et interruption
                     if(cnt==9660){                 //normalement 10000 mais la durée des instructions pas negligeable p/r à IT=100uS
                   //  portc=0;         //pour test
                  //   porta.f2=0;       //pour test
                                       // lorsque l'on compte 1 seconde (voir commentaire entête)
                               compteur= tour;         // Multiplier le nombre de tour/seconde par 60 (pour tour/min)si une impulsion par tour
                              //  seconde=tour;         // pour afficher direct les tours
                                cnt=0;                     // RAZ variable cnt
                                tour=0;
                                INTCON.INT0IE = 1;           // Activer RB0/INT interruption
                      }                                    // Fin if
       }       //fin interruption
        void tachy (int valeur)
          { char chk  ;
           chk = 0X0E^hi(valeur)^lo(valeur);
    
           UART_Write(0X01);                    //écriture
           UART_Write(0X0F);                     //commande  0x07 ulcd220 0x0a ulcd32
           UART_Write(0X00);
           UART_Write(hi(valeur));              //valeur
           UART_Write(lo(valeur));              //valeur
           UART_Write(chk);                     //checksum
           Delay_ms(100);
    
                       }
    //******************************************************************************
    void Affiche_Compteur (void){           // fonction d'affichage de nombre sur plusieurs digits
    unsigned int temp;
    unsigned char rotation_brute;
     vitesse= compteur;
    rotation_brute = (compteur/1000)+48;
    temp = compteur % 1000;
    Lcd_Chr(2, 4, rotation_brute);           // Afficher les milliers en ligne 2, 4-ieme colonne
    rotation_brute = (temp/100)+48;
    temp = temp % 100;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les centaines
    rotation_brute = (temp/10)+48;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les dizaines
    rotation_brute = (temp % 10)+48;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les unités
      //pour test
      /*
     rotation_brute = (seconde/1000)+48;
    temp = seconde % 1000;
    Lcd_Chr(1, 4, rotation_brute);           // Afficher les milliers en ligne 2, 4-ieme colonne
    rotation_brute = (temp/100)+48;
    temp = temp % 100;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les centaines
    rotation_brute = (temp/10)+48;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les dizaines
    rotation_brute = (temp % 10)+48;
    Lcd_Chr_Cp(rotation_brute);             // Afficher les unités
        */
    }
     //*****************************************************************************
     void main(){                       // Début du programme principal
     /*  INT0IF_bit = 0;          // Clear INT0IF
       TMR0IE_bit         = 1;
      INT0IE_bit = 1;          // turn OFF interrupt on INT0
      GIE_bit = 1;             // enable GIE
    
                    */
    
         UART1_Init(9600);                     // Initialize UART module at 9600 bps
         delay_ms(3600);
    
      INTCON=0b10110000;                // activer detection interruption front montant RB0 avec INTE et GIE
      INTCON2.INTEDG0=1;                //detection des front montants
      T0CON= 0b11001000;          // Assigner prescaler sur TMR0  valeur    = 000
      TMR0L=56;
      CMCON  |= 7;                      // Comparateur desactivé
      ADCON0=0;                         // ADC désactivé
      TRISA=1;                          // PORTA configuré en entrée
      TRISB=0b00000001;                 // PORTB configuré en sortie sauf port0
      TRISC=0;                          // PORTC configuré en sortie
      PORTA=0;
      PORTB=0;
      PORTC=0;
      compteur=0;
      temp=0;
      seconde=0;
      tour=0;
    
    //******************************************************************************
    
      Lcd_Init();                       //Initialiser le LCD
      Lcd_Cmd(_LCD_CLEAR);              // Effacer l'écran
      Lcd_Cmd(_LCD_CURSOR_OFF);         // Cacher le curseur
      Lcd_Out(1,4, "Vitesse du vent");       // Afficher le message
      Lcd_Out(2,9, "km/h ");           // Afficher le message
      delay_ms(300);
    //boucle infinie
             while(1)
    
                     {
    
                      Affiche_Compteur();               // Fonction d'affichage sur LCD
    
        tachy(vitesse);
                      }  //fin de while
    
      }  // fin de main

    -----

  2. #2
    paulfjujo

    Re : Mesures la vitesse du vent Mikro c

    bonjour,

    il manque le test de TMR0IF_bit dans l'interrupt ..

    Code:
    void interrupt() 
    {
      if(TMR0IF_bit==1)
       {
                     cnt++;
                      TMR0L   = 55;                          // Valeur décimale préchargée à soustraire à 255
                      TMR0IF_bit=0;     //remise à 0 flag interuption
                      //  portc=cnt;      //pour test
       }
      
         if(INT0IF_bit==1)                   // Si une interruption du port B0 est détectée
        {
         	tour++;            // incrémenter la variable de tour
            //   porta.f2=1;    //pour test
           INT0IF_bit=0;
          //   }                  // fin if
          //     INTCON = 0x20;       //  INTCON.TMR0IE = 1;
                                        // Initialisation du registre timer et interruption
           if(cnt==9660)
    	   {                 //normalement 10000 mais la durée des instructions pas negligeable p/r à IT=100uS
                   //  portc=0;         //pour test
                  //   porta.f2=0;       //pour test
                                       // lorsque l'on compte 1 seconde (voir commentaire entête)
                compteur= tour;         // Multiplier le nombre de tour/seconde par 60 (pour tour/min)si une impulsion par tour
                 //  seconde=tour;         // pour afficher direct les tours
                  cnt=0;                     // RAZ variable cnt
                 tour=0;
            //      INTCON.INT0IE = 1;           // Activer RB0/INT interruption
            }                                    // Fin if
       }       //fin interruption
    Ne pas oublier de RAZER le flag interrupt dans le traitement d'interruptions.
    normalement , on ne masque pas les flags d'autorisation **IE d'interrupt dans le traitement des interrupts
    sauf traitement specifique .. mais il faut alors réarmer le flag autorisation **IE dans le main program
    Dernière modification par paulfjujo ; 28/01/2021 à 18h00.

Discussions similaires

  1. Actu - Aeolus : à quoi vont servir ses premières mesures directes de vent depuis l’espace
    Par RSSBot dans le forum Commentez les actus, dossiers et définitions
    Réponses: 0
    Dernier message: 17/08/2018, 15h30
  2. Réponses: 30
    Dernier message: 20/07/2015, 15h39
  3. vitesse du vent
    Par py3.1415 dans le forum Physique
    Réponses: 6
    Dernier message: 05/03/2013, 10h56
  4. vitesse du vent
    Par ar13menia dans le forum Physique
    Réponses: 2
    Dernier message: 02/05/2010, 20h22
  5. Vitesse du vent
    Par Nenya dans le forum Physique
    Réponses: 11
    Dernier message: 16/01/2008, 14h47
Découvrez nos comparatifs produits sur l'informatique et les technologies.