Nouveautés LabVIEW 2010 : du côté des palettes

Résumé: LabVIEW 2010 a introduit des améliorations pratiques, notamment dans les palettes de programmation et de contrôles. Les structures de gestion de la mémoire optimisent l’utilisation de la mémoire, essentielles pour les applications embarquées. Les icônes des variables partagées, globales et locales ont été redessinées pour plus de clarté. Une constante de type double a été ajoutée pour simplifier la programmation numérique. L’icône de la constante booléenne a été compactée pour économiser de l’espace. Les fonctions de flux réseau et le client HTTP facilitent le transfert de données et la communication avec les serveurs Web, respectivement. Ces changements visent à améliorer l’efficacité et la lisibilité des diagrammes.

Voici un petit tour d’horizon des nouveautés et changements apporté par LabVIEW 2010 en comparaison avec LabVIEW 2009 mais du point de vue des palettes de programmation et de contrôles. On notera qu’une bonne part des modifications visent l’aspect pratique.

Programmation : structures

On note la migration du la structure élément en place qui était déjà présente dans la version 2009 mais qu’on trouvait dans la palette gestion de la mémoire. Cette structure est bien utile pour optimiser la consommation de la mémoire, ce qu’on mais surtout en pratique pour les applications embarquées (compact RIO ou compact FieldPoint) et pour les logiciels sollicitant fortement la manipulation de données en mémoire (ceci réduisant le nombre de réallocations et facilitant la lecture du diagramme).

Les icones des variables partagées, globales et locales ont changé de look, c’est un peu plus parlant.

Programmation : numérique

Ajout de la constante de type double. Avant il fallait positionner une constante de type entier puis changer sa représentation en double. Maintenant on pose directement la constante double sur le diagramme.

Programmation : booléen

Modification de l’icone de la constante booléenne : il est plus compact. Au lieu d’afficher T/F, il n’affiche que T ou que F, ceci permet d’alléger le diagramme et de gagner de l’espace.

Programmation : E/S sur fichiers

Ici c’est E/S sur fichiers de waveform qui fait sont apparition. C’est la copie des mêmes fonctions qu’on trouve également dans la palette waveform. Elle est donc à deux endroit : palette E/S sur fichiers et palette waveform. L’intérêt c’est qu’on ne risque pas de se dire “bon dieu, mais elle est où cette fonction déjà ?”. Et oui, ce n’est pas incohérent de la mettre aussi là puisqu’on traite un fichier après tout.

La palette des fichiers TDMS a évolué avec l’ajout de fonctions avancées comme ci-dessous.

Dans les fonctions de fichiers avancées, la gestion des bibliothèques empaquetées a été ajoutée. Mais c’est quoi donc ? Et bien pour ceux qui sont familiers avec le langage C, cela se rapproche des librairies statiques : ce sont des VIs compilés dans un même fichier .lvlibp. Les avantages sont : comme c’est déjà compilé ça fait gagner du temps lors de la génération d’un exécutable (pratique pour les gros exe), on peut distribuer ses fonctions à ses collègues plus facilement. Bref on les utilisera surtout pour des projets de grosse envergure et/ou chaque développeur travail sur sa partie.

Programmation : Dialogue et interface utilisateur

La fusion des erreurs est désormais une fonction et non un sous-vi. Outre le côté pratique de cette fonction qui accepte N entrées en l’étirant (à la manière de la fonction construire un tableau), gageons que qu’elle sera plus rapide que la version antérieur en sous-vi. J’en profite pour insister sur l’importance du suivi des erreurs : je ne compte pas le nombre de fois où j’ai gagné du temps tant durant la phase de développement que de la maintenance pour identifier la source d’un bug.

Communication de données

Les fonctions de flux réseau font leur apparition. Elles permettent le transfert sans perte de données et en continue de type waveform. Pour données qui ne sont pas à “flux tendu” ont préfèrera les variables partagées qu’on publiera sur le réseau. C’est simple et c’est efficace.

On note ici aussi le changement de look des icones des variables.

Au niveau des protocoles, c’est l’HTTP client qui a été ajouté. Ceci facilite la programmation car dans les versions antérieures, il fallait tout codé en utilisant les couches basses de la palette TCP. Désormais le dialogue avec un serveur Web est bien plus simple. Exemple d’utilisation : dialogue avec un serveur pour envoyer ou recevoir des informations, comme un mini serveur d’une carte ethernet low cost ou d’un serveur web embarqué dans un automate distant.

