SDK
  SDK

Table des matières

Introduction au kit de développement logiciel de GO2cam

Définition du kit de développement logiciel

Le kit de développement logiciel de GO2cam permet une ouverture en langage interprété Pascal, ou en COM Windows (VB net, C++, C#, ...) de la base de donnée GO2cam. Il permet d'écrire des macros qui vont intéragir avec GO2cam afin d'éxécuter des tâches automatisées. Une macro écrite en Pascal interprété peut être exécutée automatiquement au lancement de GO2cam. Il suffit d'ajouter les paramètres "-s nom_fichier_macro" au raccourci de lancement.

Exemple :

GO2cam.exe -s TEST.SPI

Le kit de développement logiciel permet :

  • De créer une boite de dialogue de paramètres.
  • De gérer les données de la boite de dialogue.
  • De lire de la géométrie GO2cam.
  • De créer de la géométrie GO2cam.
  • De lire des usinages GO2cam

Une macro GO2cam est un fichier ASCII de type Pascal qui est interprété par GO2cam. Son extension doit être SPI ou PPI.

Dans le répertoire :

  • **./process/std** sont définies les macros géométrique standard ".PPI".
  • **./process/specif** sont définies les macros géométrique spécifique ".SPI".

Un fichier d'erreur Pascal.ERR est créer si l’exécution de la macro s'est mal déroulée. Il récapitule les erreurs de syntaxes ou d’exécution en indiquant le numéro de ligne problématique.

Utilisation du kit de développement logiciel

En passant par le menu outils/macros spécifiques, un navigateur de fichiers permet de sélectionner la macro à exécuter. Une fois la macro sélectionnée, une éventuelle boite de dialogue contenant les paramètres s'affiche si nécessaire. Il suffit alors de cliquer sur le bouton confirmer de la boite de dialogue, après avoir saisi les paramètres désirés, pour lancer l'exécution de la macro. En cas de problème la combinaison de touche ctrl+z permet de revenir à l'état initial.

Remarques
Il est possible de sélectionner une macro dans l'explorateur de fichiers Windows et de le lâcher dans GO2cam (Drag and Drop).
Cela entraîne l'exécution de la macro.

Comment accéder à la bibliothèque des fonctions ?

Il est nécessaire de connaître ou d'avoir des notions de programmation avant de commencer à écrire des macros. Les fonctions de la bibliothèque sont appelées par 3 mots clef Pascal.

  • PCALL(nom de la fonction, liste de paramètres ...); Procédure ne retournant pas de résultat.
  • ICALL(nom de la fonction, liste de paramètres ...); Procédure retournant un résultat entier (fonction).
  • RCALL(nom de la fonction, liste de paramètres ...); Procédure retournant un résultat réel (fonction).

Comment créer une macro

Préparation du fichier de la macro

Le fichier est composé de 2 (ou 3) procédures Pascal.

{************************************}
{********** Macro GO2cam **********}
{************************************}
{ Définition des paramètres de la macro }
PROCEDURE PPI_PARAMETRE_PROCESSUS;
BEGIN
END;
{ Gestion et Mise à jour des paramètres de la macro. Procédure optionnel}
PROCEDURE PPI_MAJ_PARAMETRE_PROCESSUS;
BEGIN
END;
{ Exécution de la macro }
PROCEDURE PPI_ATELIER_PROCESSUS;
BEGIN
END;
  • PPI_PARAMETRE_PROCESSUS : Cette procédure Pascal est appelée par GO2cam pour la construction de la boite de dialogue de la macro. Elle permet de définir les paramètres à afficher dans la boite de dialogue.
  • PPI_MAJ_PARAMETRE_PROCESSUS : Cette procédure Pascal est optionnelle. Elle permet de gérer les entrées d'une boite de dialogue. Par défaut GO2cam utilise sa propre gestion de mise a jour des champs de la boite de dialogue.
  • PPI_ATELIER_PROCESSUS : Cette procédure est le moteur de la macro. Elle décrit les actions à mener tout au long de l'éxécution de la macro.

Définition des Paramètres

La définition des paramètres se passe dans la procédure de défintion de la boite de dialogue : PPI_PARAMETRE_PROCESSUS.

Elle doit contenir :

  • Le titre de la boite de dialogue.
  • Le positionnement des paramètres.
  • Le type d'affichage des paramètres.
  • La valeur d'initialisation des paramètres.

SPI_WIN_write_title_param

La fonction SPI_WIN_write_title_param permet de créer le titre de la boite de dialogue.

Exemples :

PCALL(SPI_WIN_write_title_param, 'Ma boite de dialogue');

SPI_WIN_write_newpage_param

La fonction SPI_WIN_write_newpage_param permet de créer un nouvel onglet dans la boite de dialogue. Tous les paramètres définis après cette fonction s'afficheront dans cet onglet.
La taille finale de la boite de dialogue sera la taille du plus grand des onglets.

Exemples :

PCALL(SPI_WIN_write_newpage_param);

SPI_WIN_write_title_page_param

La fonction SPI_WIN_write_title_page_param permet de créer un titre sur l'onglet courant.

Exemples :

PCALL(SPI_WIN_write_title_page_param, 'Mon onglet');

SPI_WIN_write_format_param

La fonction SPI_WIN_write_format_param définie le format d'affichage et le positionnement du paramètre dans la boite de dialogue. Un certain nombre de format sont disponibles en fonction du type de paramètre souhaité.

Exemples :

PCALL(SPI_WIN_write_format_param, 0, 5, 250, 10, 0);
{ permettra d'obtenir un format de type 0, de positionner le paramètre sur la ligne 0.5 }
{ dans la colonne 25 et le champ disposera de 10 caractères de saisie. }

SPI_WIN_write_inactive_param

La fonction SPI_WIN_write_inactive_param permet de griser un champ par défaut.

Remarques
Par défaut, un champ est toujours actif (non grisé).

SPI_WIN_write_domain_param

La fonction SPI_WIN_write_domain_param permet de spécifier le domaine d'utilisation d'un paramètre.
La fonction de définition du domaine doit être positionnée entre le format du paramètre et sa définition.
La fonction de définition du domaine est optionnelle.
Le domaine est défini par une liste de valeurs ou d'intervalle que le paramètre peut accepter. Cette fonction n'est utilisable qu'avec les paramètres de type entier ou réel.

Exemples :

Pour un entier : '[10,20,30,50..60,80..100]'
Valeur possible 10 ou 20 ou 30.
Intervalle possible entre 50 et 60 ou 80 et 100

Pour un réel : '[0.0..3.14159,6.283]'
Valeur possible 6.283
Intervalle possible entre 0.0 et 3.14159

Paramètres disponibles

Six types de paramètres sont disponibles.
Un paramètre est défini par son label qui permettra de le repérer et de l'utiliser.
Un paramètre de type commentaire ou séparateur peut embellir la boite de dialogue, mais ne peut pas avoir de valeur.

  • Booléen : SPI_WIN_write_boolean_param
  • Entier : SPI_WIN_write_integer_param
  • Réel: SPI_WIN_write_real_param
  • Chaîne : SPI_WIN_write_string_param
  • Commentaire : SPI_WIN_write_comment_param
  • Séparateur : SPI_WIN_write_frame_param

Exemples :

PCALL(SPI_WIN_write_real_param,'DIAMETRE','Diamètre du trou :',40.0);

Permet de créer un paramètre de type réel qui aura comme label 'DIAMETRE'.
Le champ de saisie aura comme légende : 'Diamètre du trou :' et la valeur par défaut sera 40.0.

Le code suivant permet d'afficher et saisir un diamètre, une profondeur et une précision dans une boite de dialogue.

PROCEDURE PPI_PARAMETRE_PROCESSUS;
BEGIN
PCALL(SPI_WIN_write_title_param, 'Paramètres trou');
PCALL(SPI_WIN_write_format_param, 0, 5, 200, 10, 0);
PCALL(SPI_WIN_write_domain_param, '[1.0..40]');
PCALL(SPI_WIN_write_real_param, 'DIAMETRE', 'Diamètre du trou :', 40.0);
PCALL(SPI_WIN_write_format_param, 0, 20, 200, 10, 0);
PCALL(SPI_WIN_write_real_param, 'PROF', 'Profondeur du trou :', 20.0);
PCALL(SPI_WIN_write_format_param, 0, 35, 200, 10, 0);
PCALL(SPI_WIN_write_domain_param, '[0.001..0.5]');
PCALL(SPI_WIN_write_real_param, 'PREC', 'Précision du trou :', 0.1);
END;
Remarques
  • Ne pas oublier de formater les paramètres avant chaque appel.
  • Le domaine de définition du paramètre n'est pas obligatoire mais il permet de filtrer des valeurs parasites lors de la saisie.
  • Le domaine doit être positionne entre le format et la définition du paramètre pour être pris en compte.
  • Définir des labels de paramètres courts (moins de 20 caractères).
  • Définir pour chaque nouveau paramètre un label différent.

Fichiers crées automatiquement par les SPIs

Les dernières valeurs saisies dans la boite de dialogue par l'utilisateur, sont stockées dans un fichier .USR.
Par exemple, si la macro s’appelle TEST.SPI, GO2cam créera le fichier TEST.SPI.USR dans le répertoire process/user.

Au prochain lancement, les valeurs sauvegardées seront lues et remplacerons les valeurs par défauts de la boite de dialogue.
La fonction SPI_WIN_ignore_usr permet d'ignorer les dernières valeurs stockées.

Gestion de la mise à jour de la boite de dialogue

Cette gestion de mise à jour se fait dans la procédure PPI_MAJ_PARAMETRE_PROCESSUS.
Cette procédure est optionnelle. Par défaut GO2cam utilise sa propre gestion de mise a jour des champs de saisie.
Son utilisation permet de personnaliser la gestion d'une boite de dialogue en interagissant avec les paramètres de plusieurs façons :

  • Griser ou dégriser des champs.
  • Recalculer un champ en fonction d'autres champs.
  • Interdire certaines valeurs.
  • ...
Remarques
Toute la mise à jour de la boite de dialogue se fait dans cette procédure à partir du moment ou elle est utilisée. Il n'est pas possible de l'utiliser en partie en la mixant avec la gestion des boites de dialogue faite par GO2cam.

Comment lire la valeur courante ?

La fonction SPI_WIN_read_current_panel permet de récupérer le champ modifié en indiquant son label de référence, son type et la valeur entrée par l'utilisateur.

Comment mettre à jour une valeur de la boite de dialogue ?

Il suffit de connaître le label de référence du paramètre à mettre à jour. 4 fonctions sont disponibles pour cette mise à jour :

  • SPI_WIN_write_integer_panel : permet d'écrire une valeur entière.
  • SPI_WIN_write_boolean_panel : permet d'écrire une valeur booléenne.
  • SPI_WIN_write_real_panel : permet d'écrire une valeur réelle.
  • SPI_WIN_write_string_panel : permet d'écrire une valeur de type chaîne.

Comment griser ou dégriser une valeur ?

La fonction SPI_WIN_write_state_panel permet de griser ou dégriser le champ référencé par son label.

Comment changer une image (Booléen) ?

La fonction SPI_WIN_write_bitmap_panel permet de changer l'image d'un paramètre booléen référencé par son label.

Comment changer une liste de choix (Entier) ?

La fonction SPI_WIN_write_wordlist_panel permet de changer la liste de choix d'un paramètre entier référencé par son label.

Comment lire une valeur dans la boite de dialogue ?

Il suffit de connaître le label de référence du paramètre. 4 fonctions sont alors disponibles :

  • SPI_WIN_read_integer_panel : permet de lire une valeur entière.
  • SPI_WIN_read_boolean_panel : permet de lire une valeur booléenne.
  • SPI_WIN_read_real_panel : permet de lire une valeur réelle.
  • SPI_WIN_read_string_panel : permet de lire une valeur de type chaîne.

Exemples :

PROCEDURE PPI_PARAMETRE_PROCESSUS;
BEGIN
{**** Ouverture et saisie dans la boite de dialogue ****}
PCALL(SPI_WIN_write_title_param, 'Taraudage');
PCALL(SPI_WIN_write_format_param, 0, 1, 200, 10, 0);
PCALL(SPI_WIN_write_boolean_param, 'CHOIX', 'Petit-Grand', 0);
PCALL(SPI_WIN_write_format_param, 1, 15, 200, 10, 0);
PCALL(SPI_WIN_write_integer_param, 'DIAMETRE', 'Diamètre:-M2-M3-M4-M5-M6-M7-M8', 1);
PCALL(SPI_WIN_write_format_param, 2, 1, 10, 45, 13);
PCALL(SPI_WIN_write_boolean_param, 'ICONE', '@B114.BMP', 0);
END;
PROCEDURE PPI_MAJ_PARAMETRE_PROCESSUS;
VAR ival,itype,ival1:INTEGER;
rval:REAL;
sval,lab:TC80;
BEGIN
{*Mise a jour de la valeur*}
PCALL(SPI_WIN_read_current_panel, lab, itype, ival, rval, sval);
CASE (itype) OF
1:BEGIN {Boolean}
PCALL(SPI_WIN_write_boolean_panel, lab, ival);
END;
2:BEGIN {Entier}
PCALL(SPI_WIN_write_integer_panel, lab, ival);
END;
3:BEGIN {Reel}
PCALL(SPI_WIN_write_real_panel, lab, rval);
END;
4:BEGIN {Chaine}
PCALL(SPI_WIN_write_string_panel, lab, sval);
END;
END;
{*Mise a jour des etats*}
PCALL(SPI_WIN_read_boolean_panel, 'CHOIX', ival);
IF (ival = 0) THEN
PCALL(SPI_WIN_write_wordlist_panel, 'DIAMETRE', 'M2-M3-M4-M5-M6-M7-M8')
ELSE
PCALL(SPI_WIN_write_wordlist_panel, 'DIAMETRE', 'M12-M14-M16-M20-M26-M32');
PCALL(SPI_WIN_read_integer_panel, 'DIAMETRE', ival1);
CASE (ival1) OF
1:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B224.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B114.BMP');
END;
2:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B225.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B115.BMP');
END;
3:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B226.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B116.BMP');
END;
4:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B227.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B117.BMP');
END;
5:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B228.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B118.BMP');
END;
6:BEGIN
IF (ival = 0) THEN
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B229.BMP')
ELSE
PCALL(SPI_WIN_write_bitmap_panel, 'ICONE', 'B119.BMP');
END;
END;
END;

Définition de la procédure d'exécution de la macro

La définition de l'exécution de la macro se fait dans la procédure PPI_ATELIER_PROCESSUS.
Cette procédure permet d'avoir une intéraction avec la base de donnée GO2cam dans le but de lire et/ou d'écrire des entités géométriques.
Elle permet également de lire des cycles d'usinage afin d'en extraire des informations (temps, vitesse, liste des outils, ...)

Lecture des paramètres de la boite de dialogue

Les fonctions de lecture des paramètres de la boite de dialogue sont au nombre de 4. Elle sont utilisées en fonction du type du paramètre à lire :

  • SPI_WIN_read_integer_param : Lecture d'un paramètre entier
  • SPI_WIN_read_boolean_param : Lecture d'un paramètre booléen
  • SPI_WIN_read_real_param : Lecture d'un paramètre réel
  • SPI_WIN_read_string_param : Lecture d'un paramètre chaîne

Exemples :

Pour lire la valeur d'un parametre réel ayant pour label "VALEUR_REELLE" dans la variable "rVal", il faudra utiliser la fonction :

PCALL(SPI_WIN_read_real_param, 'VALEUR_REELLE', rVal);

Gestion de la base de donnée géométrique

Lecture de la base de donnée géométrique

Principe : parcourir la base de donnée géométrique et tester si l'entité est valide (non supprimée, active).

  • SPI_GEO_last_elt : Lecture du nombre d'élément géométrique de la base de donnée GO2cam.
  • SPI_GEO_valid_elt : Test si l'élément géomtrique de la base de donnée est valide.
  • SPI_GEO_read_mark_elt: Test si l'élément géométrique de la base de donnée est marqué.

Exemples :

Boucle sur les éléments valides et sélectionnés de la base de données.

PPI_ATELIER_PROCESSUS;
VAR ind,nbelt:INTEGER;
BEGIN
nbelt := ICALL(SPI_GEO_last_elt);
FOR ind:= 1 TO nbelt DO
IF ICALL(SPI_GEO_valid_elt, ind) = SPI_YES THEN
IF ICALL(SPI_GEO_read_mark_elt, ind) = SPI_YES THEN
writeln('Elément valide :',ind);
END;

Comment lire une entité géométrique ?

Pour travailler sur une entité géométrique, il faut connaître son indice de base de donnée. Il faut également tester qu'elle soit valide c'est à dire non supprimée.

  • SPI_GEO_read_type_elt : Lecture du type de l'entité (SPI_ELTTYPE_POINT ...).
  • SPI_GEO_read_layer_elt : Lecture du numéro de couche de l'entité.
  • SPI_GEO_read_color_elt : Lecture du numéro de couleur de l'entité (SPI_COLOR_BLUE ...).
  • SPI_GEO_read_linetype_elt : Lecture du type de trait de l'entité (SPI_LINETYPE_AXES ...).
  • SPI_GEO_read_linewidth_elt : Lecture de l' épaisseur de trait de l'entité (SPI_LINEWIDTH_DOUBLE ...).
  • SPI_GEO_read_mater_elt : Lecture du matériau de l'entité.
  • SPI_GEO_read_plane_elt : Lecture du numéro de plan de l'entité.
  • SPI_GEO_read_mark_elt : Test si l'entité est sélectionnée ou non (retour : SPI_YES / SPI_NO).
  • SPI_GEO_read_name_elt : Lecture du label de l'entité.
  • SPI_GEO_read_params_elt : Lecture du tableau de réel de la forme canonique de l'entité.

Exemples :

Affiche les élément valides de la base de donnée.

PROCEDURE PPI_ATELIER_PROCESSUS;
VAR i,j,nb,itype : INTEGER;
cl,cc,plan,ierr : INTEGER;
mot : TC80;
elt : TR9;
rval : REAL;
BEGIN
{*Lecture de la base de donnée géométrique*}
nb := ICALL(SPI_GEO_last_elt);
writeln('nombre d'élément dans la base de donnée : ', nb);
FOR i:= 1 TO nb DO
BEGIN
IF ICALL(SPI_GEO_valid_elt, i) = SPI_YES THEN
BEGIN
itype := ICALL(SPI_GEO_read_type_elt, i);
cc := ICALL(SPI_GEO_read_layer_elt, i);
cl := ICALL(SPI_GEO_read_color_elt, i);
plan := ICALL(SPI_GEO_read_plane_elt, i);
ierr := ICALL(SPI_GEO_read_name_elt, mot, i);
writeln('itype : ',itype,' lab :', mot, cc, cl, plan);
ierr := ICALL(SPI_GEO_read_params_elt, 9, elt, i);
FOR j:= 0 TO 8 DO writeln(' ',j,' :',elt[j],' ');
END
END
END;

Comment afficher une entité géométrique ?

Il est possible de rafraîchir l'affichage d'une entité géométrique ou de toute la base de donnée géométrique.

  • SPI_DRAW_draw_elt : Affiche une entite.
  • SPI_DRAW_redraw : Affiche toute la base de donnée.

Comment modifier une entité géométrique ?

Chaque fonction de lecture de la base de donnée à une fonction équivalente pour l'écriture.
La modifidification des entités géométriques se fait toujours par l'indice de l'élément concerné.

  • SPI_GEO_write_type_elt : Ecriture du type de l'entité (SPI_ELTTYPE_POINT ...)
  • SPI_GEO_write_layer_elt : Ecriture du numéro de couche de l'entité
  • SPI_GEO_write_color_elt : Ecriture de la couleur de l'entité (SPI_COLOR_BLUE ...).
  • SPI_GEO_write_linetype_elt : Ecriture du type de trait de l'entité (SPI_LINETYPE_AXES ...).
  • SPI_GEO_write_linewidth_elt : Ecriture de l'épaisseur de trait de l'entité (SPI_LINEWIDTH_DOUBLE ...).
  • SPI_GEO_write_mater_elt : Ecriture du matériau de l'entité.
  • SPI_GEO_write_plane_elt : Ecriture du numéro de plan de l'entité.
  • SPI_GEO_write_mark_elt : Ecriture de l'état de séléction de l'entité (SPI_YES / SPI_NO).
  • SPI_GEO_write_name_elt : Ecriture du label de l'entité.
  • SPI_GEO_write_params_elt : Ecriture du tableau de réel de la forme canonique de l'entité.

Exemples :

Modification du numéro de la couche des entités sélectionnées.

PROCEDURE PPI_ATELIER_PROCESSUS;
VAR i,nb,mark,ierr:INTEGER;
BEGIN
{*Lecture de la base de donnée géométrique*}
nb := ICALL(SPI_GEO_last_elt);
FOR i:= 1 TO nb DO
BEGIN
IF ICALL(SPI_GEO_valid_elt, i) = SPI_YES THEN
IF ICALL(SPI_GEO_read_mark_elt, ind) = SPI_YES THEN
ierr := ICALL(SPI_GEO_write_layer_elt, 10, i);
END
END;

Comment créer une entité géométrique ?

Il est possible de créer rapidement un certain nombre d'entité simple dans la base de donnée géométrique de GO2cam.
Les attributs et le plan de l'entité ainsi créée sont ceux de GO2cam par défaut :

  • SPI_GEO_append_point
  • SPI_GEO_append_segment
  • SPI_GEO_append_block
  • SPI_GEO_append_arc_2points_center
  • SPI_GEO_append_arc_3points
  • SPI_GEO_append_arc
  • SPI_GEO_append_circle
  • SPI_GEO_append_rectangle
  • SPI_GEO_append_oblong
  • SPI_GEO_append_text

Exemples :

Création de segments paralleles.

PROCEDURE PPI_ATELIER_PROCESSUS;
VAR pt1,pt2 : TR3;
i,ind : INTEGER;
BEGIN
{*Initialisation des 2 points*}
FOR i:=0 TO 2 DO
BEGIN
pt1[i] := 0.0;
pt2[i] := 0.0;
END;
pt1[0] := 10.0;
pt2[0] := 40.0;
FOR i := 0 TO 10 DO
BEGIN
pt1[1] := i*10.0;
pt2[1] := pt1[1];
ind := ICALL(SPI_GEO_append_segment, pt1, pt2);
writeln('indice base de donnée', ind);
END
END;
Remarques
Une fonction permet de créer une entite vide qui peut ensuite être remplie en utilisant les fonctions d'écriture d'entités.
  • SPI_GEO_append_free_elt

Exemples :

pt1[0] := 20.5;
pt1[1] := 10.5;
pt1[2] := 0.0;
ind := ICALL(SPI_GEO_append_free_elt);
ierr := ICALL(SPI_GEO_write_type_elt, SPI_ELTTYPE_POINT, ind);
ierr := ICALL(SPI_GEO_write_color_elt, SPI_COLOR_BLUE, ind);
ierr := ICALL(SPI_GEO_write_layer_elt, 1, ind);
ierr := ICALL(SPI_GEO_write_plane_elt, 1, ind);
ierr := ICALL(SPI_GEO_write_name_elt, 'vide', ind);
ierr := ICALL(SPI_GEO_write_params_elt, 3, pt1, ind);

Supression d'une entité géométrique

  • SPI_GEO_del_elt

Création d'un plan par 3 points

  • SPI_GEO_append_plane_3points

Gestion de la cotation et des textes

Les fonctions d'accès aux cotes et aux textes répondent comme les entités géométriques aux fonctions :

  • D'accès :
    • SPI_GEO_valid_elt : Test si un élément est valide.
    • SPI_GEO_read_mark_elt : Test si un élément est marqué.
    • etc ....
  • De lecture :
    • SPI_GEO_read_type_elt : Lecture du type de l'entité (SPI_ELTTYPE_TEXT ...).
    • SPI_GEO_read_layer_elt : Lecture du numéro de calque de l'entité.
    • etc ....
  • D'écriture :
    • SPI_GEO_write_color_elt : Ecriture de la couleur de l'élément.
    • SPI_GEO_write_linetype_elt : Ecriture du type de trait (SPI_LINETYPE_DOT ...).
    • etc ....
  • D'affichage :
    • SPI_DRAW_draw_elt
    • etc ....

La gestion de la cotation et des textes possède des fonctions qui lui sont dediées :

Comment lire toutes les caractéristiques ?

  • SPI_GEO_read_carac_dimension : Lecture d'une cotation.
  • SPI_GEO_read_carac_text : Lecture d'un texte (simple ou bloc).
  • SPI_GEO_read_carac_annot_sb : Lecture d'une annotation (simple ou bloc).
  • SPI_GEO_read_carac_annot_rugo : Lecture d'une annotation de rugosité.
  • SPI_GEO_read_carac_annot_tdf : Lecture d'une annotation de tolérance de forme.

Exemples :

VAR ierr,ind : INTEGER;
s1,s2,s3,s4,s5,s6,s7:TC80;
BEGIN
{....}
ierr := ICALL(SPI_GEO_read_carac_dimension, s1, s2, s3, s4, s5, s6, s7, ind);
IF (ierr == SPI_YES) THEN
BEGIN
writeln ('Préfixe ................. =',s1);
writeln ('Cote nominale utilisateur =',s2);
writeln ('Cote nominale vraie ..... =',s3);
writeln ('Cote H. ouverture ....... =',s4);
writeln ('Suffixe ................. =',s5);
writeln ('Tolérance Supèrieure .... =',s6);
writeln ('Tolérance Infèrieure .... =',s7);
END;
END;

Comment lire les parametres d'un texte en base de donnée

  • SPI_GEO_read_integer_text : Lecture d'un paramètre entier du texte.
  • SPI_GEO_read_boolean_text : Lecture d'un paramètre booléen du texte.
  • SPI_GEO_read_real_text : Lecture d'un paramètre réel du texte.
  • SPI_GEO_read_string_text : Lecture d'un paramètre chaîne du texte.
  • SPI_GEO_read_location_text : Lecture de la position du texte.

Exemples :

VAR ierr,ind : INTEGER;
tsize : REAL;
tfont : TC80;
BEGIN
{....}
ierr := ICALL (SPI_GEO_read_real_text,SPI_TEXT_SIZE, tsize, ind);
IF (ierr = SPI_YES) THEN
BEGIN
writeln ('Taille du texte =', tsize);
END;
ierr := ICALL (SPI_GEO_read_string_text,SPI_TEXT_FONT, tfont, ind);
IF (ierr = SPI_YES) THEN
BEGIN
writeln ('Police de caractère =', tfont);
END;
END;

Comment créer un nouveau texte en base de donnée

  • SPI_GEO_append_text

Exemples :

VAR ind : INTEGER;
pt : TR3;
text: TC80;
BEGIN
strcpy (text, 'HELLO WORLD');
pt[0] := 20.0;
pt[1] := 50.0;
pt[2] := 0.0;
ind := ICALL (SPI_GEO_append_text, pt, text);
END;
Remarques
Les attributs courants de GO2cam seront appliqués au nouveau texte créé.

Comment modifier un texte en base de donnée

  • SPI_GEO_write_integer_text : Ecriture d'un paramètre entier du texte.
  • SPI_GEO_write_boolean_text : Ecriture d'un paramètre booléen du texte.
  • SPI_GEO_write_real_text : Ecriture d'un paramètre réel du texte.
  • SPI_GEO_write_string_text : Ecriture d'un paramètre chaîne du texte.
  • SPI_GEO_write_location_text : Ecriture de la position du texte.

Exemples :

VAR ierr,ind : INTEGER;
tratio : REAL;
tfont : TC80;
BEGIN
{....}
tratio := 0.5;
strcpy (tfont, 'Arial');
ierr := ICALL(SPI_GEO_write_real_text, SPI_TEXT_RATIO, tratio, ind);
ierr := ICALL(SPI_GEO_write_string_text, SPI_TEXT_FONT, tfont, ind);
END;

Comment déterminer la longueur ou la boite englobante d'un texte

  • SPI_TXT_length_text : Calcule la longueur du texte.
  • SPI_TXT_frame_text : Calcule le cadre du texte.

Exemples :

VAR ierr,ind : INTEGER;
tsize,tratio : REAL;
tfont,text : TC80;
lon : REAL;
BEGIN
tsize := 15.0;
tratio := 0.5;
strcpy (tfont, 'Arial');
strcpy (text, 'HELLO WORLD');
ierr := ICALL(SPI_TXT_lenght_text, text, tsize, tratio, tfont, lon);
writeln ('Longueur =',lon);
END;

Gestion des cycles d'usinage

Les fonctions detaillées ci-dessous permettent de travailler avec la base de donnée usinages.
Ces fonctions permettent de :

  • Parcourir la gamme d'usinage.
  • Lire un cycle existant.
  • Extraire des informations souhaitées.
  • ...
Remarques
Un cycle d'usinage est réferencé par un numéro de processus et un nnuméro de cycle.

Comment parcourir la gamme d'usinage ?

Il est possible de parcourir les cycles un à un à l'aide des fonctions suivantes :

  • SPI_PRC_next_process : Activation du cycle d'usinage suivant en tenant compte des filtres en cours.
  • SPI_PRC_previous_process : Activation du cycle précédent en tenant compte des filtres en cours.
Remarques
Initialiser le numéro de cycle et numéro de processus à 0 pour trouver le 1er cycle de la gamme d'usinage.

Exemples :

BEGIN
{....}
nocyc := 0;
nopro := 0;
Continue := ICALL(SPI_PRC_next_process, nocyc, nopro);
writeln('******** Gamme par Cycle ***********');
WHILE Continue = SPI_YES DO
BEGIN
writeln('Numéro de cycle ', nopro, nocyc);
Continue := ICALL(SPI_PRC_next_process, nocyc, nopro);
END;
END;

Une autre methode consiste a boucler sur tous les cycle d'usinages et de lire le numéro d'ordre du cycle dans la gamme d'usiange.

  • SPI_PRC_last_process : Lecture du nombre de processus dans la gamme.
  • SPI_PRC_read_number_process : Lecture du nombre de cycle dans un processus.
  • SPI_PRC_order_process : Lecture du numéro d'ordre d'un cycle dans la gamme.

Exemples :

BEGIN
{....}
nbpro := ICALL(SPI_PRC_last_process);
FOR nopro:=1 TO nbpro DO
BEGIN
indordre := ICALL(SPI_PRC_order_process, nopro);
writeln('Numéro ordre :',indordre);
END;
END;

Comment lire un cycle d'usinage ?

Pour lire un cycle d'usinage quelconque il faut connaître son numéro de processus et son numéro de cycle.
Une fonction permet de charger le cycle dans un tampon mémoire afin de lire ses paramètres.
Les fonctions d'accès à la technologie permettent de lire les paramètres à l'aide de clés.

  • SPI_PRC_init_process : Initialise le tampon mémoire du cycle à lire.
  • SPI_PRC_free_process : Libère le tampon tampon mémoire du cycle lu.
  • SPI_PRC_read_process : Charge un cycle dans le tampon mémoire.
  • SPI_PRC_read_integer_tec_process: Lit un paramètre entier dans le cycle.
  • SPI_PRC_read_reel_tec_process : Lit un paramètre réel dans le cycle.
  • SPI_PRC_read_string_tec_process : Lit un paramètre chaîne dans le cycle.
  • SPI_PRC_read_number_subcycle_process : Lit le nombre de sous cycle du cycle.
  • SPI_PRC_read_reference_subcycle_process : Lit les références d'un sous cycle.

Comment deplacer un cycle dans la gamme ?

  • SPI_PRC_move_process : Déplacement d'un cycle par rapport à un autre.
  • SPI_PRC_write_order_process : Reconstruction la gamme d'usinage.

Comment lire et écrire des trajets dans un usinage ?

Pour commencer, les références du sous cycle à traiter doivent être lues.
Les références contiennent le trajet pièce et le trajet centre outil (ces deux trajets peuvent être egaux).
Les éléments de trajet du cycle se lisent de la même manière que les éléments géométriques.

  • SPI_PRC_read_plane_path : Lecture du numéro de plan du trajet.
  • SPI_PRC_write_plane_path : Ecriture du plan du trajet.
  • SPI_PRC_read_layer_path : Lecture du numéro de calque du trajet.
  • SPI_PRC_write_layer_path : Ecriture du numéro de calque du trajet.
  • SPI_PRC_read_color_path : Lecture de la couleur du trajet.
  • SPI_PRC_write_color_path : Ecriture de la couleur du trajet.
  • SPI_PRC_read_type_path : Lecture du type de trajet.
  • SPI_PRC_write_type_path : Ecriture du type de trajet.
  • SPI_PRC_read_type_machining_path : Lecture du type d'usinage du trajet.
  • SPI_PRC_write_type_machining_path : Ecriture du type d'usinage du trajet.
  • SPI_PRC_read_params_path : Lecture la forme canonique du trajet.
  • SPI_PRC_write_params_path : Ecriture la forme canonique du trajet.
  • SPI_PRC_read_name_path : Lecture du nom du trajet.
  • SPI_PRC_write_name_path : Ecriture du nom du trajet.
  • SPI_PRC_valid_path : Test si le trajet est valide.
  • SPI_PRC_del_path : Suppression d'un élément du trajet.
  • SPI_PRC_insert_path : Insertion d'un élément vierge sur le trajet d'usinage.