Comment mettre à jour glut fenêtre en continu?

J'ai un robot réel qui est de la commande de mon robot virtuel en open gl. Je veux montrer à chaque mouvement de mon maître robot(robot réel) de l'esclave (virtuel en open gl) en ligne, donc j'ai besoin de mettre à jour mon glut fenêtre en permanence, en fait, tant que réel les mouvements du robot my virtual on se déplace aussi, et tous ces mouvements devraient être en ligne.

- Je obtenir des données à partir de maître avec toujours obtenir les données de la fonction, mais je ne sais pas comment je devrais mettre à jour la fenêtre.

Voici mon code:

********************************************/

  void OnIdle(void){  
initSocket();
printf("\n  Defining Step Time Parameters and Initial Conditions for solving Dynamic equations\n");
xi=0;
xf=0.1;
printf("\n    end value x         : %f ",xf); 
i=0;  yi[i]=0; 
i++;yi[i]=-1.570796;
i++;yi[i]=-1.570796;
i++;yi[i]=0;
i++;yi[i]=0;
i++;yi[i]=0;
ndata=2; fi=1;
double counter=0.1;
Eqdifp(v1,v2,v3,v4,v5,v6,xi,xf,yi,ndata,p,fi);
for(int i=0;i<50;i++)
//while(1)
{
getData();
printf("\n");
for(int i=0;i<6; i++)
{
printf("%d = %.3f\n", i,drecvbuf[i]);
}
printf("\n");
yi[0]=v1[ndata];
yi[1]=v2[ndata];
yi[2]=v3[ndata];
yi[3]=v4[ndata];
yi[4]=v5[ndata];
yi[5]=v6[ndata];
printf("my nadata %f\n",v1[ndata]);
counter=counter+0.1;
Eqdifp(v1,v2,v3,v4,v5,v6,xi,xf,yi,ndata,p,fi);
glutPostRedisplay();
}
}
/////////////////////////////////////////////////////
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(900,500);
int u=glutCreateWindow("3DOF robot");
myinit();
createMenu();
glutIdleFunc (OnIdle);
glutDisplayFunc(Display);
glutReshapeFunc(reshape);
glutKeyboardFunc(KeyDown);
glutMainLoop(); 
System::Timers::Timer^ aTimer = gcnew System::Timers::Timer( 100 );
//Hook up the Elapsed event for the timer.
aTimer->Elapsed += gcnew System::Timers::ElapsedEventHandler( OnTimedEvent );
//Set the Interval to 2 seconds (2000 milliseconds).
aTimer->Enabled = true;
return 0;
}
Ne voulez pas le marquer comme tel, car je ne suis pas familier, mais System::Timers::Timer^ aTimer = gcnew System::Timers::Timer( 100 ); semble que C++/CLI pour moi?
Dès que vous voyez un ^ il est certainement en C++/CLI.
en fait, gcnew est beaucoup plus l'indicateur de C++/CLI. ^ est un opérateur valide en C++standard.
Oui, vous avez raison, n'ont pas pensé, xor.

OriginalL'auteur Likak | 2011-07-23

  1. 8

    Vous pouvez appeler glutPostRedisplay après la mise à jour, où les horaires de la fenêtre pour être redessiné (à l'aide de SURABONDANCE de l'affichage de la touche func, bien sûr) dès qu'il revient à la file d'attente de messages, je pense.

    Mais cela ne fonctionnera pas si vous êtes constamment à l'interrogation du robot de données dans une boucle infinie que cette permanence bloque le programme. Ce que vous devez faire est d'utiliser une minuterie pour programmer le robot de mise à jour à intervalles réguliers, de sorte qu'entre ces mises à jour, le programme peut revenir à la boucle d'événements et de redessiner la fenêtre. Ou vous pouvez appeler une fonction, qui raconte le cadre de la visite de la boucle d'événements. L'exemple de code n'a pas vraiment expliquer comment vous faites ça pour le moment (ou je ne suis pas familier avec les fonctions que vous appelez).

    chère Christine,tnx pour votre réponse
    en fait im nouveau avec open gl et même en c++, pas très professionnel.
    donc , je préfère utiliser opengl de la fonction de quelque chose que l'on vous dit(glutPostRedisplay), mais je ne sais pas comment. j'ai besoin de quelque chose de pas si complexe!
    j'ai édité le code et c'est la manière suggérée j'ai essayé mais ça n'a pas fonctionné, je n'ai pas compris:((
    Par la voie, glutPostRedisplay n'appartient PAS à l'OpenGL, mais à l'EXCÈS. OpenGL est une interface de programmation du matériel graphique (affichage de choses), alors que GLUT est une interface graphique abstraction de la bibliothèque de rendre la création de simples programmes OpenGL plus facile. Mais OpenGL n'a rien à voir avec des tâches telles que l'interface graphique ou la gestion des événements.

    OriginalL'auteur Christian Rau

  2. 2

    GLUT vous offre un ralenti de rappel (void (*)(void) signature), défini par glutIdleFunc. Récupérer le robot d'entrée de données dans le vide gestionnaire. Ou utiliser un thread séparé d'interrogation de données, le remplissage des structures de données; l'utilisation d'un sémaphore pour déverrouiller inactif lorsque de nouvelles données sont arrivés, utiliser un dispositif de verrouillage avec délai d'attente de sorte que votre programme est interactif. Pseudo:

    Semaphore robot_data_semaphore;
void wait_for_data(void)
{
SemaphoreLockStatus lock_status = 
semaphore_raise_timeout(robot_data_semaphore, RobotDataTimeout);
if( lock_status == SEMAPHORE_RAISED ) {
update_scene_with_robot_data();
semaphore_lower(robot_data_semaphore);
glutPostRedisplay();
}
}
void main(int argc, char *argv[])
{
/* ... */
semaphore_init(robot_data_semaphore);
Thread thread_robot_data_poller = thread_create(robot_data_poller);
glutIdleFunc(wait_for_data);
/* ... */
thread_start(thread_robot_data_poller);
glutMainLoop();
}
    j'ai essayé ce que vous avez dit, mais ça n'a pas fonctionné, j'ai changé les codes, et utilisé votre chemin, pourriez-vous prendre un coup d'oeil, et de dire ce qui est avec qui?tnx beaucoup:)
    Le régime de ralenti gestionnaire doit retourner à l'intérieur à propos de 50ms à garder le programme adapté. Aussi l'écran de mise à jour n'arrivera pas jusqu'à ce que le ralenti gestionnaire retourné. glutPostRedisplay juste définit le drapeau. Dans le vide de gestionnaire, vous devriez donc ce que vous devez placer dans la branche par défaut d'un événement boucle de traitement – sans la boucle.
    voulez-vous corriger les codes dans une manière que vous dites! J'ai essayé beaucoup de façons, mais il ne marche pas.
    Pour cela, j'avais besoin de la totalité du code source, étant donné que la partie que vous avez posté ne contient pas de suffcient de l'information.

    OriginalL'auteur datenwolf

  3. 0

    Je voudrais faire le suivant. Traiter glutMainLoop() que votre boucle et à chaque fois que vous traitez un getData() vous le dessiner, il sera plus rapide que vous le pensez.

    Ce qui doit arriver pour vous d'obtenir une "continu" mise à jour est de:

    1. De données de processus (getData() ensuite vos calculs)
    2. Redraw (Display() glut appelle cela chaque fois qu'il fait une boucle)
    3. Autres fonctions définies à l'aide de glut_____Func()
    4. À 1

    Glut continue jusqu'à ce que le programme est quitté.

    //called every time glutMainLoop
//do data processing
void OnIdle(void)
{  
getData();
printf("\n");
for(int i=0;i<6; i++)
{
printf("%d = %.3f\n", i,drecvbuf[i]);
}
printf("\n");
yi[0]=v1[ndata];
yi[1]=v2[ndata];
yi[2]=v3[ndata];
yi[3]=v4[ndata];
yi[4]=v5[ndata];
yi[5]=v6[ndata];
printf("my nadata %f\n",v1[ndata]);
Eqdifp(v1,v2,v3,v4,v5,v6,xi,xf,yi,ndata,p,fi);
}
//also called every loop of glutMainLoop
void Display()
{
...
//Your previous Display() function just add this:
glutPostRedisplay(); //everytime you are done 
//drawing you put it on the screen
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(900,500);
int u=glutCreateWindow("3DOF robot");
myinit();
createMenu();
glutIdleFunc (OnIdle);
glutDisplayFunc(Display);
glutReshapeFunc(reshape);
glutKeyboardFunc(KeyDown);
///////////////
//SETUP YOUR INITIAL DATA
System::Timers::Timer^ aTimer = gcnew System::Timers::Timer( 100 );
//Hook up the Elapsed event for the timer.
aTimer->Elapsed += gcnew System::Timers::ElapsedEventHandler( OnTimedEvent );
//Set the Interval to 2 seconds (2000 milliseconds).
aTimer->Enabled = true;
initSocket();
printf("\n  Defining Step Time Parameters and Initial Conditions for solving Dynamic equations\n");
xi=0;
xf=0.1;
printf("\n    end value x         : %f ",xf); 
i=0;  yi[i]=0; 
i++;yi[i]=-1.570796;
i++;yi[i]=-1.570796;
i++;yi[i]=0;
i++;yi[i]=0;
i++;yi[i]=0;
ndata=2; fi=1;
Eqdifp(v1,v2,v3,v4,v5,v6,xi,xf,yi,ndata,p,fi);
//////////////
//Start the Main Loop
glutMainLoop(); //This statement blocks, meaning that until you exit the 
//glut main loop no statments past this point will be executed.
return 0;
}

    OriginalL'auteur Gideon W