Découvrez comment AJOLLY Testing peut apporter de la valeur à vos projets :
🌐 www.ajolly.fr

Nouvelles fonctions de LabVIEW 2009

Résumé : LabVIEW 2009 (version 9.0) a introduit des améliorations significatives, notamment dans les commandes de face avant et les fonctions de diagramme. Parmi les nouveautés, on trouve des commandes numériques de type réservoir, des graphes 3D avancés, et des palettes enrichies pour la programmation numérique et les matrices. La gestion de la mémoire et les informations sur le processeur ont été optimisées, et de nouvelles fonctions pour les variables partagées et le moteur de balayage NI ont été ajoutées, facilitant ainsi la synchronisation et la gestion des défaillances. Ces évolutions visent à améliorer l'efficacité et la clarté du développement sous LabVIEW.

LabVIEW 2009 vient de sortir (on notera que le numéro de la version est en faite la 9.0). En plus des nouveautés annoncées par National Instruments sur son site, j’ai voulu faire un tour d’horizon des nouveautés dans les palettes de commandes en face avant et de fonctions pour les diagrammes. En voici la synthèse (les nouveautés sont encadrées en rouge :

Nouveautés dans les commandes (face avant)

• Numérique

ajout de la commande de type réservoir

• Graphe

ajout du tracé de compas, tracé à barres d’erreur, tracé de plume et matrice de tracés XY et ajout de la palette dédiée au graphe 3D

• Graphe 3D

ajout des graphes 3D de type nuage, barres, camembert, bâtons, rubans, contour, champ vectoriel, comète, surface, maillage et chute d’eau.

 

Nouveautés dans les fonctions (diagramme)

• Programmation, numérique, virgule fixe

ajout de : adapter de virgule fixe à entier, adapter d’entier à virgule fixe

• Programmation, tableau, matrice

nouvelle palette avec : taille de matrice, construire une matrice, redimensionner une matrice, transposée d’une matrice, obtenir la diagonale d’une matrice, obtenir les éléments d’une matrice, obtenir une sous-matrice, définir une diagonale de matrice, définir des éléments de matrice, définir une sous-matrice

• Programmation, cluster, classe et variant

ajout de préserver la classe à l’exécution

• Programmation, E/S sur fichiers, constantes de fichiers

ajout de : obtenir le répertoire système et répertoire de l’application

• Programmation, E/S sur les fichiers, XML, parseur XML

ajout de : obtenir le premier nœud correspondant et obtenir tous les nœuds correspondants. à noter le changement des icones nouveau et fermer.

• Programmation, E/S sur les fichiers, TDM en continu

ajout de : TDMS – convertir le format, créer des informations de mise à l’échelle

• Programmation, contrôle d’applications, contrôle de mémoire

ajout de : nouvelle référence de valeur de données, supprimer une référence de valeur de données

• Programmation, contrôle d’applications, informations sur le processeur

nouvelle palette avec : information sur le processeur, nombre de niveaux de cache, taille du cache de données

• Programmation, waveform, waveforme numérique

ajout de grouper les signaux numériques

• Traitement du signal, opérations sur les signaux

ajout de nœud de délai de transformée en Z

• Mathématiques, équations différentielles, équations différentielles partielles

nouvelle palette avec : définir une EDP, définir un domaine d’EDP, définir la condition aux limites d’une EDP, définir la condition initiale d’une EDP, résolution d’EDP, rendu d’EDP

• Communication de données, variable partagée

ajout de fonctions pour simplifier l’utilisation des variables partagées : établir une connexion à la variable, lire une variable, écrire une variable, fermer une connexion à une variable, nœud de propriété de variable. pour les variable PSP : ouvrir et vérifier la connexion d’une variable, établir une connexion à une variable en arrière plan. pour les variables E/S : lecture par balayage de la variable, écriture par balayage de la variable, lecture directe de la variable, écriture directe de la variable

• Entrées/Sorties de mesures, moteur de balayage NI

nouvelle palette avec : synchronisation avec le moteur de balayage, obtenir la période du moteur de balayage, définir la période du moteur de balayage, obtenir le mode du moteur de balayage, définir le mode du moteur de balayage, rafraichir les modules locaux

• Entrées/Sorties de mesures, moteur de balayage NI, contrainte

nouvelle palette avec : activer les contraintes de variables, désactiver les contraintes de variables, effacer les contraintes de variables, contraindre une variable, annuler une contrainte de variable

• Entrées/Sorties de mesures, moteur de balayage NI, défaillances

nouvelle palette avec : obtenir une liste de défaillances, définir une défaillance, effacer une défaillance, effacer toutes les défaillances

• Entrées/Sorties de mesures, moteur de balayage NI, configuration de défaillances

nouvelle palette avec : définir une configuration de défaillance, effacer une configuration de défaillance, obtenir toutes les configurations de défaillances Découvrez comment AJOLLY Testing peut apporter de la valeur à vos projets : 🌐 www.ajolly.fr

Structuration du code LabVIEW

On peut définir un bon code source par plusieurs caractéristiques : déjà il faut qu’il fonctionne, qu’il soit facile à lire et facile à modifier donc aisément maintenable. Dans ces fins, on recherchera à structurer et non à jeter son code pèle-mêle sur le diagramme. On utilisera la palette de structures avec les boucles FOR ou WHILE, les CONDITIONS, la structure d’événements (pour gérer les actions sur des éléments de l’interface graphique comme un clic sur un bouton) ou encore les séquences, sans oublier les décorations comme les encadrés et les texte pour ajouter des commentaires. Mais aussi des sous-VI qui regrouperons des instructions, se qui allégera les diagrammes, capitalisera les fonctionnalités et ainsi rendra aisé la distribution des sources et qui permettra, en outre, une meilleur gestion des ressources mémoire par le moteur de LabVIEW lors de l’exécution.

Découvrez comment AJOLLY Testing peut apporter de la valeur à vos projets :
🌐 www.ajolly.fr

LabWindows/CVI 9.0 : les tables dynamique

Avec l'implémentation du standard C99, une avancé est fait quant à la gestion de la mémoire : la déclaration de tables dynamiques (variable-length arrays in english).

Vous me direz, les tables je connais, je la déclare un tableau de dix entiers en dimensionnant avec une constante comme suit : int iTable[10]. Les tables dynamiques, ok je connais, je déclare un pointeur puis je fais un malloc ou calloc pour la dimmensionner avec une variable, en n'oubliant pas de libérer la mémoire allouée avec un free à la fin du traitement.

Alors que sont les variable-length arrays ?

C'est la possibilité de declarer des tables en les dimensionnant avec des variables et non plus qu'avec les seules constantes.

Voici deux exemples pour illustrer l'utilisation d'un tableau dynamique : On demande à l'utilisateur de dimmensionner une table que l'on alloue puis on affiche le contenu de cette table.

AVANT
int rows, cols;
int i, j;
int *piTable = NULL;

printf("Entrez le nombre de ligne de la table: ");
scanf("%d", &iNbLigne);
printf("Entrez le nombre de colonne de la table: ");
scanf("%d", &iNbColonne);

*piTable = (int*)malloc(iNbLigne*iNbColonne*sizeof(int));
if (piTable != NULL)
{
  for (int i = 0; i < iNbLigne;i++)
  {
    for (int j = 0; j <iNbColonne;j++)
    {
      piTable[i][j] = i*iNbColonne + j;
      printf("%d ", piTable[i][j]);
    }
    printf("\n");
  }
}
free(piTable);
piTable = NULL;

MAINTENANT

Dans le code suivant, on utilise également une autre nouveauté de la C99 : la déclaration des variables n'est plus cantonnée au début des blocs { }.

int iNbLigne, iNbColonne;
int i, j;

printf("Entrez le nombre de ligne de la table: ");
scanf("%d", &iNbLigne);
printf("Entrez le nombre de colonne de la table: ");
scanf("%d", &iNbColonne);

int tiTable[iNbLigne][iNbColonne];
for (int i = 0; i < iNbLigne; ++i)
{
  for (int j = 0; j < iNbColonne; ++j)
  {
    tiTable[i][j] = i*iNbColonne + j;
    printf("%d ", tiTable[i][j]);
  }
  printf("\n");
}

Ici, la libération de la mémoire alouée à tiTable est effectuée à la fin de "vie" de cette variable. Comme tiTable est une variable locale, elle sera désalouée à la fin du traitement la fonction dans laquelle elle est déclarée.

Découvrez comment AJOLLY Testing peut apporter de la valeur à vos projets :
🌐 www.ajolly.fr