IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Delphi Discussion :

Acquisition d'un signal en fréquence


Sujet :

Langage Delphi

  1. #21
    Membre confirmé

    Inscrit en
    Novembre 2002
    Messages
    744
    Détails du profil
    Informations forums :
    Inscription : Novembre 2002
    Messages : 744
    Points : 500
    Points
    500
    Par défaut
    re ,
    d'accord je comprends , mais je peux pas t'expliquer toute la philosophie de delphi ..

    En fait un string est une chaine de caractères et un integer une valeur numérique. donc tu dois convertir tes chaines texte ( string) dans un format numérique pour pouvoir faire des opérations dessus et ensuite les reconvertir en texte pour les afficher.

    StrToInt => converti une chaine en valeur numérique entière
    IntTostr => converti une valeur numérique entière en chaine
    StrToFoat=> converti une chaine en valeur numérique réelle
    et ainsi de suite..

    Mais le plus simple pour nous, c'est que tu nous envoie plutôt ton bout de code qui coince, que l'ont puissent nous même nous rendre compte et on t'expliquera directement avec ton code, plus simple pour nous et aussi pour toi de bien comprendre .

    à bientot
    Bye et bon code...

    Ce n'est pas tant l'aide de nos amis qui nous aide , mais notre confiance dans cette aide .

  2. #22
    Membre éprouvé
    Avatar de Montor
    Homme Profil pro
    Autre
    Inscrit en
    Avril 2008
    Messages
    879
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Autre

    Informations forums :
    Inscription : Avril 2008
    Messages : 879
    Points : 963
    Points
    963
    Par défaut
    Ce schemas est simple a realiser il y a deux registre 273 et le compteur 4040 qui compte la duree de chaque periode
    pour utiliser le port de pc

  3. #23
    Expert confirmé
    Avatar de Sub0
    Homme Profil pro
    Développeur Web
    Inscrit en
    Décembre 2002
    Messages
    3 573
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : Décembre 2002
    Messages : 3 573
    Points : 4 219
    Points
    4 219
    Par défaut
    si tu as besoin d'un accès direct bas niveau du port // avec delphi, voici une démo avec ses sources qui te permettra la capture des signaux du port //, il ya le tableau d'adressage des broches, c'est le B-E-A-B-A de l'électronique sur PC :



    "BA" est l'adresse de base de ton port parrallèle, par exemple $378.
    Si tu ne sais pas extraire les bits d'un octet, lis ce sujet.

    /!\ Il faut absolument que le fichier SYS du pilote soit dans le même dossier que ton programme pour pouvoir fonctionner. Le programme ne pourra pas fonctionner si il est lancé directement depuis un ZIP par exemple.
    De retour parmis vous après 10 ans!!

  4. #24
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    euh.. delphidelphi et Sub0... vous allez un peu trop loin là ... comprend plus...

    et sinon petitcoucou31, merci pour tes explication, j'ai reussi a effectuer ma division avec le code suivant:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    procedure TForm1.TrackBar1Change(Sender: TObject);
    begin
      OutputDACchannel (1,TrackBar1.Position);
      Label6.Caption:=inttostr(Trackbar1.Position * 10 div 63);
    end;
    Mais comme j'utilise div au lieu de / , je n'arrive qu'à afficher des valeurs comme 0, 1, 2, 3, 4, 5, etc. et moi j'aimerais avoir un précision a 0.0 près pour afficher des valeur comme 2.3 , 4.5, etc.

    et là, je bloque... pck je ne sais pas comment convertir les types de variables pour réussir à afficher cela...

    J'ai essayé de modifier le code que tu m'avais donné comme exemple, mais j'y arrive pas...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
      repeat
          V:=MesureFrequence;
          // adaptation resultat
          edit1.text:=FormatFloat('###.##',v);
          application.ProcessMessages;
       until fini ;

  5. #25
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    Je pars du programme donné par "Frank SORIANO" legerement modifié.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
     
     
     
    function MesureFrequence: double;
    const DUREE_MESURE = 250; //durée de la mesure en ms
    var
      debut, fin, freq: int64;
      e : boolean;
      old : boolean;
      compteur : cardinal;
      duree : cardinal;
    begin
      QueryPerformanceFrequency(freq);//lit la frequence du compteur de performances
     
      Sleep(1); //permet de poursuivre l'éxecution de la mesure au début d'une
                //fenêtre d'exécution CPU.
     
      //pour commencer, on se synchronise sur un front montant
      //pour avoir une référence pour le début de la mesure
      while (ReadIOchannel(2)) do
      begin
        //on attend que l'entrée soit à 0
      end;
      while (not ReadIOchannel(2)) do
      begin
        //on attend que l'entrée passe à 1
      end;
     
      //début de la mesure
      compteur:=0;
     
      //on lit la date de début de la mesure
      QueryPerformanceCounter(debut);
      old:=ReadIOchannel(2);
      repeat
        e:=ReadIOchannel(2);
        if (e<>old) //on vient de détecter un changement d'état
        then inc(compteur);
     
        //on lit la date en cour
        QueryPerformanceCounter(fin);
      until (fin-debut)*1000 div freq > DUREE_MESURE;
     
      //la duree de mesure DUREE_MESURE est écoulée
      //pour une meilleure précision on attend le front suivant.
      while ReadIOchannel(2)=old do
      begin
        //on attend le prochain changement d'état
      end;
      //on lit la date en cour
      QueryPerformanceCounter(fin);
     
      //calcul de la durée de la mesure en ms
      duree:=(fin-debut*1000) div freq;
     
      //calcul de la fréquence en Hz duree est mesurée en ms.
      //compteur contient le nombre de demi-périodes comptée pendant cette durée
      if compteur=0
      then result:=0
      else result:=(duree*2/compteur)/1000;
    end;
    A partir de cela, comment afficher la valeur en m/s (a 0.1 près)de la vitesse du vent dans un Label? J'ai aussi essayé diverses solutions ms aucune ne marche...

  6. #26
    Membre confirmé

    Inscrit en
    Novembre 2002
    Messages
    744
    Détails du profil
    Informations forums :
    Inscription : Novembre 2002
    Messages : 744
    Points : 500
    Points
    500
    Par défaut
    re salut

    tu as en bas de la procédure l'affichage.
    regarde dans l'aide le formatfloat tu as diverses possibilités

    et j'ai rajouter une variable "V" ( vitesse )

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
     
    function MesureFrequence: double;
    const DUREE_MESURE = 250; //durée de la mesure en ms
    var
      debut, fin, freq: int64;
      e : boolean;
      old : boolean;
      compteur : cardinal;
      duree : cardinal;
      V: real;
    begin
      QueryPerformanceFrequency(freq);//lit la frequence du compteur de performances
     
      Sleep(1); //permet de poursuivre l'éxecution de la mesure au début d'une
                //fenêtre d'exécution CPU.
     
      //pour commencer, on se synchronise sur un front montant
      //pour avoir une référence pour le début de la mesure
      while (ReadIOchannel(2)) do
      begin
        //on attend que l'entrée soit à 0
      end;
      while (not ReadIOchannel(2)) do
      begin
        //on attend que l'entrée passe à 1
      end;
     
      //début de la mesure
      compteur:=0;
     
      //on lit la date de début de la mesure
      QueryPerformanceCounter(debut);
      old:=ReadIOchannel(2);
      repeat
        e:=ReadIOchannel(2);
        if (e<>old) //on vient de détecter un changement d'état
        then inc(compteur);
     
        //on lit la date en cour
        QueryPerformanceCounter(fin);
      until (fin-debut)*1000 div freq > DUREE_MESURE;
     
      //la duree de mesure DUREE_MESURE est écoulée
      //pour une meilleure précision on attend le front suivant.
      while ReadIOchannel(2)=old do
      begin
        //on attend le prochain changement d'état
      end;
      //on lit la date en cour
      QueryPerformanceCounter(fin);
     
      //calcul de la durée de la mesure en ms
      duree:=(fin-debut*1000) div freq;
     
      //calcul de la fréquence en Hz duree est mesurée en ms.
      //compteur contient le nombre de demi-périodes comptée pendant cette durée
      if compteur=0
      then result:=0
      else result:=(duree*2/compteur)/1000;
     
    //--------------------------------
    // 
      if result=0 Then V:=0;
      else V:=(duree/result);
      edit1.text:=FormatFloat('0.#',V) + ' m/s';
     
    //--------------------------------
    end;
    Bye et bon code...

    Ce n'est pas tant l'aide de nos amis qui nous aide , mais notre confiance dans cette aide .

  7. #27
    Membre éprouvé
    Avatar de Montor
    Homme Profil pro
    Autre
    Inscrit en
    Avril 2008
    Messages
    879
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Autre

    Informations forums :
    Inscription : Avril 2008
    Messages : 879
    Points : 963
    Points
    963
    Par défaut
    bon, je rectifie pour moi
    c'était pas le registre "273"
    mais bien le registre "374"
    Pour vous repondre
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     label6.Caption:=FormatFloat('00.00',TrackBar1.Position*10/63 )
    ChangeCount est le nombre de périodes
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
     unit Unit1;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
      Dialogs, ExtCtrls, StdCtrls;
    type
      TForm1 = class(TForm)
      Timer1: TTimer;
        procedure Timer1Timer(Sender: TObject);
      private
        { Déclarations privées }
      public
        { Déclarations publiques }
      end;
    var
    Form1: TForm1;
    TickPerSec, BeginTime, EndTime: Int64;
    ChangeCount:integer;
    implementation
    {$R *.dfm}
    procedure TForm1.Timer1Timer(Sender: TObject);
    var
    tmp,bp,mm:integer;
    begin
    QueryPerformanceFrequency(TickPerSec);
    QueryPerformanceCounter(EndTime);
    if (ChangeCount>0) then    begin
    mm:=Round(((EndTime - BeginTime) / (TickPerSec div 1000))/ChangeCount)  ;
    bp:= 1000 div mm ;
    caption:='Frequence : '+inttostr(bp)+' Pulse : '+FormatFloat('0.000ms',1/bp);
    end;
    ChangeCount:=0;
    QueryPerformanceCounter(BeginTime);
    end;
     
    end.

  8. #28
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    Delphidelphi, ton code:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
     
     unit Unit1;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
      Dialogs, ExtCtrls, StdCtrls;
    type
      TForm1 = class(TForm)
      Timer1: TTimer;
        procedure Timer1Timer(Sender: TObject);
      private
        { Déclarations privées }
      public
        { Déclarations publiques }
      end;
    var
    Form1: TForm1;
    TickPerSec, BeginTime, EndTime: Int64;
    ChangeCount:integer;
    implementation
    {$R *.dfm}
    procedure TForm1.Timer1Timer(Sender: TObject);
    var
    tmp,bp,mm:integer;
    begin
    QueryPerformanceFrequency(TickPerSec);
    QueryPerformanceCounter(EndTime);
    if (ChangeCount>0) then    begin
    mm:=Round(((EndTime - BeginTime) / (TickPerSec div 1000))/ChangeCount)  ;
    bp:= 1000 div mm ;
    caption:='Frequence : '+inttostr(bp)+' Pulse : '+FormatFloat('0.000ms',1/bp);
    end;
    ChangeCount:=0;
    QueryPerformanceCounter(BeginTime);
    end;
     
    end.
    Bah je vois le principe ms je ne sais pas comment l'adapter a ma carte k8000; car elle ne lis l'entrée que lorsque delphi lui envoi l'instruction ReadIOchannel (2) donc voila...

    et sinon pour petitcoucou31

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
      if result=0 Then V:=0;
      else V:=(duree/result);
      edit1.text:=FormatFloat('0.#',V) + ' m/s';
    alors que mon Label1 est correctement placé dans mon programme il m'indique:

    Indentificateur non déclaré: 'Edit1'
    Opérateur ou point-virgule manquant
    Instruction attendue, mais expression de type 'String' trouvée


    Rahlala...

  9. #29
    Membre confirmé

    Inscrit en
    Novembre 2002
    Messages
    744
    Détails du profil
    Informations forums :
    Inscription : Novembre 2002
    Messages : 744
    Points : 500
    Points
    500
    Par défaut
    re

    oui tu as raison , un oubli de ma part ,

    La fonction fonction " MesureFrequence " ne connait pas les composants de ta fiche donc tu remplace

    "edit1.text" par formx.edit1.text, (formx etant le nom de ta fiche).

    Si tu prends le 1er code que je t'ai envoyé, il est parfaitement fonctionnel, il te faut juste faire la même modification que celle sur la routine de "Franc Soriono" a cause de la reponde de ta carte par un boollean et tout functionnera

    salut
    Bye et bon code...

    Ce n'est pas tant l'aide de nos amis qui nous aide , mais notre confiance dans cette aide .

  10. #30
    Expert confirmé
    Avatar de Sub0
    Homme Profil pro
    Développeur Web
    Inscrit en
    Décembre 2002
    Messages
    3 573
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : Décembre 2002
    Messages : 3 573
    Points : 4 219
    Points
    4 219
    Par défaut
    Citation Envoyé par Nok3dZion Voir le message
    euh.. delphidelphi et Sub0... vous allez un peu trop loin là ... comprend plus...
    Pour précisions, le code que je t'ai donné concerne l'acquisition des données du port //, l'accès direct aux entrées/sorties du port. Ça sert à lire et écrire l'état de chaque broche de la prise. C'est utile surtout lorsque tu réalises toi-même ton interface électronique et pour pouvoir la faire communiquer avec ton application Delphi.

    Mais si tu disposes déjà d'un pilote (une DLL par exemple) fourni par le fabricant de ta carte d'acquisition, tu n'auras pas besoin d'accéder au port //, le pilote s'en chargera, par exemple, c'est lui qui te fournira la fréquence de l'entrée de ta carte.
    De retour parmis vous après 10 ans!!

  11. #31
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    "petitcoucou31",quand tu dis que ton code est fonctionnel? tu parle bien de celui la:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
     
     
     
    unit Unit32;
     
    interface
     
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
      Dialogs, StdCtrls, ExtCtrls;
     
    type
      Tform32 = class(TForm)
        acquisition: TButton;
        Button1: TButton;
        Edit1: TEdit;
        Edit2: TEdit;
        Label1: TLabel;
        Label2: TLabel;
        Edit3: TEdit;
        Label3: TLabel;
        Edit4: TEdit;
        Label4: TLabel;
     
        procedure Clock(duree:integer);
        procedure acquisitionClick(Sender: TObject);
        function  AcquisitionData:real;
        procedure Button1Click(Sender: TObject);
        procedure FormClose(Sender: TObject; var Action: TCloseAction);
     
      private
        { Déclarations privées }
      public
        { Déclarations publiques }
      end;
     
    var
      form32: Tform32;
     
    implementation
     
    {$R *.dfm}
    var fini:boolean;
    //==============================================================================
    procedure Tform32.Button1Click(Sender: TObject);
    begin
       fini:=true; // quitte la lecture
    end;
    //==============================================================================
    procedure Tform32.FormClose(Sender: TObject; var Action: TCloseAction);
    begin
       fini:=true; // quitte la lecture
    end;
    //==============================================================================
    // ici je simule la lecture de ton canal
    // a remplacer par ta procedure et faire un masque au besoin si tu lis un octet plutot qu'un bit
    function ReadIOchannel(Channelno:integer):byte;
    begin
        // a remplacer , je simule la lecture d'un bit
        randomize;
        result:=random(256);
        // affiche la valeur de l'octet
        form32.edit4.text:=inttostr(result);
        // lecture du bit 0
        result:=result and ($01);
    end;
    //==============================================================================
    procedure Tform32.Clock(duree:integer);
    Var
       F : Int64 ;
       Start,Stop : Int64 ;
       R:double;
    begin
         start:=0;
         // controle si le pc possede ce type de compteur, sinon utilise le GetTickCount
         // initialise valeur de depart
         if QueryPerformanceFrequency(F) then  QueryPerformanceCounter(Start)
         else Start:=GetTickCount;
         // rentre dans une boucle d'attente
         repeat
              if QueryPerformanceFrequency(F) then  QueryPerformanceCounter(Stop)
              else
              begin
                F:=1000;
                Stop:=GetTickCount;
              end;
              R:=(Stop-Start)*1000/F; //resultat en ms
              application.ProcessMessages;
         until R>duree; // quitte au bout de 1 ms
    end;
    //==============================================================================
    function Tform32.AcquisitionData:real;
    var FinAcq        :boolean;
        CompteurActif :boolean;
        etat          :byte;
        Oldetat       :byte;
        compteur      :integer;
        NbAqc         :integer;
    begin
       Oldetat:=0;
       CompteurActif:=false;
       compteur:=0;
       NbAqc:=0;
       FinAcq:=false;
       edit3.text:='';
       repeat
          // delai de 1 ms, cette "clock" est l'echantillonage du signal
          Clock(1);
          // lecteure du canal de la carte
          etat:=ReadIOchannel(0);
     
          // controle si l'etat lus est different de l'etat precedant,
          // si l'etat change j'active ou desactive le compteur
          if Oldetat<>Etat then
          begin
              CompteurActif:=not(CompteurActif);
              // ici je desactive le compteur donc l'acquisition est finie.
              if CompteurActif=false then FinAcq:=true;
          end;
          // iniatilise l'etat precedant
          Oldetat:=etat;
          // compte le nombre d'acquisition entre deux changements d'etat ( donc le nombre de ms)
          if CompteurActif then
          begin
              inc(compteur);
              // affiche le nombre de bit a 1 concecutifs
              edit3.text:=edit3.text+inttostr(etat);
          end;
     
          // variable de controle, je quitte si l'acquisition dure plus de 1 seconde sans changement d'etat
          inc(NbAqc);
          if (CompteurActif=false) and (NbAqc=1000) then FinAcq:=true;
          application.ProcessMessages;
       until FinAcq;
     
       // la valeur retournée par cette fonction est le nombre de ms ecoulé entre
       // deux changements d'etat donc un demi periode ( si le signal a un rapport
       // cyclique de 50 !!) donc je le multipli par deux .
     
       compteur:=compteur*2;
       edit2.text:=inttostr(compteur);   
       // resultat en m/s
       result:=250/(compteur);
    end;
    //==============================================================================
    procedure Tform32.acquisitionClick(Sender: TObject);
    var V:real;
    begin
       fini:=false;
       repeat
          // delai t'attente de 500 ms entre deux lecture de frequence
          Clock(500);
          V:=AcquisitionData;
          edit1.text:=FormatFloat('###.##',v);
          application.ProcessMessages;
       until fini ;
    end;
    //==============================================================================
    end.
    tu as eu l'occasion de le tester? pck en fait je suis en train de programmer en delphi mais pour l'instant, mon système n'etant pas encore opérationnel, je n'ai pas eu le temps ni les moyens de pouvoir tester cette partie du programme.

    Merci.

  12. #32
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    "petitcoucou31", j'ai essayé de modifier ton code pour l'adapter... mais pfiou, pas facile lol. Et donc à ce que j'ai compris ma fonction ReadIOchannel (2) renvoie un boolean. Et dans ton code il y a 4 Edit alors qu'un seul m'indiquant la valeur est nécéssaire... (enfin c'est un détail ça)

    Donc si on peux m'aider sur cela aussi, se ne serait pas de refus...

    Merci

  13. #33
    Membre confirmé

    Inscrit en
    Novembre 2002
    Messages
    744
    Détails du profil
    Informations forums :
    Inscription : Novembre 2002
    Messages : 744
    Points : 500
    Points
    500
    Par défaut
    re ,

    Quand je dis fonctionnel , c'est qu'il fait ce que j'attends de lui. mais peut être y trouvera tu un défaut en fonctionnement réel avec ta carte, çà fait parti du degguage !

    Ton code doit réagir en fonction des informations délivrées par ta carte K8000, mais bien sur je n'avais pas cette carte, donc j'ai imaginé ce que cette carte donnerait comme informations (dans mon code des 0 et des 1 , mais je sais maintenant que c'est des "true" ou "false" en fonction d'un état) mais çà marche pareil à une modification prés.

    j'ai donc écris la function ReadIOchannel(Channelno:integer):byte; pour simuler les informations que pourrait te renvoyer ta carte, elle me renvoit aléatoirement un valeur = 0 ou 1 ( comme si je venais de lire un bit sur ton canal).
    Bien sur ensuite cette fonction devra être remplacé par la vrai ( celle de ta carte ).

    c'est pour cela que je dis que mon code est fonctionnel, avec ma routine de simulation.

    donc si tu essayes mon code, tu aura pour visualiser ce qu'il se passe 4 Tedit

    Edit1 qui te donne le résultat que tu recherche

    les 3 autres sont juste là pour que tu comprenne ce qui se passe .

    Edit2 qui te donne le nombre de bit a 1
    Edit3 qui visualise la trame de bit a 1 (111111)
    Edit4 qui donne le resultat de la lecture de ton canal (0 ou 1)

    mon générateur de valeur aléatoire pour la simulation, donne bien sur des vitesses de vents élevé ( même improbable ) car il change souvent d'état, une autre routine de simulation etait envisageable bien sur , mais cela ne gène en rien au fonctionnement des routines .

    c'est sur que faire ce que tu veux faire sans aucune connaissance de delphi et pas simple ! donc si tu veux et si cela peut t'expliquer, ayant un peut de temps je peux t'aider en direct via msn ou autre .

    bon courage.
    Bye et bon code...

    Ce n'est pas tant l'aide de nos amis qui nous aide , mais notre confiance dans cette aide .

  14. #34
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    Je n'ai pas acces a msn, je suis en cour pour réaliser cela et internet est bloqué a ce niveau... et je ne peux pas etre constamment a coté du pc mais merci bcp de me lavoir proposé.

    Dans ton code, il ya a plusieur chose que je ne comprend pas... Comme ceci:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
     
    function ReadIOchannel(Channelno:integer):byte;
    begin
        // a remplacer , je simule la lecture d'un bit
        randomize;
        result:=random(256);
        // affiche la valeur de l'octet
        form32.edit4.text:=inttostr(result);
        // lecture du bit 0
        result:=result and ($01);
    end;
    je le modifie et le transforme en cela? ou pas...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
     
    function ReadIOchannel(2);
    begin
        // a remplacer , je simule la lecture d'un bit
        randomize;
        result:=ReadIOchannel(2)
        // affiche la valeur de l'octet
        form32.edit4.text:=inttostr(result);
    end;

    Pour ceci, comment controler et comment modifier si le pc ne possede pas ce type de compteur:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
     
    begin
         start:=0;
         // controle si le pc possede ce type de compteur, sinon utilise le GetTickCount
         // initialise valeur de depart
         if QueryPerformanceFrequency(F) then  QueryPerformanceCounter(Start)
         else Start:=GetTickCount;

    Et aussi, moi pour mes autres mesure, je lie la procedure de lecture a un timer (ex: readADchannel (1).timer1) car la lecture ne s'effectue pas en continu ms a chaque fois que le programme lui demande de connaitre l'etat a un instant défini. Donc si cette procédure est dans ton programme, pourrais tu m'indiquer ou elle se situe?

    Merci

  15. #35
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    Et a quoi sert ton button1? Il lance le début de la mesure?
    Je peux donc le remplacer par FormCreate afin de démarrer la mesure lorsque je lance l'application?

  16. #36
    Membre confirmé

    Inscrit en
    Novembre 2002
    Messages
    744
    Détails du profil
    Informations forums :
    Inscription : Novembre 2002
    Messages : 744
    Points : 500
    Points
    500
    Par défaut
    re salut ,

    oui pour le bouton1 , il lance la mesure ..

    je t'envoie les fichiers via le "rar" joint , tu y trouve l'exe, le source et la fiche.

    j'espère avoir assez documenté pour que tu comprennes tout. quand tu aura bien compris et seulement là , remplace ce qui simule par les routines de ta carte.
    Fichiers attachés Fichiers attachés
    Bye et bon code...

    Ce n'est pas tant l'aide de nos amis qui nous aide , mais notre confiance dans cette aide .

  17. #37
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 15
    Points : 1
    Points
    1
    Par défaut
    Bonjour!

    Dsl pour ces quelques temps d'abscence. Comme ce travail était a réaliser dans le cadre de mon BTS je n'ai plus reussi a me trouver de temps pour m'attarder sur le programme mais en tous cas vos informations mon été tres utiles et je vous dis un grand merci a tous (en esperant que je l'ai ce diplome lol )

    Donc voila, bonne continuation et encore merci!

  18. #38
    Expert confirmé
    Avatar de Sub0
    Homme Profil pro
    Développeur Web
    Inscrit en
    Décembre 2002
    Messages
    3 573
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 51

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : Décembre 2002
    Messages : 3 573
    Points : 4 219
    Points
    4 219
    Par défaut
    De retour parmis vous après 10 ans!!

Discussions similaires

  1. Réponses: 5
    Dernier message: 30/10/2012, 16h38
  2. Réponses: 1
    Dernier message: 02/08/2010, 14h53
  3. Réponses: 6
    Dernier message: 21/07/2008, 19h42
  4. Réponses: 4
    Dernier message: 30/05/2007, 15h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo