problème arrêt acquisition sur graphique CVI

[ledon2904]

Bonjour,

voici mon problème :

   je fais l'acquisition de température en continue mais je souhaiterais l'arrêter aprés un certain temps

Le problème c'est que plus je diminue mon sleep plus plus l'acquisition sur le graphique mets de tempsà s'arrêter

voici mon programme

#include "graphessai.h"


#include <windows.h>
#include <NIDAQmx.h>
#include <formatio.h>
#include <analysis.h>
#include <ansi_c.h>
#include <cvirte.h>    
#include <userint.h>

#define echelletc                30
#define offsettc                -50
#define nbpointtc                10
#define NUM_PLOTS           20100
#define ABS_DATE_TIME_FORMAT_STRING "%X  %B %#d, %Y"
#define REL_DATE_TIME_FORMAT_STRING "%#M:%S.%3f"
#define MSG_FORMAT_STRING "Current window: %s  -  %s"


static int PanelHandle, PlotArray[NUM_PLOTS] = { 0 }, CurrentPlotIndex;
static double StartTime;
static void TakeSample (void);
double tc1[10];
double tc_mean;
double curTime;
TaskHandle tc1_task; 


int main (int argc, char *argv[])
{
    if (InitCVIRTE (0, argv, 0) == 0)
        return -1;  /* out of memory */
    if ((PanelHandle = LoadPanel (0, "Graphessai.uir", PANEL)) < 0)
        return -1;
 
    DAQmxCreateTask("TC1",&tc1_task);
    DAQmxCreateAIVoltageChan (tc1_task, "PXI1Slot5/ai6", "", DAQmx_Val_RSE, 0, 10, DAQmx_Val_Volts, "");
    DisplayPanel (PanelHandle);
    RunUserInterface ();
    DiscardPanel (PanelHandle);
    return 0;
}


int CVICALLBACK QuitCallback (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event)
    {
    case EVENT_COMMIT:
        QuitUserInterface (0);
        break;
    }
    return 0;
}


static void TakeSample (void)
{
    double value;
      
    double i;

    for(i=0;i<20/0.001;i++){
            DAQmxReadAnalogF64 (tc1_task, 10, 10.0, DAQmx_Val_GroupByChannel, tc1, 10, NULL, 0);
    Mean (tc1, 10, &tc_mean);
     if (StartTime == 0.)
    {
        StartTime = curTime;
     
    }

    GetCurrentDateTime (&curTime);
   
       
   
     
    value = tc_mean * echelletc+offsettc; 
        
    // gPlotArray is a circular buffer; if we've looped around, discard the old plot
    if (PlotArray[CurrentPlotIndex])
        DeleteGraphPlot (PanelHandle, PANEL_GRAPH, PlotArray[CurrentPlotIndex], VAL_DELAYED_DRAW);
   
   PlotArray[CurrentPlotIndex] =PlotXY (PanelHandle, PANEL_GRAPH, &curTime, &value, 1, VAL_DOUBLE,
        VAL_DOUBLE, VAL_CONNECTED_POINTS, VAL_EMPTY_DIAMOND, VAL_SOLID, 1, VAL_RED);
   
              Sleep (1);   
        if (++CurrentPlotIndex == NUM_PLOTS)
      
        CurrentPlotIndex = 0;
       
       

   

   
             
    }
}

int CVICALLBACK START (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event)
    {
        case EVENT_COMMIT:

         TakeSample ();
          

            break;
    }
    return 0;
}
j'aimerais que l'acquisition s'arrête au bout de 20 SEcondes (juste pour l'exemple plus tard il faudra que je l'arrête au bout de 24 h)) mais mon programme s'arrête environ 25 minutes plus tard

si quelqu'un à une idée elle serait la bienvenue

Cordialement

[stef_fr]

Bonjour,

Votre fonction "TakeSample" capture 20000 fois 10 échantillons, calcule leur moyenne, puis les trace. Sa durée d'éxecution dépend du temps passé dans la fonction  =  20000 x (temps passé dans DAQmxReadAnalogF64 + temps de moyennage + affichage dans le graphe ).

"TakeSample" profite du temps passé dans la fonction sleep pour rafraichir l'affichage et traiter les évènements, si ce temps est trop court tout devra être rafraichit à la fin de la fonction.

Dans un cas comme le votre on procède généralement de la façon suivante :

1-on lance une tache d'acquisition (indépendante de l'interface graphique) qui accumule les échantillons dans une mémoire tampon

2-périodiquement (plusieurs fois par seconde) on extrait un paquet d'échantillons de la mémoire tampon pour les afficher à l'écran et les sauvegarder dans un fichier (cela permet de ne pas avoir à tout recommencer si l'acquisition plante ou bout de 23h59mn).

Cette méthode permet de conserver une interface avec l'utilisateur réactive (on peut interrompre quand on veut l'acquisition, changer les paramètres d'affichage du graphe à la volée ...) tout en assurant un échantillonnage à fréquence fixe.

Cordialement,

Stéphane

[ledon2904]

Bonjour,

merci pour cette éclaircissement!

Mais concrétement comment on créé une mémoire tampon?

Pour l'instant tout ce que j'arrive à faire c'est avec pas mal de chance (cela fais 6 semaines que j'utilise CVI)

Merci d'avance

[stef_fr]

Bonjour,

Je n'utilise pas DAQmx pour mes applications du coup je ne l'ai pas installé et je n'ai pas accés à l'aide. Cependant ces fonctionalités étaient déjà disponibles dans le driver précédent (NIDAQ). D'après les quelques documents présent sur le site de NI, la création de mémoire tampon se fait certainement à l'initialisation de la tache d'acquisition (fonction DAQmxCfgSampClkTiming je pense). Le lancement de la tache se fera avec DAQmxStartTask et l'arret avec DAQmxStopTask puis DAQmxClearTask. Pour la lecture des données et le rafraichissement du graphe, il est possible de créer un évenement qui sera déclenché tout les N échantillons acquis (fonction DAQmxRegisterEveryNSamplesEvent). C'est dans la fonction associée a cet évènement qu'il faudra utiliser la fonction "xxxRead" pour lire vos échantillons et les afficher. A vous de dimensionner la mémoire tampon et le nombre d'échantillons qui provoquent l'évènement afin d'obtenir un rafraichissement du graphe plusieurs fois par seconde. J'espère que cela va vous aider ... sans carte d'acquisition et sans aide sur l'API de DAQmx je ne peux pas vous en dire beaucoup plus !  Fouillez dans les exemples de code, il y a certainement un exemple d'acquisition avec mémoire tampon (Buffered acquisition) et un autre sur les évènements DAQmx.

cordialement,

Stéphane