electrical & safety · industrial connectivty · software

electrical & safety · industrial connectivty · software & electronics · advanced connectivity

WoodheadWoodhead

hw_Library_DLL.doc 04/09/2003

Copyright © 2003 Woodhead Software & Electronics. Tous droits réservés.

http://www.applicom-int.com

Librairie/DLL

applicom® 3.7

un produit Woodhead Software & Electronics


WoodheadWoodhead

hw_Library_DLL.doc 04/09/2003 Copyright © 2003 Woodhead Software & Electronics. Tous droits réservés. Tous les produits applicom®, Direct-LinkTM, RJ-LnxxTM, SSTTM sont des marques déposées de Woodhead Software & Electronics. Tous les autres noms de produits sont des marques déposées de leurs fabricants respectifs.

http://www.applicom-int.com


WoodheadWoodhead

Librairie/DLL • i • Table des matières

Table des matières

1. - Généralités ...................................................................................1

2. - Utilisation de la DLL avec votre langage de programmation...2

3. - Nombre maximum de variables..................................................6

4. - Initialisation..................................................................................7

5. - Fonctions du mode attente.......................................................15 - Lecture ................................................................................................................15 - Ecriture................................................................................................................52 - Diagnostics, Modes de marches, Sémaphores ..................................................78 - Fonction ouverte ...............................................................................................104 - Fonctions "Ports sans protocole" ......................................................................107 - Fonctions spécifiques Profibus FMS.................................................................115

6. - Fonctions du mode différé......................................................119 - Conditions d’utilisation ......................................................................................119 - Lecture ..............................................................................................................120 - Ecriture..............................................................................................................144 - Fonctions "Ports sans protocole" ......................................................................160 - Fonction ouverte ...............................................................................................168 - Transfert de demande différée..........................................................................170

7. - Fonctions du mode cyclique ..................................................177 - Création d'une fonction cyclique => CREATECYC .......................................177 - Démarrage d'une fonction cyclique => STARTCYC......................................183 - Arrêt d'une fonction cyclique => STOPCYC..................................................185 - Activation ponctuelle => ACTCYC.................................................................187 - Transfert de demande cyclique.........................................................................189 - Demande d’informations sur des fonctions cycliques.......................................193

8. - Fonctions Data-Base...............................................................198 - Lecture ..............................................................................................................198 - Ecriture..............................................................................................................219 - Incrémentation ..................................................................................................239 - Décrémentation.................................................................................................243 - FIFO d'événements...........................................................................................247

9. - Fonctions de redondance d’équipements.............................253

10. - Fonctions locales ....................................................................258

11. - Fonctions modem....................................................................274

12. - Fonctions annexes ..................................................................278


WoodheadWoodhead

Librairie/DLL • ii • Table des matières

13. - Index .........................................................................................284


WoodheadWoodhead

Librairie/DLL • 1 • - Généralités

1. - Généralités

Ce manuel décrit les différentes fonctions de la librairie du produit applicom®. Dans le descriptif de chaque fonction vous trouverez sa catégorie soit : ⇒ Fonction "Standard applicom®". ⇒ Fonction "Spécifique à un protocole". Les fonctions dites « Standard applicom® » sont valables quel que soit le protocole (Profibus,

Modbus, Uni-Te, ...) et seront également supportées pour les protocoles futurs proposés sur le produit applicom®. Ces fonctions standards sont (ou seront) disponibles à condition que le protocole supporte le type d'objet (bits, mots, ...) ou la fonctionnalité visée par la fonction. Vous trouverez la liste des fonctions supportées dans le « Manuel du protocole » que vous utilisez.

Les différentes fonctions de la librairie du produit applicom® retournent une variable "STATUS".

Vous trouverez la signification des différentes valeurs retournées dans la variable « STATUS » en consultant le « Manuel du protocole » au chapitre « Status de retour des fonctions ».

Remarque : Les fonctions de lecture et d’écriture d’octets en mode « packés » (ex: readpackbyte,

writepackbyte, ...) utilisent des tableaux d’octets. Ce type de variable ne peut pas être déclaré par tous les compilateurs « BASIC ».


WoodheadWoodhead

Librairie/DLL • 2 • - Utilisation de la DLL avec votre langage de programmation

2. - Utilisation de la DLL avec votre langage de programmation

La DLL applicom® est commune pour toutes les plates-formes MS-Windows 32 bits

(Windows NT, Windows 2000 et Windows XP). Cela permet ainsi aux applications développées de pouvoir fonctionner indifféremment au travers de l’un ou l’autre des OS Windows 32 bits.

Attention, la DLL applicom® est installée dans le répertoire applicom® et doit être

unique sur le disque dur de la machine.

- Utilisation L’utilisation de la DLL « APPLICOM.DLL » est immédiate. Une application utilise les points

d’entrées définis comme toute fonction applicom®, en veillant bien à respecter le nombre de paramètres et leurs types. En effet, la condition d’appel « Pascal » ne pardonne aucune erreur.

Toutes les fonctionnalités et la description des procédures de la librairie dynamique

« APPLICOM.DLL » sont décrites dans ce Manuel de référence. - Langage Visual Basic Les déclarations des procédures se trouvent dans le fichier APPLICOM.BAS. Ce fichier est situé

dans le sous-répertoire Visual Studio\VB\VB 6.0. Il faut l'insérer dans votre projet par l'option "Ajouter un fichier".

La première fonction à appeler est CALL INITBUS(status%). Si le « status » est différent de 0, vous ne pouvez pas utiliser les autres fonctions applicom® (voir chapitre « Status de retour des fonctions » à la fin du manuel spécifique au protocole).

Remarque : Pour travailler dans l'environnement de VISUAL BASIC et éviter le message "ne trouve pas

APPLICOM.DLL", donnez comme répertoire de travail à VISUAL BASIC le répertoire où se trouve « APPLICOM.DLL » en utilisant, "fichier et propriétés" du gestionnaire de programmes.

- Langage Visual Basic .Net Les déclarations des procédures se trouvent dans le fichier APPLICOM.VB. Ce fichier est situé

dans le sous-répertoire Visual Studio\VB\VB .Net. Il faut l’insérer dans votre projet par l'option "Ajouter un fichier existant".

- Langage C Microsoft Ajoutez dans votre projet (.MAK) le fichier « APPLICOM.LIB » (librairie d’imports). Ce fichier est

situé dans le sous-répertoire Visual Studio\C. Inclure dans votre programme le fichier contenant les prototypes des fonctions de la DLL

applicom®. # include " APPLICOM.H" Tous les arguments sont passés par adresse (&x). La première procédure à appeler est

initbus(&status). Si le « status » est différent de 0, vous ne pouvez pas utiliser les autres fonctions


WoodheadWoodhead


applicom® (voir le chapitre "Status de retour des fonctions" à la fin du manuel spécifique au protocole).

- Langage C++ Microsoft Ajoutez dans votre projet (.MAK) le fichier « APPLICOM.LIB ». Ce fichier est situé dans le sous-

répertoire Visual Studio\C++. Il n’existe pas de librairie de classes applicom®, les fonctions applicom® sont vues comme des

fonctions C, il faut donc inclure dans votre programme le fichier contenant les prototypes des fonctions de la DLL applicom® en le faisant précéder par le mot clé EXTERN « C ».

extern "C" { #include " APPLICOM.H"* } Tous les arguments sont passés par adresse (&). La première procédure à appeler est

initbus(&status). Si le « status » est différent de 0, vous ne pouvez pas utiliser les autres fonctions applicom® (voir le chapitre "Status de retour des fonctions" à la fin du manuel spécifique au protocole).

- Langage C# Microsoft Les déclarations des procédures se trouvent dans le fichier APPLICOM.CS. Ces déclarations ont été incluses dans la classe CApplicom qui définit des méthodes qui ont le

même prototype que les fonctions appelées. Ce fichier est situé dans le sous-répertoire Visual Studio\C#. Il faut l’insérer dans votre projet par

l'option "Ajouter un fichier existant". Il faut également modifier une option de compilation de votre projet pour autoriser l’utilisation de

blocs de code « unsafe ». Pour cela, il faut :

Ouvrir la page de propriété de votre projet,

Cliquer sur le dossier Configuration Properties,

Cliquer sur la page Build

Modifier la propriété Allow unsafe code blocks et la positionner à TRUE. - Langage Delphi de Borland Les déclarations des procédures se trouvent dans le fichier APPLICOM.PAS. Ce fichier est situé

dans le sous-répertoire DELPHI. Il faut l’insérer dans votre projet par la ligne de commande : implementation {$R *.DFM} {$I c:\applicom\delphi\APPLICOM.PAS}

La première procédure à appeler est initbus(status). Si le « status » est différent de 0, vous ne

pouvez pas utiliser les autres fonctions applicom® (voir le chapitre « Status de retour des fonctions » à la fin du manuel spécifique au protocole.)

Remarques : Les procédures ne vérifient pas les dimensions de tableaux. Déclarez vos tableaux avec des

dimensions correctes. Le type entier 16 bits sous DELPHI 32 bits est SmallInt et non pas Integer.


WoodheadWoodhead


- Langage C Borland Ajoutez dans votre projet (.IDE) le fichier « APPLICOM.LIB » (librairie d’imports pour Borland). Ce

fichier est situé dans le sous-répertoire BC_BCC. Inclure dans votre programme le fichier contenant les prototypes des fonctions de la DLL

applicom®. # include " APPLICOM.H" Tous les arguments sont passés par adresse (&). La première procédure à appeler est


- Langage C++ Borland Ajoutez dans votre projet (.IDE) le fichier « APPLICOM.LIB ». (librairie d’imports pour Borland). Ce

fichier est situé dans le sous-répertoire BC_BCC. Il n’existe pas de librairie de classes applicom®, les fonctions applicom® sont vues comme des

fonctions C, il faut donc inclure dans votre programme le fichier contenant les prototypes des fonctions de la DLL applicom® en le faisant précéder par le mot clé EXTERN « C ».

extern "C" * { #include " APPLICOM.H" } Tous les arguments sont passés par adresse (&). La première procédure à appeler est


- Langage C avec LabWindows/CVI de National Instrument (sous répertoire CVI ) La société National Instrument fournit un environnement de développement C, qui permet de

développer des applications Windows intégrant la notion d’instrument et ceci de façon très simple. Cette version applicom® fournit en standard une librairie instrument compatible avec cet environnement CVI. Cet instrument applicom® est architecturé en différentes classes et sous-classes reprenant ainsi les différents modes de fonctionnement du logiciel applicom®. Pour intégrer cet instrument dans votre application vous devez ajouter dans votre projet (.PRJ) les fichiers :

- « APPLICOM.LIB ». (librairie d’imports). - « APPLICOM.FP ». (librairie instrument applicom®).

Vous devez inclure le fichier prototypes #include " APPLICOM.H" dans votre fichier source. Ces fichiers sont situés dans le sous-répertoire CVI.

Comme dans tous les instruments standards CVI, la mise en oeuvre des fonctions est graphique

(function pannel) et la documentation est accessible par le clic droit de la souris. Tous les arguments sont passés par adresse (&). La première procédure à appeler est

initbus(&status). Si le « status » est différent de 0, vous ne pouvez pas utiliser les autres fonctions applicom® (voir le chapitre "Status de retour des fonctions" à la fin du manuel spécifique au protocole). Vous devez exécuter obligatoirement la fonction exitbus en quittant votre application.


WoodheadWoodhead


- Langage G avec Labview de National Instrument applicom® fournit en standard une librairie compatible avec cet environnement: « applicom.llb ».

Cet librairie applicom® contient une série de sous-VI, chaque sous-VI permet d’accéder à une fonction applicom®.

Comme pour tout programme qui utilise la DLL applicom®, il faut appeler « initbus » pour initialiser le dialogue, avant tout appel aux fonctions applicom®. Le dialogue doit se conclure avec « exitbus ».

Dans LabVIEW, l’insertion d’un sous-VI dans un diagramme se fait grâce à la palette « functions », « select a VI ».

Une fois inséré dans votre diagramme, le câblage du sous-VI est facilité en visualisant les broches du connecteur par le menu « show », « terminals ». En sélectionnant la bobine dans la palette « Tools », une bulle contenant la signification de chaque broche s’affiche.

Ces fichiers sont situés dans le répertoire LavVIEW. Une aide pour chaque fonction applicom® est visible dans la fenêtre « Help ». Une aide en ligne plus complète est disponible si le répertoire d’installation est le répertoire par

défaut. - Langage Windev de PCSoft Pour utiliser les procédures applicom® il est conseillé de charger, en début de projet (lors de la

création de la fenêtre principale) ,APPLICOM.DLL à l’aide de la commande en W-Langage : inst est un entier long

inst = chargeDLL(« APPLICOM.DLL ») Et lorsque le programme se termine (Fermeture de fenêtre) il est conseillé de décharger

APPLICOM.DLL à l’aide de la commande en W-Langage dechargeDLL(inst)

La première procédure à appeler est appelDLL(«APPLICOM » , « initbus »,&status). Si le

« status » est différent de 0, vous ne pouvez pas utiliser les autres fonctions applicom® (voir le chapitre « Status de retour des fonctions » à la fin du manuel spécifique au protocole.).

Remarques : Les procédures ne vérifient pas les dimensions de tableaux. Déclarez vos tableaux avec des

dimensions correctes. L’utilisation de chargeDLL n’est pas obligatoire car appelDLL charge et décharge

APPLICOM.DLL en mémoire. Pour des raisons de performance il est conseillé de charger APPLICOM.DLL à l’aide de chargeDLL et de la décharger en fin de programme avec DechargeDLL.

Ces fichiers sont situés dans le répertoire WINDEV.


WoodheadWoodhead

Librairie/DLL • 6 • - Nombre maximum de variables

3. - Nombre maximum de variables

Les différentes fonctions de la librairie applicom® V3.0 (ou supérieure) permettent dorénavant de manipuler un nombre supérieur de variables par rapport aux versions précédentes. Pour pouvoir atteindre ces nouvelles limites, les conditions suivantes doivent être respectées:

• Utiliser le produit applicom® V3.0 (ou supérieure) pour Windows 32 bits avec des cartes applicom® au format PCI,

• Effectuer les requêtes vers un protocole supportant les nouvelles limites (Industrial Ethernet...), ou vers la DATA-BASE applicom®,

• Appeler la fonction AuSetApplicationMaxSize (après initbus) avec le paramètre APP_1584BYTES_BASED_LIMITS

L'application a la possibilité de consulter les limites supportées sur les différentes interfaces applicom® en utilisant la fonction AuGetApplicomMaxSize.

Ce nombre de variable maximum est défini comme suit:

Type de variable

Nombre maximum de variables(*) Version < 3.0

APP_256BYTES_BASED_LIMITS

Nombre maximum de variables(*) Version 3.0 ou supérieure

APP_1584BYTES_BASED_LIMITS Bits non packés (getbit) 128 792 Bits en mode différé (readdifpackbit,...) 2048 12672 Bits packés (readpackbit, getpackbit,...) 2048 12672 Ecriture de bits non contigus (setdispbit) 64 396 Lecture de bits non contigus (getdispbit) 128 792 Octets (readbyte,...) 128 792 Octets packés (readpackbyte, setpackbyte,...) 256 1584 Mots (readword, getword,...) 128 792 Ecriture de mots non contigus (setdispword) 64 396 Lecture de mots non contigus (getdispword) 128 792 Mots doubles 32 bits et flottants (readdword, readfword,...)

64 396

Ecriture de mots doubles 32 bits et flottants non contigus (setdispdword, setdispfword)

32 198

Lecture de mots doubles 32 bits et flottants non contigus (getdispdword, getdispfword)

64 396

Timer, Compteur (readtimer, readcounter) 128 792 Lecture d'événements (getevent) 20 144 readident, readmes, writemes, writereadmes, readdifmes, writedifmes, writereaddifmes

256 1584

(*)Ces chiffres indiquent des limites maximum. Les limites réelles peuvent être inférieures en fonction du protocole et des équipements visés.

Si la fonction AuSetApplicationMaxSize n'est pas appelée, le logiciel applicom® vous assure de n'accepter que des requêtes compatibles avec les anciennes limites (évitant ainsi tout problème de compatibilité des applications existantes utilisant applicom®)

Dans tous les cas, l'application doit s'assurer de disposer de buffers de retour suffisamment dimensionnés lors des appels aux fonctions applicom®.

Dans les fonctions suivantes, le nombre de variables "nb" varie de 1 à MAX. MAX représente une des limites définie dans le tableau ci dessus.


WoodheadWoodhead

Librairie/DLL • 7 • - Initialisation

Initbus

4. - Initialisation

Dans ce chapitre :

- Initialisation du produit applicom® => INITBUS - Fixer le nombre maximum de variables => AuSetApplicationMaxSize - Retrouver le nombre maximum de variables => AuGetApplicomMaxSize - Fin de programme => EXITBUS

- Initialisation du produit applicom® => INITBUS Prototype en C : void initbus(short *) Prototype en MS pascal : initbus(var status: integer) Syntaxe : C initbus(&status) MS PASCAL initbus(status) BASIC INITBUS(STATUS) Paramètre Type status Entier 16 bits. Description Cette instruction doit être exécutée une seule fois dans votre programme application avant tout

accès aux fonctions du produit applicom®. L'exécution de cette fonction permet : - De vérifier la présence de l'interface. - D'initialiser le dialogue avec la librairie applicom®. Status = 0 Indique une initialisation correcte du driver applicom®. Status = 45 Indique que le logiciel de dialogue applicom® n'est pas résident en mémoire.

Dans ce cas, les autres fonctions du produit sont inutilisables. Lancer au préalable le fichier de commandes : "applicom" ou ‘’PCINIT’’ sous Windows.

Status = 47 Absence d'interface applicom®. Status = 59 Clé de protection absente sur l'interface applicom®.


WoodheadWoodhead


initbus exemple en langage C Microsoft #include "inimsc.h" short int status; short int end_loop; main() { initbus(&status); if (!status) { do { /* votre application */ } while(end_loop == 0); exitbus(&status); exit(0); } else { printf(" logiciel de dialogue applicom® non résident "); exit(1); } }


WoodheadWoodhead


AuSetApplicationMaxSize

- Fixer le nombre maximum de variables => AuSetApplicationMaxSize Prototype en C : BOOL AuSetApplicationMaxSize(short, unsigned long *) Prototype en MS pascal : fonction AuSetApplicationMaxSize(buffersize: SmallInt, var status: LongInt) : boolean Syntaxe : C AuSetApplicationMaxSize(buffersize, &status) MS PASCAL AuSetApplicationMaxSize(buffersize, status) BASIC AUSETAPPLICATIONMAXSIZE(BUFFERSIZE, STATUS) Paramètre Type

buffersize Entier 16 bits, Indique si l'application désire utiliser les nouvelles limites de la librairie applicom® • APP_1584BYTES_BASED_LIMITS Utiliser les nouvelles limites. • APP_256BYTES_BASED_LIMITS Utiliser les anciennes limites.

status Entier 32 bits, représentant un status d'erreur.

Retour TRUE si la fonction s'est bien terminée.

Description Fonction disponible uniquement sous MS_Windows NT.

Cette fonction permet d'indiquer le nombre maximal de variables que votre application est capable de supporter. (voir "Nombre maximal de variable")

Pour indiquer que votre application est conçue pour supporter les nouvelles limites, appelez cette fonction avec le paramètre APP_1584BYTES_BASED_LIMITS.

Si la fonction AuSetApplicationMaxSize n'est pas appelée, le logiciel applicom® vous assure de n'accepter que des requêtes compatibles avec les anciennes limites (évitant ainsi tout problème de compatibilité des applications existantes utilisant applicom®)

Le produit applicom® calcule le nombre de variables acceptables dans une requête en fonction : des limites que vous venez de fixer, du maximum supporté par le protocole visé.

Attention : AuSetApplicationMaxSize doit être appelée après la fonction initbus. Dans tous les cas, l'application doit s'assurer de disposer de buffers de retour suffisamment dimensionnés lors des appels aux fonctions applicom®.


WoodheadWoodhead


AuSetApplicationMaxSize exemple en langage C Microsoft #include "applicom.h" short int status; unsigned long dwStatus; short int end_loop; main() { initbus(&status); if (!status) { if(!AuSetApplicationMaxSize(APP_1584BYTES_BASED_LIMITS, &dwStatus)) { exitbus(&status); exit(1); } do { /* votre application */ } while(end_loop == 0); exitbus(&status); exit(0); } else { printf(" logiciel de dialogue applicom® non résident "); exit(1); } }


WoodheadWoodhead


AuGetApplicomMaxSize

- Retrouver le nombre maximum de variables => AuGetApplicomMaxSize

Prototype en C : BOOL AuGetApplicomMaxSize(short sizeDB[8],short sizeChannel[32],unsigned long* status); Prototype en MS pascal : fonction AuGetApplicomMaxSize(var sizeDB:SmallInt;var sizeChannel:SmallInt;var stat:LongInt) : boolean Syntaxe : C AuGetApplicomMaxSize(sizeDB,sizeChannel, &status) MS PASCAL AuGetApplicomMaxSize(sizeDB,sizeChannel, status) BASIC AUGETAPPLICOMMAXSIZE(SIZEDB,SIZECHANNEL,STATUS) Paramètre Type

sizeDB Tableau de 8 Entiers 16 bits, chaque élément contient une valeur indiquant les limites de la data-base correspondante. La valeur peut être : • APP_1584BYTES_BASED_LIMITS Supporte les nouvelles limites du logiciel applicom® V3.0 (ou supérieure), • APP_256BYTES_BASED_LIMITS Supporte les limites des logiciels applicom® antérieurs à la V3.0,

sizeChannel Tableau de 32 Entiers 16 bits, chaque élément contient une valeur indiquant les

limites du canal correspondant. La valeur peut être : • APP_1584BYTES_BASED_LIMITS Supporte les nouvelles limites du logiciel applicom® V3.0 (ou supérieure), • APP_256BYTES_BASED_LIMITS Supporte les limites des logiciels applicom® antérieurs à la V3.0,

status Entier 32 bits, représentant un status d'erreur.

Retour VRAIE si la fonction s'est bien terminée.

Description Fonction disponible uniquement sous MS_Windows NT.

Cette fonction permet à une application de connaître les limites supportées par les data-base ou les protocoles maître des interfaces applicom®.

Afin de connaître ces différentes limites, consultez la partie "Nombre maximum de variables"


WoodheadWoodhead


AuGetApplicomMaxSize

exemple en langage C Microsoft #include "applicom.h" short int status; unsigned long dwStatus; short dwStatus; short int end_loop; short sizeDB[8], sizeChannel[32]; main() { initbus(&status); if (!status) { if(!AuGetApplicomMaxSize(sizeDB,sizeChannel, &dwStatus)) { exitbus(&status); exit(1); } do { /* votre application */ } while(end_loop == 0); exitbus(&status); exit(0); } else { printf(" logiciel de dialogue applicom® non résident "); exit(1); } }


WoodheadWoodhead


exitbus

- Fin de programme => EXITBUS prototype en C : void exitbus(short *) prototype en MS pascal : procédure exitbus(var status : integer) Syntaxe : C exitbus(&status) MS PASCAL exitbus(status) BASIC EXITBUS(STATUS) Paramètre Type status Entier 16 bits. Description Cette instruction doit être exécutée à la sortie de toutes les tâches qui ont exécuté un INITBUS

(avec ou sans succès). Le status est toujours égal à 0 à la sortie de cette fonction.


WoodheadWoodhead


exitbus exemple en langage C Microsoft #include "inimsc.h" short int status; short int end_loop; main() { initbus(&status); if (!status) { do { /* votre application */ } while(end_loop == 0); exitbus(&status); exit(0); } else { printf(" logiciel de dialogue applicom® non résident "); exit(1); } }


WoodheadWoodhead

Librairie/DLL • 15 • - Fonctions du mode attente

readpackbit

5. - Fonctions du mode attente

Dans ce chapitre :

- Lecture- Ecriture - Diagnostics, Modes de marches, Sémaphores - Fonction ouverte - Fonctions "Ports sans protocole" - Fonctions spécifiques Profibus FMS

- Lecture

Dans ce chapitre : - Lecture de bits => READPACKBIT - Lecture de bits d'entrée => READPACKIBIT - Lecture de bits de sortie => READPACKQBIT - Lecture rapide de 8 bits => READQUICKBIT - Lecture d'octets => READBYTE - Lecture d'octets d'entrée => READIBYTE - Lecture d'octets de sortie => READQBYTE - Lecture d'octets packés => READPACKBYTE - Lecture d'octets packés d'entrée => READPACKIBYTE - Lecture d'octets packés de sortie => READPACKQBYTE - Lecture de mots => READWORD - Lecture de mots d'entrée => READIWORD - Lecture de mots de sortie => READQWORD - Lecture de mots BCD => READWORDBCD - Lecture de mots doubles => READDWORD - Lecture de mots flottants => READFWORD - Lecture de temporisateurs => READTIMER - Lecture de compteurs => READCOUNTER

- Lecture de bits => READPACKBIT

prototype en C :

void readpackbit(short *, short *, short *, long*, short *, short *) prototype en MS pascal :

procédure readpackbit(var nchan, neq, nb : integer; var adr : integer4; var tabl, status : integer);extern; Syntaxe : C readpackbit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readpackbit(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS)


WoodheadWoodhead


Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire dans l'équipement. tabl Tableau d'entiers 16 bits recevant les données lues. status Entier 16 bits, Status de l'échange. Description : Cette fonction standard applicom® permet la lecture de bits dans un équipement en format packé.

Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum une chaîne de 16 bits. Les bits non lus dans le dernier mot recevant les données sont dans un état indéterminé.

La fonction applicom® "transwordbit" vous permet d'éclater les chaînes de bits.


WoodheadWoodhead


readpackbit Exemple en langage C Microsoft Lecture des bits de 0 à 7 de l'équipement numéro 6, canal numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 8; /* Nombre de variables */ short status; /* Status */ long adr = 0; /* Adresse de la première variable */ short tabl[1]; /* Table recevant les données */ short tablbit[8]; /* Table contenant les valeurs éclatées */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackbit(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { transwordbit(&nb, tabl, tablbit, &status); for (i=0; i < nb ; i++) printf(" %hd",tablbit[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readpackibit

- Lecture de bits d'entrée => READPACKIBIT

prototype en C :

void readpackibit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readpackibit(var nchan, neq, nb : integer; var adr : integer4; var tabl, status :integer);extern; Syntaxe : C readpackibit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readpackibit(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKIBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à lire dans l'équipement. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de bits d'entrée dans un équipement en

format packé. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum une chaîne de 16 bits. Les bits non lus dans le dernier mot recevant les données sont dans un état indéterminé.



WoodheadWoodhead


readpackibit exemple en langage C Microsoft Lecture des bits de 0 à 33 de l'équipement numéro 6, depuis le canal numéro 1 de l'interface

applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status */ long adr = 0; /* Adresse de la première variable */ short tabl[3]; /* Table recevant les données */ short tablbit[34]; /* Table contenant les valeurs éclatées */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackibit(&nchan, &neq, &nb, &adr, tabl, &status); if ( !status ) { transwordbit(&nb, tabl, tablbit, &status); for ( i=0; i < nb; i++ ) printf(" %hd",tablbit[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while( status == 0 ); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readpackqbit

- Lecture de bits de sortie => READPACKQBIT prototype en C :

void readpackqbit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readpackqbit(var nchan, neq, nb : integer; var adr : integer4; var tabl, status :integer);extern; Syntaxe : C readpackqbit(&nchan,&neq,&nb,&adr,tabl,&status) MS PASCAL readpackqbit(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKQBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à lire dans l'équipement. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de bits de sortie dans un équipement en

format packé. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum une chaîne de 16 bits. Les bits non lus dans le dernier mot recevant les données sont dans un état indéterminé.



WoodheadWoodhead


readpackqbit exemple en langage C Microsoft Lecture des bits de sortie 0 à 33 dans l'équipement numéro 6, depuis le canal numéro 1 de

l'interface applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status */ long adr = 0; /* Adresse de la première variable */ short tabl[3]; /* Table recevant les données */ short tablbit[34]; /* Table contenant les valeurs éclatées */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackqbit(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { transwordbit(&nb, tabl, tablbit, &status); for ( i=0; i < nb; i++ ) printf(" %hd",tablbit[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readquickbit

- Lecture rapide de 8 bits => READQUICKBIT prototype en C :

void readquickbit(short *, short *, short *, short *) prototype en MS pascal :

procédure readquickbit(var nchan, neq, tabl, status :integer); extern; Syntaxe : C readquickbit(&nchan,&neq,tabl,&status) PASCAL readquickbit(nchan,neq,tabl[1],status) BASIC READQUICKBIT(NCHAN,NEQ,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (1-255). tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction spécifique au protocole Jbus permet la lecture rapide de 8 bits, l'adresse de ces bits

est : - A504 à A511 pour des équipements de la gamme SMC - 0A00 à 0A07 pour des équipements de la gamme PB - 0000 à 0007 pour des équipements de type applicom® PC100 - Configurable entre 0 et 32000 pour des équipements de type applicom®

PC1000/PC4000/GT4000... Les données sont reçues dans l'octet de poids faible d'un premier élément du tableau "tabl". La

fonction applicom® "transwordbit" vous permet d'éclater les chaînes de bits.


WoodheadWoodhead


readquickbit exemple en langage C Microsoft Lecture rapide des 8 bits de l'équipement numéro 6, depuis le canal numéro 1 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short status; /* Status */ short tabl[1]; /* Table recevant les données */ short tablbit[8]; /* Table contenant les valeurs éclatées */ short nb = 8; /* Nombre de variables */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readquickbit(&nchan, &neq, tabl, &status); if (!status) { transwordbit(&nb, tabl, tablbit, &status); for (i=0; i<nb ; i++) printf(" %hd",tablbit[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readbyte

- Lecture d'octets => READBYTE prototype en C :

void readbyte(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl, status : integer);extern; Syntaxe : C readbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readbyte(nchan,neq,nb,adr,tabl[1],status) BASIC READBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier octet à lire dans l'équipement. tabl Tableau d'entiers 16 bits recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets dans un équipement. Les différentes

valeurs seront rangées dans les octets de poids faible du tableau d'entiers "tabl". L'octet de poids fort de chaque élément du tableau est forcé à 0.

Remarques : Protocole Uni-Te : - L'argument adresse "adr", est codé sur 32 bits. Le codage des 16 bits de poids fort permet l'accès à des segments et types d'objets particuliers (NUM) (voir chapitre "Fonction de lecture et écriture d'objets" du manuel fonctionnalité). - Cette fonction n'est pas supporté par le automate TSX.


WoodheadWoodhead


readbyte exemple en langage C Microsoft Lecture des octets de 0 à 33 de l'équipement numéro 6, depuis le canal numéro 1 de l'interface

applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ short tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %hd", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readibyte

- Lecture d'octets d'entrée => READIBYTE prototype en C :

void readibyte(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readibyte(var nchan, neq, nb : integer; var adr : integer4; var tabl, status : integer);extern; Syntaxe : C readibyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readibyte(nchan,neq,nb,adr,tabl[1],status) BASIC READIBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier octet à lire dans l'équipement. tabl Tableau d'entiers recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets d'entrée dans un équipement. Les

différentes valeurs seront rangées dans les octets de poids faible du tableau d'entiers "tabl". L'octet de poids fort de chaque élément du tableau est forcé à 0.


WoodheadWoodhead


readibyte exemple en langage C Microsoft Lecture des octets d'entrée de 0 à 33 de l'équipement numéro 6, depuis le canal numéro 1 de

l'interface applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ short tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readibyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %hd", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readqbyte

- Lecture d'octets de sortie => READQBYTE

prototype en C :

void readqbyte( short *, short *, short *, long *, short *, short * ) prototype en MS pascal :

procédure readqbyte( var nchan, neq, nb: integer; var adr: integer4; var tabl, status: integer );extern ; Syntaxe : C readqbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readqbyte(nchan,neq,nb,adr,tabl[1],status) BASIC READQBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier octet à lire dans l'équipement. tabl Tableau d'entiers recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets de sortie dans un équipement. Les

différentes valeurs seront rangées dans les octets de poids faible du tableau d'entiers "tabl". L'octet de poids fort de chaque élément du tableau est forcé à 0.


WoodheadWoodhead


readqbyte exemple en langage C Microsoft Lecture des octets de sortie de 0 à 33 de l'équipement numéro 6, depuis le canal numéro 1 de

l'interface applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ short tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readqbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %d", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readpackbyte

- Lecture d'octets packés => READPACKBYTE prototype en C :

void readpackbyte(short *, short *, short *, long *, char *, short *) prototype en MS pascal :

procédure readpackbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl : byte; var status : integer);extern; Syntaxe : C readpackbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readpackbyte(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à lire dans l'équipement. tabl Tableau d'octets recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets dans un équipement. Les différentes

valeurs sont rangées dans le tableau d'octets 'tabl'.


WoodheadWoodhead


readpackbyte exemple en langage C Microsoft Lecture des octets de 0 à 33 dans l'équipement numéro 6, depuis le canal numéro 1 de l'interface

applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ char tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %d", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readpackibyte

- Lecture d'octets packés d'entrée => READPACKIBYTE prototype en C :

void readpackibyte(short *, short *, short *, long *, char *, short *) prototype en MS pascal :

procédure readpackibyte(var nchan, neq, nb : integer; var adr : integer4; var tabl : byte; var status : integer);extern; Syntaxe : C readpackibyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readpackibyte(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKIBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à lire dans l'équipement. tabl Tableau d'octets recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets d'entrée dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'octets 'tabl'.


WoodheadWoodhead


readpackibyte exemple en langage C Microsoft Lecture des octets d'entrée packés de 0 à 33 dans l'équipement numéro 6, depuis le canal numéro

1 de l'interface applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ char tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackibyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %d", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readpackqbyte

- Lecture d'octets packés de sortie => READPACKQBYTE prototype en C :

void readpackqbyte(short *, short *, short *, long *, char *, short *) prototype en MS pascal :

procédure readpackqbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl : byte; var status : integer);extern; Syntaxe : C readpackqbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readpackqbyte(nchan,neq,nb,adr,tabl[1],status) BASIC READPACKQBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à lire dans l'équipement. tabl Tableau d'octets recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture d'octets de sortie dans un équipement. Les



WoodheadWoodhead


readpackqbyte exemple en langage C Microsoft Lecture des octets de sortie de 0 à 33 dans l'équipement numéro 6, depuis le canal numéro 1 de

l'interface applicom®. #include inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 34; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 0; /* Adresse de la première variable */ char tabl[34]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readpackqbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf(" %d", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readword

- Lecture de mots => READWORD prototype en C :

void readword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readword(var nchan, neq, nb :integer ; var adr :integer4 ; var tabl, status :integer);extern; Syntaxe : C readword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readword(nchan,neq,nb,adr,tabl[1],status) BASIC READWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à lire. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots dans un équipement. Les différentes

valeurs lues dans l'équipement sont retournées par la fonction dans le tableau d'entiers 'tabl'.


WoodheadWoodhead


readword exemple en langage C Microsoft Lecture des mots de 20 à 30 de l'équipement numéro 4, du canal numéro 2. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 11; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ short tabl[11]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readword(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf("mot%ld = %hd \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readiword

- Lecture de mots d'entrée => READIWORD prototype en C :

void readiword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readiword(var nchan, neq, nb: integer; var adr : integer4 ; var tabl, status :integer);extern; Syntaxe : C readiword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readiword(nchan,neq,nb,adr,tabl[1],status) BASIC READIWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à lire. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots d'entrée dans un équipement. Les

différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau d'entiers 'tabl'.


WoodheadWoodhead


readiword exemple : Lecture des mots de 20 à 30 de l'équipement numéro 4, du canal numéro 2. exemple en langage C Microsoft #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 11; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ short tabl[11]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readiword(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i<nb ; i++) printf("mot%ld = %hd \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readqword

- Lecture de mots de sortie => READQWORD prototype en C :

void readqword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readqword(var nchan, neq, nb: integer; var adr : integer4 ; var tabl, status :integer);extern; Syntaxe : C readqword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readqword(nchan,neq,nb,adr,tabl[1],status) BASIC READQWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à lire. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots de sortie dans un équipement. Les

différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau d'entiers 'tabl'.


WoodheadWoodhead


readqword exemple : Lecture des mots de sortie 20 à 30 dans l'équipement numéro 4, du canal numéro 2 de l'interface

applicom®. exemple en langage C Microsoft #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 11; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ short tabl[11]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readqword(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i<nb ; i++) printf("mot%ld = %hd \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readwordbcd

- Lecture de mots BCD => READWORDBCD prototype en C :

void readwordbcd(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure readwordbcd(var nchan, neq, nb: integer; var adr : integer4 ; var tabl, status :integer);extern; Syntaxe : C readwordbcd(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readwordbcd(nchan,neq,nb,adr,tabl[1],status) BASIC READWORDBCD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à lire. tabl Tableau d'entiers 16 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots au format BCD. Exemple : Valeur lue dans l'équipement h'9999' hexadécimal. Valeur retournée par la fonction 9999 décimal. Les différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau

d'entiers 'tabl'. Si une des valeurs accédées dans l'équipements n'est pas au format BCD, le status 3 vous sera

retourné.


WoodheadWoodhead


readwordbcd exemple : Lecture des mots BCD 20 à 30 dans l'équipement numéro 4, du canal numéro 2 de l'interface

applicom®. exemple en langage C Microsoft #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 11; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ short tabl[11]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readwordbcd(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i<nb ; i++) printf("mot%ld = %d \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdword

- Lecture de mots doubles => READDWORD prototype en C :

void readdword(short *, short *, short *, long *, long *, short *) prototype en MS pascal :

procédure readdword(var nchan, neq, nb :integer; var adr, tabl :integer4; var status :integer);extern; Syntaxe : C readdword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readdword(nchan,neq,nb,adr,tabl[1],status) BASIC READDWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots doubles à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot double à lire. tabl Tableau d'entiers 32 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots doubles dans un équipement. Les

différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau d'entiers 32 bits 'tabl'.


WoodheadWoodhead


readdword exemple en langage C Microsoft Lecture des mots doubles de 20 à 30 de l'équipement numéro 4, du canal numéro 2. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 11; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ long tabl[11]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readdword(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb; i++) printf("mot%ld = %ld \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } }


WoodheadWoodhead


readfword

- Lecture de mots flottants => READFWORD prototype en C :

void readfword(short *, short *, short *, long *,float *, short *) prototype en MS pascal :

procédure readfword(var nchan, neq, nb :integer; var adr :integer4; var tabl :real; var status :integer);extern; Syntaxe : C readfword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readfword(nchan,neq,nb,adr,tabl[1],status) BASIC READFWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de mots flottants à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot flottant à lire. tabl Tableau de réels 32 bits, recevant les données lues. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de mots flottants au format IEEE dans un

équipement. Les différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau de réels 32 bits 'tabl'.


WoodheadWoodhead


readfword exemple en langage C Microsoft Lecture des mots flottants de 20 à 26 de l'équipement numéro 1, du canal numéro 0. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 0; /* Numéro de canal */ short neq = 1; /* Numéro d'équipement */ short nb = 7; /* Nombre de variables */ short status; /* Status de l'échange */ long adr = 20; /* Adresse de la première variable */ float tabl[7]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readfword(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { for (i=0; i<nb ; i++) printf("mot%ld = %f \n",adr+i,tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readtimer

- Lecture de temporisateurs => READTIMER prototype en C :

void readtimer(short *, short *, short *, long *,short *, short *) prototype en MS pascal :

procédure readtimer(var nchan, neq, nb :integer; var adr: integer4, var tabl, status :integer); extern; Syntaxe : C readtimer(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readtimer(nchan,neq,nb,adr,tabl[1],status) BASIC READTIMER(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de temporisateurs à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Numéro du premier temporisateur. tabl Tableau d'entiers 16 bits recevant les valeurs courantes des 'nb' temporisateurs. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de valeurs de préselection liées à des

temporisateurs dans un équipement. Les différentes valeurs sont rangées dans le tableau d'entiers 16 bits 'tabl'.

Remarques : Protocole Uni-Te : - 1Temporisateur maximum. - Permet la lecture des objets Ti,P des automates TSX (i = n° du temporisateur). Protocole 3964/3964R messagerie RK512 : - Permet la lecture des objets TB.


WoodheadWoodhead


readtimer exemple en langage C Microsoft Lecture du temporisateur n°3 dans l'équipement numéro 6, depuis le canal numéro 1 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan = 1; /* Numéro de canal */ short neq = 6; /* Numéro d'équipement */ short nb = 1; /* Nombre de temporisateurs */ long adr = 3; /* Adresse du temporisateur */ short tabl[1]; /* Table recevant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readtimer(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) { printf(" Valeur de la tempo n° %ld = %hd \n ", adr, tabl[0] ); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readcounter

- Lecture de compteurs => READCOUNTER prototype en C :

void readcounter(short *, short *,short *, long *, short *, short *) prototype en MS pascal :

procédure readcounter(var nchan, neq, nb :integer; var adr: integer4, var tabl, status :integer); extern; Syntaxe : C readcounter(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL readcounter(nchan,neq,nb,adr,tabl[1],status) BASIC READCOUNTER(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de compteurs à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Numéro du premier compteur. tabl Tableau d'entiers 16 bits, recevant les valeurs courantes des 'nb' compteurs. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la lecture de valeurs de présélection liées à des

compteurs dans un équipement. Les différentes valeurs lues dans l'équipement sont retournées par la fonction dans le tableau d'entiers 'tabl'.

Remarques : Protocole Uni-Te : - 1 Compteur maximum. - Permet la lecture des objets Ci,P des automates TSX (i = n° du compteur). Protocole 3964/3964R messagerie RK512 : - Permet la lecture des objets ZB.


WoodheadWoodhead


readcounter exemple en langage C Microsoft Lecture du compteur n°10 dans l'équipement numéro 4, depuis le canal numéro 0 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan = 0; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb = 1; /* Nombre de compteur */ long adr = 10; /* Adresse du compteur */ short tabl[1]; /* Table recevant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readcounter(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) printf(" Valeur du compteur n° %ld = %hd \n", adr, tabl[0]); else printf(" problème sur l'équipement n° %hd \n", neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writepackbit

- Ecriture

Dans ce chapitre : - Ecriture de bits => WRITEPACKBIT - Ecriture de bits de sortie => WRITEPACKQBIT - Ecriture d'octets => WRITEBYTE - Ecriture d'octets de sortie => WRITEQBYTE - Ecriture d'octets packés => WRITEPACKBYTE - Ecriture d'octets packés de sortie => WRITEPACKQBYTE - Ecriture de mots => WRITEWORD - Ecriture de mots de sortie => WRITEQWORD - Ecriture de mots BCD => WRITEWORDBCD - Ecriture de mots doubles => WRITEDWORD - Ecriture de mots flottants => WRITEFWORD - Ecriture de temporisateurs => WRITETIMER - Ecriture de compteurs => WRITECOUNTER

- Ecriture de bits => WRITEPACKBIT prototype en C :

void writepackbit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writepackbit(var nchan, neq, nb :integer; var adr :integer4, var tabl, status :integer); extern; Syntaxe : C writepackbit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writepackbit(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEPACKBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à écrire. tabl Tableau d'entiers 16 bits contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de bits dans un équipement. Les différentes

valeurs sont rangées dans le tableau d'entiers 'tabl' en mode "packé" (16 bits par entier).


WoodheadWoodhead


writepackbit exemple en langage C Microsoft Mise à 1, des bits de 20 à 30 de l'équipement numéro 4, depuis le canal numéro 2 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb =11; /* Nombre de bits */ short status; /* Status de l'échange */ long adr = 20; /* Adresse du premier bit */ short tabl[1]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { tabl[0] = 0x07FF; writepackbit(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writepackqbit

- Ecriture de bits de sortie => WRITEPACKQBIT prototype en C :

void writepackqbit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writepackqbit(var nchan, neq, nb :integer; var adr :integer4, var tabl, status :integer); extern; Syntaxe : C writepackqbit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writepackqbit(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEPACKQBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à écrire. tabl Tableau d'entiers 16 bits contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de bits de sortie dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'entiers 'tabl' en mode "packé" (16 bits par entier).


WoodheadWoodhead


writepackqbit exemple en langage C Microsoft Mise à 1, des bits de sortie 20 à 30 de l'équipement numéro 4, depuis le canal numéro 2 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan = 2; /* Numéro de canal */ short neq = 4; /* Numéro d'équipement */ short nb 11; /* Nombre de bits */ short status; /* Status de l'échange */ long adr = 20; /* Adresse du premier bit */ short tabl[1]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { tabl[0] = 0x07FF; writepackqbit(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writebyte

- Ecriture d'octets => WRITEBYTE prototype en C :

void writebyte(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writebyte(var nchan, neq, nb : integer; var adr : integer4; var tabl, status : integer);extern; Syntaxe : C writebyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writebyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à écrire dans l'équipement. tabl Tableau d'entiers de 16 bits contenant les données à écrire. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture d'octets dans un équipement. Les différentes

valeurs seront rangées dans les octets de poids faible du tableau d'entiers "tabl". Si l'octet de poids fort n'est pas égal à 0, le status retourné sera égal à 3.


WoodheadWoodhead


writebyte exemple en langage C Microsoft Ecriture des octets 10 à 13 de l'équipement numéro 4, depuis le canal numéro 2 de l'interface

applicom®. Les valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre d'octets */ short status; /* Status de l'échange */ long adr; /* Adresse du premier octet */ short tabl[4]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=4; adr=10; for ( i = 0; i < nb; i++) { printf("\n Valeur de l'octet %ld (0-255) = ", adr+i); scanf(" %hd", &tabl[i]); } writebyte(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writeqbyte

- Ecriture d'octets de sortie => WRITEQBYTE prototype en C :

void writeqbyte(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writeqbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl, status : integer);extern; Syntaxe : C writeqbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writeqbyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEQBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à lire dans l'équipement. tabl Tableau d'entiers 16 bits contenant les données à écrire. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture d'octets de sortie dans un équipement. Les

différentes valeurs seront rangées dans les octets de poids faible du tableau d'entiers "tabl". Si l'octet de poids fort n'est pas égal à 0, le status retourné sera égal à 3.


WoodheadWoodhead


writeqbyte exemple en langage C Microsoft Ecriture des octets de sortie 10 à 13 de l'équipement numéro 4, depuis le canal numéro 2 de

l'interface applicom®. Les valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de d'octets */ short status; /* Status de l'échange */ long adr; /* Adresse du premier octet */ short tabl[4]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=4; adr=10; for ( i = 0; i < nb; i++) { printf("\n Valeur de l'octet %ld (0-255) = ", adr+i); scanf(" %hd", &tabl[i]); } writeqbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writepackbyte

- Ecriture d'octets packés => WRITEPACKBYTE prototype en C :

void writepackbyte(short *, short *, short *, long *, char *, short *) prototype en MS pascal :

procédure writepackbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl : byte; var status : integer);extern; Syntaxe : C writepackbyte(&nchan,&neq,&nb,&adr,tabl,&status) MS PASCAL writepackbyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEPACKBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à écrire dans l'équipement. tabl Tableau d'octets contenant les données à écrire. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture d'octets dans un équipement. Les différentes

valeurs sont rangées dans le tableau d'octets 'tabl'.


WoodheadWoodhead


writepackbyte exemple en langage C Microsoft Ecriture des octets packés 10 et 11 de l'équipement numéro 4, depuis le canal numéro 2 de

l'interface applicom®. Les valeurs sont positionnées à 255. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre d'octets */ short status; /* Status de l'échange */ long adr; /* Adresse du premier octet */ char tabl[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=2; adr=10; tabl[0] = 255; tabl[1] = 255; writepackbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writepackqbyte

- Ecriture d'octets packés de sortie => WRITEPACKQBYTE prototype en C :

void writepackqbyte(short *, short *, short *, long *, char *, short *) prototype en MS pascal :

procédure writepackqbyte(var nchan, neq, nb : integer; var adr : integer4; var tabl : byte; var status : integer);extern; Syntaxe : C writepackqbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writepackqbyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEPACKQBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier octet à écrire dans l'équipement. tabl Tableau d'octets contenant les données à écrire. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture d'octets de sortie dans un équipement. Les



WoodheadWoodhead


writepackqbyte exemple en langage C Microsoft Ecriture des octets de sortie 10 à 11 de l'équipement numéro 4, depuis le canal numéro 2 de

l'interface applicom®. Les valeurs sont positionnées à 255. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre d'octets */ short status; /* Status de l'échange */ long adr; /* Adresse du premier octet */ char tabl[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=2; adr=10; tabl[0] = 255; tabl[1] = 255; writepackqbyte(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writeword

- Ecriture de mots => WRITEWORD prototype en C :

void writeword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writeword(var nchan, neq, nb :integer; var adr :integer4; var tabl, status :integer); extern; Syntaxe : C writeword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writeword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot à écrire. tabl Tableau d'entiers 16 bits, contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de mots dans un équipement. Les différentes

valeurs sont rangées dans le tableau d'entiers "tabl".


WoodheadWoodhead


writeword exemple en langage C Microsoft Ecriture des mots 20 à 30 dans l'équipement numéro 1, depuis le canal numéro 0 de l'interface

applicom®. Les valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de mots */ short status; /* Status de l'échange */ long adr; /* Adresse du premier mot */ short tabl[11]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for ( i = 0; i < nb; i++) { printf("\n Valeur du mot %ld ?", adr+i); scanf(" %hd",&tabl[i]); } writeword(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writeqword

- Ecriture de mots de sortie => WRITEQWORD prototype en C :

void writeqword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writeqword(var nchan, neq, nb :integer; var adr :integer4; var tabl, status :integer); extern; Syntaxe : C writeqword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writeqword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEQWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot à écrire. tabl Tableau d'entiers 16 bits, contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de mots de sortie dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'entiers "tabl".


WoodheadWoodhead


writeqword exemple en langage C Microsoft Ecriture des mots de sortie 20 à 30 dans l'équipement numéro 1, depuis le canal numéro 0 de

l'interface applicom®. Les valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de mots */ short status; /* Status de l'échange */ long adr; /* Adresse du premier mot */ short tabl[11]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for ( i = 0; i < nb; i++) { printf("\n Valeur du mot %ld ?", adr+i); scanf(" %hd",&tabl[i]); } writeqword(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writewordbcd

- Ecriture de mots BCD => WRITEWORDBCD prototype en C :

void writewordbcd(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writewordbcd(var nchan, neq, nb :integer; var adr :integer4; var tabl, status :integer); extern; Syntaxe : C writewordbcd(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writewordbcd(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEWORDBCD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot à écrire tabl Tableau d'entiers 16 bits, contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de mots au format BCD dans un équipement. Exemple : Valeur passée à la fonction 9999 décimal. Valeur écrite dans l'équipement h'9999' hexadécimal. Les différentes valeurs sont rangées dans le tableau d'entiers "tabl". Si une des valeurs positionnées dans "tabl" n'est pas au format BCD, le status 3 vous sera

retourné et aucun échange ne sera exécuté.


WoodheadWoodhead


writewordbcd exemple en langage C Microsoft Ecriture des mots BCD 20 à 30 dans l'équipement numéro 1, depuis le canal numéro 0 de

l'interface applicom®. Les valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de mots */ short status; /* Status de l'échange */ long adr; /* Adresse du premier mot */ short tabl[11]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for ( i = 0; i < nb; i++) { printf("\n Valeur du mot %ld ?", adr+i); scanf(" %hd",&tabl[i]); } writewordbcd(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" Ecriture incorrect !!, status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedword

- Ecriture de mots doubles => WRITEDWORD prototype en C :

void writedword(short *, short *, short *, long *, long *, short *) prototype en MS pascal :

procédure writedword(var nchan, neq, nb :integer; var adr, tabl :integer4; var status :integer); extern; Syntaxe : C writedword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro de l'équipement (0-255). nb Entier 16 bits, nombre de mots doubles à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à écrire. tabl Tableau d'entiers 32 bits, contenant les données. status Entier 16 bits, status de l'échange. Description :

Cette fonction standard applicom® permet l'écriture de mots doubles dans un équipement. Les différentes valeurs sont à écrire dans le tableau d'entiers 32 bits 'tabl'.


WoodheadWoodhead


writedword exemple en langage C Microsoft Ecriture des 2 mots doubles à partir de l'adresse 20 de l'équipement numéro 1, depuis le canal

numéro 0 de l'interface applicom®. Leurs valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status de l'échange */ long adr; /* Adresse du premier mot double */ long tabl[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=2; adr=20; for ( i = 0; i < nb; i++) { printf("\n Valeur du mot %ld ?", adr+i); scanf(" %ld",&tabl[i]); } writedword(&nchan, &neq, &nb, &adr, tabl, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writefword

- Ecriture de mots flottants => WRITEFWORD prototype en C :

void writefword(short *, short *, short *, long *, float *, short *) prototype en MS pascal :

procédure writefword(var nchan, neq, nb :integer; var adr :integer4; var tabl :real; var status :integer);extern; Syntaxe : C writefword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writefword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEFWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots flottants à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot flottant à écrire. tabl Tableau de réels 32 bits contenant les données. status Entier 16 bits, status de l'échange. Description : Cette fonction standard applicom® permet la l'écriture de mots flottants au format IEEE dans un

équipement. Les différentes valeurs sont rangées dans le tableau de réels 32 bits 'tabl'.


WoodheadWoodhead


writefword exemple en langage C Microsoft Ecriture de 2 mots flottants à partir de l'adresse 20 dans l'équipement numéro 1, depuis le canal

numéro 0 de l'interface applicom®. Leurs valeurs sont entrées au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status de l'échange */ long adr; /* Adresse du premier mot flottant */ float tablf[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=2; adr=20; for ( i = 0; i < nb; i++) { printf("\n Valeur du mot %ld ?", adr+i); scanf(" %f",&tablf[i]); } writefword(&nchan, &neq, &nb, &adr, tablf, &status); if (status) printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writetimer

- Ecriture de temporisateurs => WRITETIMER prototype en C :

void writetimer(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writetimer(var nchan, neq, nb :integer; var adr :integer4; tabl, status :integer); extern; Syntaxe : C writetimer(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writetimer(nchan,neq,nb,adr,tabl[1],status) BASIC WRITETIMER(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, Nombre de temporisateurs (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Numéro du premier temporisateur. tabl Tableau d'entiers 16 bits contenant les 'nb' valeurs de présélections. status Entier 16 bits, Status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de valeurs de présélection liées à des

temporisateurs dans un équipement. Les différentes valeurs à écrire sont rangées dans le tableau d'entiers 16 bits 'tabl'.

Remarques : Protocole Uni-Te : - 1Temporisateur maximum. - Permet l'écriture des objets Ti,P des automates TSX (i = n° du temporisateur). Protocole 3964/3964R messagerie RK512 : - Permet l'écriture des objets TB.


WoodheadWoodhead


writetimer exemple en langage C Microsoft Ecriture de la valeur de présélection du temporisateur n°3 dans l'équipement serveur numéro 4,

depuis le canal numéro 2 de l'interface applicom®. La valeur est entrée au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de temporisateur */ long adr; /* Numéro du temporisateur */ short tabl[1]; /* Table contenant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=1; adr=3; scanf("valeur ? %hd", tabl); writetimer(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) exit(0) else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writecounter

- Ecriture de compteurs => WRITECOUNTER prototype en C :

void writecounter(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writecounter(var nchan, neq, nb : integer; var adr :integer4; var tabl, status :integer); extern; Syntaxe : C writecounter(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writecounter(nchan,neq,nb,adr,tabl[1],status) BASIC WRITECOUNTER(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de compteurs (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Numéro du premier compteur. tabl Tableau d'entiers 16 bits contenant les 'nb' valeurs de présélections. status Entier 16 bits, Status de l'échange. Description : Cette fonction standard applicom® permet l'écriture de valeurs de présélection liées à des

compteurs dans un équipement. Les différentes valeurs sont rangées dans le tableau d'entiers 16 bits 'tabl'.

Remarques : Protocole Uni-Te : - 1Compteur maximum. - Permet l'écriture des objets Ci,P des automates TSX (i = n° du temporisateur). Protocole 3964/3964R messagerie RK512 : - Permet l'écriture des objets ZB.


WoodheadWoodhead


writecounter exemple en langage C Microsoft Ecriture de la valeur de présélection du compteur n°3 dans l'équipement numéro 4, depuis le canal

numéro 2 de l'interface applicom®. La valeur est entrée au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de compteur */ long adr; /* Numéro du compteur */ short tabl[1]; /* Valeur de présélection */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=4; nb=1; adr=3; scanf("Valeur ? %hd", tabl); writecounter(&nchan, &neq, &nb, &adr, tabl, &status); if (!status) exit(0); else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdiag

- Diagnostics, Modes de marches, Sémaphores

Dans ce chapitre : - Lecture des compteurs de Diagnostics => READDIAG - Lecture des compteurs d'événements => READEVEN - Passage en STOP => MANUAL - Passage en RUN => AUTOMATIC - Connexion ou réservation => AppConnect - Déconnexion ou déréservation => AppUnconnect - Status des équipements => STATJBUS - Lecture des compteurs du maître => IOCOUNTER - R.A.Z des compteurs du maître => RESETIOCOUNTER - R.A.Z des compteurs d'erreurs => RESETCOUNTERUTE - Lecture du buffer trace => READTRACE - Lecture compteurs d'erreurs => READDIAGUTE - Identification d'un équipement => READIDENT

- Lecture des compteurs de Diagnostics => READDIAG prototype en C :

void readdiag(short *, short *, short *, short *) prototype en MS pascal :

procédure readdiag(var nchan, neq, tabl, status : integer); extern; Syntaxe : C readdiag(&nchan,&neq,tabl,&status) PASCAL readdiag(nchan,neq,tabl[1],status) BASIC READDIAG(NCHAN,NEQ,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (1-255). tabl Tableau d'entiers 16 bits, d'au moins 2 éléments. - tabl[0] = Sous code. - tabl[1] = Données. status Entier 16 bits, status de l'échange. Description : Cette fonction permet la lecture des compteurs de Diagnostics (code fonction 8) d'un équipement

Jbus / Modbus. Voir la documentation constructeur.


WoodheadWoodhead


readdiag exemple en langage C Microsoft Lecture du nombre de trames reçues avec une erreur de CRC par l'équipement 9, raccordé sur le

canal 2 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short tabl[2]; /* Tableau contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=9; tabl[0]=12; readdiag(&nchan, &neq, tabl, &status); printf(" Nombre de trames reçues avec erreur de CRC = %hd \n ", tabl[1] ); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readeven

- Lecture des compteurs d'événements => READEVEN prototype en C :

void readeven(short *, short *, short *, short *) prototype en MS pascal :

procédure readeven(var nchan, neq, val, status : integer); extern; Syntaxe : C readeven(&nchan,&neq,tabl,&status) PASCAL readeven(nchan,neq,val,status) BASIC READEVEN(NCHAN,NEQ,VAL,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (1-255). val Entier 16 bits, Recevant les données. status Entier 16 bits, Status de l'échange. Description : Cette fonction permet la lecture du compteur d'événements d'un équipement Jbus / Modbus (code

fonction 11). Voir la documentation constructeur.


WoodheadWoodhead


readeven exemple en langage C Microsoft Lecture du nombre d'événements de l'équipement 9, raccordé sur le canal 2 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short val; /* Entier contenant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=9; readeven(&nchan, &neq, &val, &status); printf(" nombre de trames reçues avec erreur de CRC = %hd \n ", val[0]); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


manual

- Passage en STOP => MANUAL prototype en C :

void manual(short *, short *, short *) prototype en MS pascal :

procédure manual(var nchan, neq, status : integer); extern; Syntaxe : C manual(&nchan,&neq,&status) PASCAL manual(nchan,neq,status) BASIC MANUAL(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de l'échange. Description : Protocole Uni-Te : Cette fonction assure la mise en 'STOP' des équipements Uni-Te. Pour certains équipements une

réservation préalable doit être effectuée (voir fonction 'AppConnect'). Protocole Jbus : Cette fonction assure la mise en 'STOP' de l'unité centrale des équipements Jbus/Modbus (code

fonction 13).


WoodheadWoodhead


manual exemple en langage C Microsoft Mise en 'STOP' de l'équipement 1 à partir du canal 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; neq=1; manual(&nchan, &neq, &status); ..... } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


automatic

- Passage en RUN => AUTOMATIC prototype en C :

void automatic(short *, short *, short *) prototype en MS pascal :

procédure automatic(var nchan, neq, status : integer); extern; Syntaxe : C automatic(&nchan,&neq,&status) PASCAL automatic(nchan,neq,status) BASIC AUTOMATIC(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de l'échange. Description : Protocole Uni-Te : Cette fonction assure la mise en 'RUN' des équipements Uni-Te. Pour certains équipements une

réservation préalable doit être effectuée (voir fonction 'AppConnect'). Protocole Jbus/Modbus : Cette fonction assure la mise en 'RUN' des équipements Jbus/Modbus (code fonction 13).


WoodheadWoodhead


automatic exemple en langage C Microsoft Mise en 'RUN' de l'équipement Uni-Te n°1 à partir du canal 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; neq=1; AppConnect(&nchan, &neq, &status); /* Réservation du serveur */ if ( status == 0) automatic(&nchan, &neq, &status); ..... } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


AppConnect

- Connexion ou réservation => AppConnect prototype en C :

void AppConnect(short *, short *, short *) prototype en MS pascal :

procédure AppConnect(var nchan, neq, status : integer); extern; Syntaxe : C AppConnect(&nchan,&neq,&status) PASCAL AppConnect(nchan,neq,status) BASIC APPCONNECT(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de l'échange. Description : Protocole Uni-Te : Cette fonction assure la réservation de l'équipement serveur visé (requête h'1D'). Cette commande

permet à un client, lors de requêtes critiques (téléchargement, Run, Stop, ...) de réserver l'équipement serveur avec lequel il veut dialoguer. La réservation est valide 60 secondes maximum.

Protocole Jbus/Modbus : Cette fonction permet de connecter le coupleur Jbus/Modbus esclave à la mémoire programme de

l'automate en assurant l'exclusion mutuelle vis à vis des autres coupleurs. Protocole 3964/3964R messagerie libre : Permet d'autoriser la réception. Protocole PROFIBUS FMS: Equivalent au service INITIATE.


WoodheadWoodhead


AppConnect exemple en langage C Microsoft Réservation de l'équipement Uni-Telway n°1 à partir du canal 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; neq=1; AppConnect(&nchan, &neq, &status); ..... } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


AppUnconnect

- Déconnexion ou déréservation => AppUnconnect prototype en C :

void AppUnconnect(short *, short *, short *) prototype en MS pascal :

procédure AppUnconnect(var nchan, neq, status : integer); extern; Syntaxe : C AppUnconnect(&nchan,&neq,&status) PASCAL AppUnconnect(nchan,neq,status) BASIC APPUNCONNECT(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de l'échange. Description : Protocole Uni-Te : Cette fonction assure la déréservation de l'équipement serveur visé (requête h'1E'). Protocole Jbus/Modbus : Cette fonction permet de déconnecter le coupleur Jbus/Modbus équipement de la mémoire de

l'automate et de la libérer pour les autres coupleurs. Protocole 3964/3964R messagerie libre : Permet de verrouiller la réception. Protocole PROFIBUS FMS: Equivalent au service ABORT avec identificateur "USER" et code 0 (ABT_RC1).


WoodheadWoodhead


AppUnconnect exemple en langage C Microsoft Déréservation de l'équipement 1 à partir du canal 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; neq=1; AppUnconnect(&nchan, &neq, &status); ..... } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


statjbus

- Status des équipements => STATJBUS prototype en C :

void statjbus(short *, short *, short *) prototype en MS pascal :

procédure statjbus(var nchan, tabl, status : integer); extern; Syntaxe : C statjbus(&nchan,tabl,&status) PASCAL statjbus(nchan,tabl[1],status) BASIC STATJBUS(NCHAN,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). tabl Tableau d'entiers 16 bits de 256 éléments recevant le status des équipements du

canal. - tabl[1] = Status des échanges avec l'équipement 1. - tabl[255] = Status des échanges avec l'équipement 255. status Entier 16 bits, status de l'échange. Description : Cette fonction spécifique Jbus/Modbus permet de consulter le status du dernier échange avec les

équipements. Si aucun échange n'a eu lieu avec un équipement son status sera positionné à 43.


WoodheadWoodhead


statjbus Exemple en langage C Microsoft Lecture du status des 20 premiers équipements raccordé sur le canal maître n°3 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short tabl[256]; /* Tableau recevant les status */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; statjbus(&nchan, tabl, &status); printf("status statjbus = %d\n ", status); if (status == 0) { for ( i=1 ; i<=20 ; i++ ) printf("Status esclave = %hd ", tabl[i] ); . . . } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


iocounter

- Lecture des compteurs du maître => IOCOUNTER prototype en C :

void iocounter(short *,short *, short *, short *) prototype en MS pascal:

procédure iocounter(var nchan, neq, tabl, status : integer); extern; Syntaxe : C iocounter(&nchan,&neq,tabl,&status) PASCAL iocounter(nchan,neq,tabl[1],status) BASIC IOCOUNTER(NCHAN,NEQ,TABL(1),STATUS) Paramètre Type nchan entier 16 bits, numéro de canal (0-31). neq entier 16 bits, numéro d'équipement (1-255). tabl tableau d'entiers recevant le status et le contenu des compteurs gérés par le

maître relatif à l'équipement NEQ. - tabl[0] = Status de l'équipement. - tabl[1] = Nombre de messages sans erreurs de transmission. - tabl[2] = Nombre de réponses de code d'exception - tabl[3] = Nombre de time-out. - tabl[4] = Nombre d'erreurs de CRC. status Entier 16 bits, status de l'échange. Description : Cette fonction permet de lire dans la tâche maître les compteurs d'erreurs liés à un équipement

Jbus / Modbus.


WoodheadWoodhead


iocounter exemple en langage C Microsoft Lecture des compteurs du maître se rapportant à de l'équipement n°9 raccordé sur le canal 2 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short tabl[5]; /* Entier contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=9; iocounter(&nchan,&neq,tabl,&status); printf("status iocounter = %d \n\t",status); if (status == 0) { printf(" Status de l'équipement = %hd \n ", tabl[0]); printf(" Nombre d'échanges réalisés = %hd \n ", tabl[1]); printf(" Nombre de code d'exception = %hd \n ", tabl[2]); printf(" Nombre de time-out = %hd \n ", tabl[3]); printf(" Nombre d'erreur de parité ou crc = %hd \n ", tabl[4]); } . } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


resetiocounter

- R.A.Z des compteurs du maître => RESETIOCOUNTER prototype en C :

void resetiocounter(short *, short *, short *) prototype en MS pascal :

procédure resetiocounter(var nchan, neq, status : integer); extern; Syntaxe : C resetiocounter(&nchan,&neq,&status) PASCAL resetiocounter(nchan,neq,status) BASIC RESETIOCOUNTER(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (1-255). status Entier 16 bits, Status de l'échange. Description : Cette fonction Jbus / Modbus permet la remise à zéro des compteurs du maître. La R.A.Z est

sélective grâce au numéro d'équipement.


WoodheadWoodhead


resetiocounter

Exemple en langage C Microsoft Remise à zéro des compteurs d'erreur de l'équipement 1 dans le maître Jbus du canal 3. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; neq=1; resetiocounter(&nchan, &neq, &status); printf(" status resetiocounter = %d \n ",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


resetcounterute

- R.A.Z des compteurs d'erreurs => RESETCOUNTERUTE prototype en C :

void resetcounterute(short *, short *, short *) prototype en MS pascal :

procédure resetcounterute(var nchan, neq, status : integer); extern; Syntaxe : C resetcounterute(&nchan,&neq,&status) PASCAL resetcounterute(nchan,neq,status) BASIC RESETCOUNTERUTE(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de l'échange. Description : Cette fonction spécifique Uni-Te permet de remettre à zéro les compteurs d'erreur d'un

équipement. Cette fonction est complémentaire à la fonction READDIAGUTE.


WoodheadWoodhead


resetcounterute Exemple en langage C Microsoft Remise à zéro du compteur de diagnostic de l'équipement 1 raccordé sur le canal 3 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { { nchan=3; neq=1; resetcounterute(&nchan, &neq, &status); if (status == 0) printf(" Reset compteur OK !!"); else printf(" Problème avec l'équipement n° %d ", neq); } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readtrace

- Lecture du buffer trace => READTRACE prototype en C :

void readtrace(short *, short *, short *, short *) prototype en MS pascal :

procédure readtrace(var nchan, neq, tabl, status : integer) ; extern; Syntaxe : C readtrace(&nchan,&neq,tabl,&status) PASCAL readtrace(nchan,neq,tabl,status) BASIC READTRACE(NCHAN,NEQ,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (1-255). tabl Tableau d'entiers 16 bits de 66 éléments recevant les données. - tabl[0] = Etat du compteur d'événements. - tabl[1] = Etat du compteur de messages. - tabl[2] à tabl[65] = Buffer trace. status Entier 16 bits, status de l'échange. Description : Cette fonction spécifique Jbus permet de consulter l'historique des 64 dernières transactions dans

l'équipement visé. Voir documentation constructeur (code fonction 12).


WoodheadWoodhead


readtrace exemple en langage C Microsoft Lecture du "Buffer trace" d'un équipement Jbus n° 9, raccordé sur le canal 2 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short tabl[66]; /* Entier contenant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=9; readtrace(&nchan, &neq, tabl, &status); printf("status readtrace = %hd \n",status); if (status == 0) { printf("\n Valeur du compteur d'événements : %hd ", tabl[0]); printf("\n Valeur du compteur de messages : %hd ", tabl[1]); for ( i=0 ; i<4 ; i++ ) { for ( j=0 ; j<8; j++ ) printf(" %04X",tabl[i*8+j+2]); } } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdiagute

- Lecture compteurs d'erreurs => READDIAGUTE prototype en C :

void readdiagute(short *, short *, short *,short *) prototype en MS pascal :

procédure readdiagute(var nchan, neq, tabl, status : integer); extern; Syntaxe : C readdiagute(&nchan,&neq,tabl,&status) PASCAL readdiagute(nchan,neq,tabl[1],status) BASIC READDIAGUTE(NCHAN,NEQ,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). tabl Tableau de 4 entiers 16 bits recevant les données. - tabl[0] = Nombre de messages émis non acquittés. - tabl[1] = Nombre de messages émis refusé. - tabl[2] = Nombre de messages reçus non acquittés. - tabl[3] = Nombre de messages reçus refusés. status Entier 16 bits, Status de l'échange. Description : Cette fonction spécifique Uni-Te permet de consulter l'historique des défauts de liaison (erreurs de

caractères, erreur de trame, erreur de protocole) de l'équipement visé. La fonction applicom® RESETCOUNTERUTE permet la remise à zéro des différents compteurs.

Remarques : Sur bus Uni-Telway

Les automates TSX esclaves Uni-Telway gèrent cette requête uniquement sur l'adresse écoute (ad2). Pour lire les compteurs du maître il faut viser son adresse système : n° Réseau = 0 n° Station = 254 n° Porte = 5 n° Module = 254 n° Voie = 100 Si l'interface applicom® est maître du bus Uni-Telway la consultation de ces compteurs est réalisable en utilisant un n° d'équipement applicom® configuré à l'adresse liaison 0 (dans la configuration par défaut celui-ci correspond au n° d'équipement applicom® 153).

Sur réseau Ethway Les automates TSX sur Ethway gèrent cette requête uniquement sur la porte réseau (Numéro de porte = 4).


WoodheadWoodhead


readdiagute exemple en langage C Microsoft Lecture des compteurs de diagnostic de l'équipement 1, depuis le canal 2 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short tabl[4]; /* Entier contenant les données */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=2; neq=1; readdiagute(&nchan, &neq, tabl, &status); for ( i = 0; i < 4; i++) printf(" compteur %hd = %hd\n", i, tabl[i]); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readident

- Identification d'un équipement => READIDENT prototype en C :

void readident(short *, short *, short *, char *, short *) prototype en MS pascal :

procédure readident(var nchan, neq, nb: integer, var tabl: byte, var status : integer); extern; Syntaxe : C readident(&nchan,&neq,&nb,tabl,&status) PASCAL readident(nchan,neq,nb,tabl[1],status) BASIC READIDENT(NCHAN,NEQ,NB,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Indique au retour le nombre de caractéres composant le message

d'identification (1-MAX). tabl Tableau d'octets recevant le message d'identification en ASCII. status Entier 16 bits, Status de l'échange. Description : Cette fonction standard applicom® permet d'identifier un équipement. Les informations

d'identification lue dans l'équipement sont retournées en ASCII dans le tableau d'octets 'tabl'.


WoodheadWoodhead


readident Exemple en langage C Microsoft Identification de l'équipement 1 du canal 3. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan = 3; /* Numéro de canal */ short neq = 1; /* Numéro d'équipement */ short nb; /* Nombre d'octets en retour */ char tabl[256]; /* Table recevant le message d'identification */ short status; /* Status */ short i; main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { readident(&nchan, &neq, &nb, tabl, &status); if (!status) { for ( i=0; i < nb; i++ ) printf(" %c", tabl[i]); } else printf(" problème sur l'équipement n° %hd \n",neq); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


txtute

- Fonction ouverte Dans ce chapitre :

- Fonction bloc texte Uni-Te => TXTUTE Accès libre à la messagerie => AuWriteReadMsg

- Fonction bloc texte Uni-Te => TXTUTE prototype en C :

void txtute(short *, short *, short *, short *, char *, char *, short *, short *, short *) prototype en MS pascal :

procédure txtute(var nchan, neq, txtic, txtil: integer; var bufemi, bufrec: byte; var txtis, txtiv, status: integer) extern; Syntaxe :

C txtute(&nchan,&neq,&txtic,&txtil,bufemi,bufrec,&txtis,&txtiv,&status) PASCAL txtute(nchan,neq,txtic,txtil,bufemi[1],bufrec[1],txtis,txtiv,status) BASIC TXTUTE(NCHAN,NEQ,TXTIC,TXTIL,BUFTX(1),BUFRX(1),TXTIS,TXTIV,STATUS)

Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). txtic Entier 16 bits, Code catégorie*256 + Code requête Uni-Te. txtil Entier 16 bits, Nombre d'octets dans la table émission. bufemi Tableau d'octets constituant la table d'émission. bufrec Tableau d'octets constituant la table de réception. txtis Entier 16 bits, Nombre d'octets de données reçus . txtiv Entier 16 bits, Compte-rendu UNI-TE. status Entier 16 bits, status de l'échange. Description : Cette fonction est assimilable au bloc texte utilisé dans les automates TSX TELEMECANIQUE. Elle

permet donc à l'utilisateur de composer sa propre requête Uni-Te. Cette fonction disponible en mode attente vous permet donc d'accéder à toutes les fonctions Uni-Te non supportées par applicom®.

Il faut renseigner le code requête ainsi que le code catégorie (txtic) et définir le champ des données dans la table d'émission (bufemi) ainsi que la longueur de cette table en octets (txtil). Le compte rendu de cette requête est retourné dans l'argument (txtiv) ainsi que le nombre d'octets de données (txtis). Les données seront stockées dans la table de réception (bufrec).

Cette fonction permet notamment l'émission de "Données non sollicitées" requête h'FC'. Dans ce cas la requête h'FC' ne retournant pas de compte rendu, l'argument status sera positionné à -9 à l'issue de l'émission.

Remarque : Sur réseau Ethway : Cette fonction permet également l'émission de message d'application à application. Ce type

d’échange n'utilisant pas de code requête l'argument "txtic" doit être positionné arbitrairement à : txtic = FFFF (h), pour l'émission de 240 octets maximum vers un bloc texte type "TXT". txtic = FFFE (h), pour l'émission de 16 octets maximum vers un bloc texte type "TLG"

(Télégramme). Ce service ne retournant pas de compte rendu, l'argument status sera positionné à -9 à l'issue de

l'émission.


WoodheadWoodhead


txtute exemple en langage C Microsoft Lecture de la liste des adresses présentes sur le bus Uni-Telway (requête h'A3'). L'interface

applicom® esclave client sur le canal 0 interroge le maître du bus configuré avec le numéro d'équipement 32 (configuration par défaut). Le maître scrute 8 adresses.

Requête émise :

Requête Cat h'A3' h'07'

Réponse échange correct :

C R Nb adr état des 152 adresses (19 octets) h'D3' h'98'

Réponse échange incorrect :

C R h'FD'

#include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short txtic; /* Code requête + Code catégorie */ short txtil; /* Nombre d'octets dans bufemi */ char bufemi[126]; /* Table d'émission */ char bufrec[126]; /* Table de réception */ short txtis; /* Entier nombre d'octets reçus */ short txtiv; /* Entier compte rendu Uni-Te */ short status; /* Status de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan = 0; neq = 32; txtic = 0x07A3; txtil = 0; txtute(&nchan, &neq, &txtic, &txtil, bufemi, bufrec, &txtis, &txtiv, &status); if ((txtiv == 0xD3) && (status == 0)) { printf(" Compte Rendu TXTiV = %hd \n ", txtiv); printf(" Nombre d'adresses gérées par le maître = %hd \n ", bufrec[0]); printf(" Etat des 8 premières adresses = %X \n ", bufrec[1]); } else { printf(" Status de l'échange = %hd \n ", status); printf(" Compte Rendu TXTiV = %hd \n ", txtiv); } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


AuWriteReadMsg

Accès libre à la messagerie => AuWriteReadMsg Prototype en C : BOOL WINAPI AuWriteReadMsg (WORD wChan, WORD wNes, DWORD dwMsgParam, WORD wNbTx, BYTE* lpbyBufTx, WORD* pwNbRx, BYTE* lpbyBufRx, DWORD* pdwStatus);

Prototype en Visual Basic : Public Declare Function AuWriteReadMsg Lib "applicom" (ByVal wChan As Integer, ByVal wEquip As Integer, ByVal dwMsgParam As Long, ByVal wNbTx As Integer, lpbyBufTx As Byte, pwNbRx As Integer, lpbyBufRx As Byte, dwStatus As Long)

Syntaxe :

C: AuWriteReadMsg (wChan, wEquip, dwMsgParam, wNbTx, &byBufTx, &wNbRx, &byBufRx, &dwStatus);

BASIC: Call AuWriteReadMsg (wChan, wEquip, dwMsgParam, wNbTx, byBufTx, wNbRx, byBufRx, dwStatus);

Paramètre Type wChan Entier 16 bits, Numéro de canal (0-31). wEquip Entier 16 bits. Numéro d’équipement visé dwMsgParam Entier 32 bits. Paramètre lié à la messagerie. wNbTx Entier 16 bits. Nombre d’octets envoyés. byBufTx Tableau d’octets. Message ou commande à envoyer. wNbRx Entier 16 bits. Attention, ce paramètre est un paramètre entrant et sortant. :

- A l’appel, il doit contenir le nombre maximum d’octets attendu. - Au retour, il contient le nombre d’octets réellement reçus. byBufRx Tableau d’octets. Message ou informations retournées par l’équipement. dwStatus Entier 32 bits. Status de l’échange.

Description : Cette fonction permet sur certain protocole un accès direct à la messagerie. Vous devez donc au-préalable, consulter le manuel lié à votre protocole pour savoir si cette fonction est supportée.

Les commandes, les paramètres et les status sont fonction du protocole visé. Lors de l’appel de cette fonction, l’utilisateur doit indiquer dans le paramètre wNbRx le nombre maximum d’octet pouvant être retourné par la fonction.

Consultez le manuel lié à votre protocole de communication pour plus d’informations.

Valeur retournée : TRUE si OK. Si cette fonction retourne FALSE en cas d’erreur, consulter la variable dwStatus pour plus d’information.

Status retourné : Si la taille du tableau d’octets récupéré lors de l’appel de la fonction est supérieure au nombre indiqué dans le paramètre wNbRx, le status 74 sera retourné.

Consultez le manuel lié à votre protocole pour plus d’informations sur les status pouvant être retournés par cette fonction.

exemple en langage C Microsoft Consultez le manuel lié à votre protocole pour avoir un exemple d’utilisation de cette fonction.


WoodheadWoodhead


readmes

- Fonctions "Ports sans protocole"

Dans ce chapitre : - Réception de messages => READMES - Emission de messages => WRITEMES - Emission réception de messages => WRITEREADMES

- Réception de messages => READMES prototype en C:

void readmes(short *, short *, short *, short *, short *, char *, short *) prototype en MS pascal :

procédure readmes(var nchan, stop, nb, tim_out, tim_ic: integer; var tabl: byte; var status: integer);extern; Syntaxe : C readmes(&nchan,&stop,&nb,&tim_out,&tim_ic,tabl,&status) PASCAL readmes(nchan,stop,nb,tim_out,tim_ic,tabl[1],status) BASIC READMES(NCHAN,NEQ,STOP,TIM_OUT,TIM_IC,TABL(1);,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). stop Entier 16 bits pouvant contenir jusqu'à deux caractères ASCII. La fin de message

sera détectée sur l'un ou l'autre des 2 caractères. - Si stop = -1, la gestion du ou des caractères d'arrêts est inactive. nb Entier 16 bits. - A l'appel nb = Nombre de caractères à recevoir (1 à MAX). - Au retour nb = Nombre de caractères reçus. tim_out Entier 16 bits, time-out (0 à 65535 ms). - Si tim_out = 0, alors le time-out est inactif. tim_ic Entier 16 bits, time-out inter-caractères (0-4000 ms). - Si tim_ic = 0, alors le time-out inter-caratères est inactif. tabl Tableau d'octets recevant le message. status Entier 16 bits, status de l'échange. status = 0, Fin de réception sur compte d'octets ou caractère de fin. status = 33, Fin de réception sur time-out (aucun caractère reçus). status = 34, Fin de réception sur défaut de parité. status = -8, Fin de réception sur time-out inter-caractères (nb indique le nombre

de caractères reçus dans tabl). Description : Cette fonction applicom® permet la réception d'une trame sur un canal de l'interface applicom®.

Les octets reçus sont rangées dans le tableau d'octets 'tabl' sans interprétation. Lorsque le time-out est inactif (time-out = 0), le canal reste bloqué en réception jusqu'à l'arrivée

d'au moins 1 caractère. A partir de cet instant le time-out est inhibé et le time-out inter-caractères est activé. La sortie en réception aura lieu soit :

- sur nombre de caractères reçus (nb). - sur caractère d'arrêt, si sa valeur est différente de -1. - sur tim_ic, si sa valeur est différente de 0.


WoodheadWoodhead


Remarques : Protocole 3964/3964R messagerie libre : - Cette fonction permet de déstocker un bloc d'informations de la mémoire tampon du canal. Afin que le canal puisse recevoir les blocs d'informations et les stocker dans sa mémoire tampon, vous devez exécuter la fonction "AppConnect" au préalable. - Les paramètres "Stop" et "Tim_ic" sont non significatifs.


WoodheadWoodhead


readmes exemple en langage C Microsoft Mise en réception d'un message sur le canal 0 de l'interface applicom®. La fin de réception sera

détectée sur le caractère ASCII LF (h'0A'). #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short stop; /* Caractère de fin */ short nb; /* Nombre de variables */ short tim_out /* Time-out */ short tim_ic /* Time-out inter-caractères */ char tabl[256]; /* Table recevant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; stop = 0x0A0A; nb=255; tim =0; tim_ic=0; readmes(&nchan, &stop, &nb, &tim, &tim_ic, tabl, &status); if (!status) for (i=0; i<nb ; i++) printf(" %c ",tabl[i]); else printf(" Problème sur canal n° %hd \n",nchan); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writemes

- Emission de messages => WRITEMES prototype en C :

void writemes(short *, short *, char *, short *) prototype en MS pascal :

procédure writemes(var nchan, nb : integer; var tabl : byte; var status: integer); extern; Syntaxe : C writemes(&nchan,&nb,tabl,&status) PASCAL writemes(nchan,nb,tabl[1],status) BASIC WRITEMES(NCHAN,NB,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb Entier 16 bits, Nombre de caractères à émettre (1 à MAX). tabl Tableau d'octets contenant le message à émettre. status Entier 16 bits, status de l'émission. Description : Cette fonction applicom® permet l'émission d'une trame sur un canal de l'interface applicom®. Le

message rangé dans le tableau d'octets 'tabl' est émis sans interprétation.


WoodheadWoodhead


writemes exemple en langage C Microsoft Emission du message " POMPE VIDANGE EN DEFAUT !! " vers l'équipement raccordé sur le

canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short nb; /* Nombre de variables */ char tabl[26]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; nb=26; strcpy(tabl,"POMPE VIDANGE EN DEFAUT !!"); writemes(&nchan, &nb, tabl, &status); if (status != 0) printf(" !! Défaut, émission incorrecte \n"); else { printf(" émission correcte \n"); . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writereadmes

- Emission réception de messages => WRITEREADMES prototype en C :

void writereadmes(short *, short *, char *, short *, short *, short *, short *, char *, short *) prototype en MS pascal :

procédure writereadmes(var nchan, nbtx: integer; var tabltx: byte; var stop, nbrx, tim, tim_ic: integer; var tablrx: byte; var status: integer);extern;

Syntaxe :

C writereadmes(&nchan,&nbtx,tabltx,&stop,&nbrx,&tim,&tim_ic,tablrx,&status) PASCAL writereadmes(nchan,nbtx,tabltx[1],stop,nbrx,tim,tim_ic,tablrx[1],status) BASIC WRITEREADMES(NCHAN,NBTX,TABLTX(1);STOP,NBRX,TIM,TIM_IC,TABLRX(1),STATUS)

Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nbtx Entier 16 bits, Nombre de caractères à envoyer (1-MAX). tabltx Tableau d'octets contenant le message à envoyer. stop Entier 16 bits pouvant contenir jusqu'à deux caractères ASCII. La fin de message

sera détectée sur l'un ou l'autre de ces 2 caractères. - Si stop = -1, la gestion du ou des caractères d'arrêts est inactive. nbrx Entier 16 bits. - A l'appel nb = Nombre de caractères à recevoir (1 à MAX). - Au retour nb = Nombre de caractères reçus. tim Entier 16 bits, time-out (0 à 65535 ms). - Si tim = 0, alors le time-out est inactif. tim_ic Entier 16 bits, time-out inter-caractères (0-4000 ms). - Si tim_ic = 0, alors le time-out inter-caratères est inactif. tablrx Tableau d'octets recevant le message. status Entier 16 bits, Status. status = 0, Fin de réception sur compte d'octets ou caractère de fin. status = 33, Fin de réception sur time-out (aucun caractère reçus). status = 34, Fin de réception sur défaut de parité. status = -8, Fin de réception sur time-out inter-caractères (nb indique le nombre

de caractères reçus dans tabl). Description : Cette fonction standard applicom® permet l'émission puis la réception d'une trame sur un canal de

l'interface applicom®. Lorsque le time-out est inactif (time-out = 0), le canal reste bloqué en réception jusqu'à l'arrivée

d'au moins 1 caractère. A partir de cet instant le time-out est inhibé et le time-out inter-caractères est activé. La sortie en réception aura lieu soit :

- sur nombre de caractères reçus (nb). - sur caractère d'arrêt, si sa valeur est différente de -1. - sur tim_ic, si sa valeur est différente de 0. Remarques : Protocole 3964/3964R messagerie libre :


WoodheadWoodhead


- La partie "READ" de cette fonction permet de déstocker un bloc d'informations de la mémoire tampon du canal. Afin que le canal puisse recevoir les blocs d'informations et les stocker dans sa mémoire tampon, vous devez exécuter la fonction "AppConnect" au préalable. - Les paramètres "Stop" et "Tim_ic" sont non significatifs.


WoodheadWoodhead


writereadmes exemple en langage C Microsoft Emission du message " POMPE VIDANGE EN DEFAUT !! " vers l'équipement raccordé sur le

canal 0 de l'interface applicom®. Puis mise en réception d'un caractère pendant 3 secondes. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short nbtx; /* Nombre de caractères à émettre */ char tabltx[26]; /* Table contenant les données à émettre */ short stop; /* Caractère de fin de réception */ short nbrx; /* Nombre de caractères à recevoir */ short tim; /* Time-out */ short tim_ic; /* Time-out inter-caractères */ char tablrx[1]; /* Table de réception */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . { do { nchan=0; nbtx=26; stop=-1; nbrx=1; tim=3000; tim_ic=0; strcpy(tabltx,"POMPE VIDANGE EN DEFAUT !!"); writereadmes(&nchan, &nbtx, tabltx, &stop, &nbrx, &tim, &tim_ic, tablrx, &status); if ( status != 0 ) printf(" !! Défaut : status émission/réception = %hd \n", status); else { printf(" Caractère reçu = %c \n ", tablrx[0]); . . } } while(status == 0); . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


AppFmsGetOd

- Fonctions spécifiques Profibus FMS

Dans ce chapitre : - Lecture de dictionnaires d'objets FMS => AppFmsGetOd - Status d’un équipement FMS => AppFmsStatus

- Lecture de dictionnaires d'objets FMS => AppFmsGetOd prototype en C :

void AppFmsGetOd ( short *, short *, short *, short *, short *, short *, void *, short *, short * ) prototype en MS pascal :

procédure AppFmsGetOd(var nchan,neq,attribut,access,index,nb: integer; var tabl: byte; var morefollows, status :integer); extern;

Syntaxe :

C AppFmsGetOd(&nchan,&neq,&attribut,&access,&index,&nb,tabl,&morefollows,&status) PASCAL AppFmsGetOd(nchan,neq,attribut,access,index,nb,tabl[1],morefollows,status) BASIC APPFMSGETOD(NCHAN,NEQ,ATTRIBUT,ACCESS,INDEX,NB,TABL(1),MOREFOLLOWS,STATUS)

Paramètre Type nchan Entier 16 bits. Numéro de canal (0-31). neq Entier 16 bits. Numéro d'équipement (0-99). attribut Entier 16 bits. 0 : Short form. 1 : Long form. access Entier 16 bits, 0 : Lecture par index. 1 : Lecture par start index. index Entier 16 bits. Numéro de l'index (ou du premier index) à lire. nb Entier 16 bits. Retourne le nombre d'octets reçu. tabl Tableau d'octets recevant les données lues. morefollows Entier 16 bits. Retourne un flag indiquant la présence d'index suivant si la

fonction a été utilisée par start index. 0 : Plus d'index après la lecture. 1 : Encore un (ou des) index(s) après la lecture. status Entier 16 bits, Status de l'échange. Description : Cette fonction spécifique PROFIBUS FMS permet la lecture du dictionnaire d'objets d'un

équipement. Les données sont retournées suivant la convention PROFIBUS (Poids fort en premier). Le contenu du tableau d’octets « tabl » est à interpréter suivant la norme DIN 19 245 part 2.


WoodheadWoodhead


AppFmsGetOd


WoodheadWoodhead


AppFmsStatus

- Status d’un équipement FMS => AppFmsStatus prototype en C :

void AppFmsStatus ( short *, short *, unsigned short *, unsigned short *, short * ) prototype en MS pascal :

procédure AppFmsStatus( var nchan, neq : integer ; var logstat, phystat : word ; var status : integer ); extern; Syntaxe : C AppFmsStatus( &nchan, &neq, &logstat, &phystat, &status ) PASCAL AppFmsStatus( nchan, neq, logstat, phystat, status ) BASIC APPFMSSTATUS( NCHAN, NEQ, LOGSTAT, PHYSTAT, STATUS ) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-99). logstat Entier 16 bits non signé, Status logique PROFIBUS.

Valeur : 0 : State changes allowed. Prêt à communiquer, tous les services peuvent être exploités normalement. 2 : Limited services permitted. Nombre limité de services, au moins les services suivants sont accessibles comme serveurs: Etablissement, Rejet, Identification, Etat, Demande OD. 4 : OD loading non interacting. Chargement OD impossible, cette signalisation d’état indique qu’un chargement de dictionnaire d’objets (OD) ne peut avoir lieu. 5 : OD loading interacting. Chargement OD possible , toutes les connexions, sauf celle permettant l’émission ou la demande de l’OD, sont bloquées. La demande d’établissement d’une connexion est rejetée.

phystat Entier 16 bits non signé, Status physique PROFIBUS Valeur : 0 : Operational. Opérationnel. 1 : Partialy operational. Partiellement opérationnel. 2 : Inoperable. Non opérationnel. 3 : Needs commissioning. Intervention d’entretien requis. status Entier 16 bits, Status de l'échange. Description : Cette fonction spécifique PROFIBUS FMS permet la lecture du status logique et physique des

équipements.


WoodheadWoodhead


AppFmsStatus Exemple en langage C Microsoft Lecture des status FMS de l'équipement Profibus 1 du canal 3. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan = 3; /* Numéro de canal */ short neq = 1; /* Numéro d'équipement */ unsigned short logstat; /* Status logique FMS */ unsigned short phystat; /* Status physique FMS */ short status; /* Status applicom® de l'échange */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . . AppFmsStatus( &nchan, &neq, &logstat, &phystat, &status); if ( status == 0 ) { printf("Logical Status : "); switch(logstat) { case 0 : printf("state changes allowed\n") ; break; case 2 : printf("limited services permitted\n") ; break; case 4 : printf("OD loading non interacting\n") ; break; case 5 : printf("OD loading interacting\n") ; break; default : printf("Bad logical status value = %hd\n", logstat ); } printf("Physical Status : "); switch(phystat) { case 0 : printf("operational\n") ; break; case 1 : printf("partially operational\n") ; break; case 2 : printf("inoperable\n") ; break; case 3 : printf("needs commissioning\n") ; break; default: printf("Bad physical status value = %hd\n", phystat ); } } else printf(" problème sur l'équipement n° %hd status %hd \n", neq , status ); . .; } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead

Librairie/DLL • 119 • - Fonctions du mode différé

conditions d’utilisation

6. - Fonctions du mode différé

Dans ce chapitre :

- Conditions d’utilisation - Lecture - Ecriture - Fonctions "Ports sans protocole" - Fonction ouverte - Transfert de demande différée.

- Conditions d’utilisation Le gestionnaire de demandes différées est capable d’accepter des requêtes dans un

environnement « multitâche » (MS-Windows NT, OS/2, Unix,...). Le gestionnaire de demandes différées de chaque interface applicom® peut accepter des requêtes

provenant de 8 tâches (ou threads) différentes. Une tâche est référencée dans le gestionnaire lors de sa première requête (si une 9ème tâche tente d’accéder au mode différé, le status 40 est retourné). Chaque tâche récupère le résultat des requêtes qu’elle a formulées et pour un canal donné, dans l’ordre des demandes.

La tâche libère sa place et les ressources qu’elle utilise ( requêtes effectuées dont le résultat n’a pas été réclamé) par la fonction exitbus (à appeler impérativement à la fermeture de l’application)


WoodheadWoodhead


readdifbit

- Lecture

Dans ce chapitre : - Lecture de bits => READDIFBIT - Lecture de bits d'entrée => READDIFIBIT - Lecture de bits de sortie => READDIFQBIT - Lecture d'octets => READDIFBYTE - Lecture d'octets d'entrée => READDIFIBYTE - Lecture d'octets de sortie => READDIFQBYTE - Lecture de mots => READDIFWORD - Lecture de mots d'entrée => READDIFIWORD - Lecture de mots de sortie => READDIFQWORD - Lecture de mots doubles => READDIFDWORD - Lecture de mots flottants => READDIFFWORD - Lecture rapide de 8 bits => READDIFQUICKBIT

- Lecture de bits => READDIFBIT prototype en C :

void readdifbit (short *, short *, short *, long*, short *) prototype en MS pascal :

procédure readdifbit(var nchan, neq, nb :integer; var adr :integer4; var status :integer); extern; Syntaxe : C readdifbit(&nchan,&neq,&nb,&adr,&status) PASCAL readdifbit(nchan,neq,nb,adr,status) BASIC READDIFBIT(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de bits dans un équipement. Les

différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdifbit exemple en langage C Microsoft Lecture différée des bits 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifbit(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifibit

- Lecture de bits d'entrée => READDIFIBIT prototype en C :

void readdifibit(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifibit(var nchan, neq, nb, status: integer; var adr: integer4); extern; Syntaxe : C readdifibit(&nchan,&neq,&nb,&adr,&status) PASCAL readdifibit(nchan,neq,nb,adr,status) BASIC READDIFIBIT(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de bits d'entrée dans un équipement.

Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdifibit Exemple en langage C Microsoft Lecture différée des bits d'entrée 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifibit(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifqbit

- Lecture de bits de sortie => READDIFQBIT prototype en C :

void readdifqbit(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifqbit(var nchan, neq, nb, status: integer; var adr: integer4); extern; Syntaxe : C readdifqbit(&nchan,&neq,&nb,&adr,&status) PASCAL readdifqbit(nchan,neq,nb,adr,status) BASIC READDIFQBIT(NCHAN,NEQ,NB,ADR(1);,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de bits à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de bits de sortie dans un équipement.

Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdifqbit exemple en langage C Microsoft Lecture différée des bits de sortie 0 à 7 dans l'équipement numéro 6, à partir canal numéro 0 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=0; neq=6; nb=8, adr=0; readdifqbit(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifbyte

- Lecture d'octets => READDIFBYTE prototype en C :

void readdifbyte(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifbyte(var nchan, neq, nb, status: integer; var adr: integer4); extern; Syntaxe : C readdifbyte(&nchan,&neq,&nb,&adr,&status) PASCAL readdifbyte(nchan,neq,nb,adr,status) BASIC READDIFBYTE(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée d'octets dans un équipement. Les



WoodheadWoodhead


readdifbyte exemple en langage C Microsoft Lecture différée des octets 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifbyte(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifibyte

- Lecture d'octets d'entrée => READDIFIBYTE prototype en C :

void readdifibyte(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifibyte(var nchan, neq, nb, status: integer; var adr: integer4); extern; Syntaxe : C readdifibyte(&nchan,&neq,&nb,&adr,&status) PASCAL readdifibyte(nchan,neq,nb,adr,status) BASIC READDIFIBYTE(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée d'octets d'entrée dans un

équipement. Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdifibyte exemple en langage C Microsoft Lecture différée des octets d'entrée 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifibyte(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifqbyte

- Lecture d'octets de sortie => READDIFQBYTE prototype en C :

void readdifqbyte(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifqbyte(var nchan, neq, nb, status: integer; var adr: integer4);extern; Syntaxe : C readdifqbyte(&nchan,&neq,&nb,&adr,&status) PASCAL readdifqbyte(nchan,neq,nb,adr,status) BASIC READDIFQBYTE(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier bit à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée d'octets de sortie dans un



WoodheadWoodhead


readdifqbyte exemple en langage C Microsoft Lecture différée des octets de sortie 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifqbyte(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifword

- Lecture de mots => READDIFWORD prototype en C :

void readdifword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifword(var nchan, neq, nb: integer ; var adr: integer4; var status: integer);extern; Syntaxe : C readdifword(&nchan,&neq,&nb,&adr,&status) PASCAL readdifword(nchan,neq,nb,adr,status) BASIC READDIFWORD(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de mots dans un équipement. Les



WoodheadWoodhead


readdifword exemple en langage C Microsoft Lecture différée des mots 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifword(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifiword

- Lecture de mots d'entrée => READDIFIWORD prototype en C :

void readdifiword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifiword(var nchan, neq, nb: integer; var adr : integer; var tabl, status: integer);extern; Syntaxe : C readdifiword(&nchan,&neq,&nb,&adr,&status) PASCAL readdifiword(nchan,neq,nb,adr,status) BASIC READDIFIWORD(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots d'entrée à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot d'entrée à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de mots d'entrée dans un



WoodheadWoodhead


readdifiword exemple en langage C Microsoft Lecture différée des mots d'entrée 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifiword(&nchan, &neq, &nb, &adr, &status); printf(" Status = %d \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifqword

- Lecture de mots de sortie => READDIFQWORD prototype en C :

void readdifqword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifqword(var nchan, neq, nb: integer; var adr : integer; var tabl, status: integer);extern; Syntaxe : C readdifqword(&nchan,&neq,&nb,&adr,&status) PASCAL readdifqword(nchan,neq,nb,adr,status) BASIC READDIFQWORD(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots de sortie à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot de sortie à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de mots de sortie dans un



WoodheadWoodhead


readdifqword exemple en langage C Microsoft Lecture différée des mots de sortie 0 à 33 dans l'équipement numéro 6, à partir canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=34, adr=0; readdifqword(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifdword

- Lecture de mots doubles => READDIFDWORD prototype en C :

void readdifdword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdifdword(var nchan, neq, nb: integer; var adr: integer4; var status :integer); extern; Syntaxe : C readdifdword(&nchan,&neq,&nb,&adr,&status) PASCAL readdifdword(nchan,neq,nb,adr,status) BASIC READDIFDWORD(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot double à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de mots doubles dans un



WoodheadWoodhead


readdifdword exemple en langage C Microsoft Lecture différée de 4 mots doubles à partir de l'adresse 20 dans l'équipement numéro 6, raccordé

sur le canal numéro 1 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=4, adr=20; readdifdword(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdiffword

- Lecture de mots flottants => READDIFFWORD prototype en C :

void readdiffword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure readdiffword(var nchan, neq, nb: integer; var adr: integer4; var status: integer); extern; Syntaxe : C readdiffword(&nchan,&neq,&nb,&adr,&status) PASCAL readdiffword(nchan,neq,nb,adr,status) BASIC READDIFFWORD(NCHAN,NEQ,NB,ADR(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots flottants à lire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot flottant à lire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la lecture différée de mots flottants au format IEEE

dans un équipement. Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdiffword exemple en langage C Microsoft Lecture différée de 4 mots flottants à partir de l'adresse 20 dans l'équipement numéro 6, raccordé

sur le canal numéro 1 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; nb=4, adr=20; readdiffword(&nchan, &neq, &nb, &adr, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifquickbit

- Lecture rapide de 8 bits => READDIFQUICKBIT prototype en C :

void readdifquickbit(short *, short *, short *) prototype en MS pascal :

procédure readdifquickbit(var nchan, neq, status: integer); extern; Syntaxe : C readdifquickbit(&nchan,&neq,&status) PASCAL readdifquickbit(nchan,neq,status) BASIC READDIFQUICKBIT(NCHAN,NEQ,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de lecture différée alors que le registre est plein. Description : Cette fonction spécifique permet la lecture rapide de 8 bits gérée par le protocole Jbus (code

fonction Jbus = 7). Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


readdifquickbit exemple en langage C Microsoft Lecture rapide de 8 bits dans l'équipement Jbus numéro 6, raccordé sur le canal numéro 1 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short status; /* Status */ main() { . /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nchan=1; neq=6; readdifquickbit(&nchan, &neq, &status); printf(" Status = %hd \n", status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifpackbit

- Ecriture Dans ce chapitre :

- Ecriture de bits => WRITEDIFPACKBIT - Ecriture de bits de sortie => WRITEDIFPACKQBIT - Ecriture d'octets => WRITEDIFPACKBYTE - Ecriture d'octets de sortie => WRITEDIFPACKQBYTE - Ecriture de mots => WRITEDIFWORD - Ecriture de mots de sortie => WRITEDIFQWORD - Ecriture de mots doubles => WRITEDIFDWORD - Ecriture de mots flottants => WRITEDIFFWORD

- Ecriture de bits => WRITEDIFPACKBIT prototype en C :

void writedifpackbit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writedifpackbit(var nchan, neq, nb: integer; var adr: integer4; var tabl, status: integer); extern; Syntaxe : C writedifpackbit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifpackbit(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFPACKBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de bits à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à écrire. tabl Tableau d'entiers 16 bits, contenant les données. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de bits dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'entiers 'tabl' en mode "packé" (16 bits par entier). Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifpackbit exemple en langage C Microsoft Mise à 1, des bits 20 à 30 dans l'équipement numéro 4, à partir du canal numéro 2 de l'interface

applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status */ long adr; /* Adresse de la première variable */ short tabl[1]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . { nchan=2; neq=4; nb=11; adr=20; tabl[0] = 0x07FF; writedifpackbit(&nchan, &neq, &nb, &adr, tabl, &status); if(status == 41) printf(" !! Défaut : Le registre de demande différée est plein \n"); } . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifpackqbit

- Ecriture de bits de sortie => WRITEDIFPACKQBIT prototype en C :

void writedifpackqbit(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writedifpackqbit(var nchan, neq, nb: integer; var adr: integer4; var tabl, status: integer); extern; Syntaxe : C writedifpackqbit(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifpackqbit(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFPACKQBIT(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre de bits à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à écrire. tabl Tableau d'entiers 16 bits, contenant les données. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de bits dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'entiers 'tabl' en mode "packé" (16 bits par entier). Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifpackqbit exemple en langage C Microsoft Mise à 1, des bits de sortie 20 à 30 dans l'équipement numéro 4, à partir du canal numéro 2 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status */ long adr; /* Adresse de la première variable */ short tabl[1]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . { nchan=2; neq=4; nb=11; adr=20; tabl[0] = 0x07FF; writedifpackqbit(&nchan, &neq, &nb, &adr, tabl, &status); if(status == 41) printf(" !! Défaut : Le registre de demande différée est plein \n"); } . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifpackbyte

- Ecriture d'octets => WRITEDIFPACKBYTE prototype en C :

void writedifpackbyte(short *, short *, short *, long*, char *, short *) prototype en MS pascal :

procédure writedifpackbyte(var nchan,neq,nb:integer;var adr:integer4; var tabl : byte; var status : integer);extern; Syntaxe : C writedifpackbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifpackbyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFPACKBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à écrire. tabl Tableau d'octets contenant les données à écrire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture d'octets dans un équipement. Les différentes

valeurs sont rangées dans le tableau d'octets 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le

nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifpackbyte exemple en langage C Microsoft Mise à 255, des octets 20 et 21 dans l'équipement numéro 4, à partir du canal numéro 2 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status */ long adr; /* Adresse de la première variable */ char tabl[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . { nchan=2; neq=4; nb=2; adr=20; tabl[0] = 255; tabl[1] = 255; writedifpackbyte(&nchan, &neq, &nb, &adr, tabl, &status); if(status == 41) printf(" !! Défaut : Le registre de demande différée est plein \n"); } . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifpackqbyte

- Ecriture d'octets de sortie => WRITEDIFPACKQBYTE prototype en C :

void writedifpackqbyte(short *, short *, short *, long*, char *, short *) prototype en MS pascal :

procédure writedifpackqbyte(var nchan,neq,nb:integer;var adr:integer4; var tabl : byte; var status : integer);extern; Syntaxe : C writedifpackqbyte(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifpackqbyte(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFPACKQBYTE(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb Entier 16 bits, nombre d'octets à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier bit à écrire. tabl Tableau d'octets contenant les données à écrire. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative de d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée d'octets de sortie dans un

équipement. Les différentes valeurs sont rangées dans le tableau d'octets 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le

nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifpackqbyte exemple en langage C Microsoft Mise à 255, des octets de sortie 20 et 21 dans l'équipement numéro 4, à partir du canal numéro 2

de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ short status; /* Status */ long adr; /* Adresse de la première variable */ char tabl[2]; /* Table contenant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . { nchan=2; neq=4; nb=2; adr=20; tabl[0] = 255; tabl[1] = 255; writedifpackqbyte(&nchan, &neq, &nb, &adr, tabl, &status); if(status == 41) printf(" !! Défaut : Le registre de demande différée est plein \n"); } . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifword

- Ecriture de mots => WRITEDIFWORD prototype en C :

void writedifword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writedifword(var nchan, neq, nb: integer; var adr: integer4; var tabl, status: integer); extern; Syntaxe : C writedifword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb entier 16 bits, nombre de mots à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à écrire. tabl Tableau d'entiers 16 bits, contenant les données status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de mots dans un équipement. Les

différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifword exemple en langage C Microsoft Ecriture différée des mots 20 à 30 de l'équipement numéro 1, raccordé sur le canal numéro 0 de

l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short tabl[11]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for (i=0; i<nb; i++) { printf("\n valeur mot %ld ?",adr+i); scanf(" %hd ", &tabl[i] ); } writedifword(&nchan, &neq, &nb, &adr, tabl, &status); if (status != 0) { printf(" !! Défaut : Demande différée non prise en compte \n"); } else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifqword

- Ecriture de mots de sortie => WRITEDIFQWORD prototype en C :

void writedifqword(short *, short *, short *, long *, short *, short *) prototype en MS pascal :

procédure writedifqword(var nchan, neq, nb: integer; var adr: integer4 ;var tabl, status: integer); extern; Syntaxe : C writedifqword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifqword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFQWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, numéro de canal (0-31). neq Entier 16 bits, numéro d'équipement (0-255). nb entier 16 bits, nombre de mots à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, adresse du premier mot à écrire. tabl Tableau d'entiers 16 bits, contenant les données status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de mots de sortie dans un

équipement. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifqword exemple en langage C Microsoft Ecriture différée des mots de sortie 20 à 30 de l'équipement numéro 1, raccordé sur le canal

numéro 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short tabl[11]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for (i=0; i<nb; i++) { printf("\n valeur mot %ld ?",adr+i); scanf(" %hd ", &tabl[i] ); } writedifqword(&nchan, &neq, &nb, &adr, tabl, &status); if (status != 0) { printf(" !! Défaut : Demande différée non prise en compte \n"); } else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifdword

- Ecriture de mots doubles => WRITEDIFDWORD prototype en C :

void writedifdword(short *, short *, short *, long *, long *, short *) prototype en MS pascal :

procédure writedifdword(var nchan, neq, nb: integer; var adr, tabl: integer4; var status :integer); extern; Syntaxe : C writedifdword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writedifdword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFDWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots doubles à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot double à écrire. tabl Tableau d'entiers 32 bits, contenant les données. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de mots doubles dans un équipement.

Les différentes valeurs sont rangées dans le tableau d'entiers 32 bits 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifdword exemple en langage C Microsoft Ecriture différée de 11 mots doubles à partir de l'adresse 20 dans l'équipement numéro 1, raccordé

sur le canal numéro 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ long tabl[11]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for (i=0; i<nb; i++) { printf("\n valeur mot double %ld ?",adr+i); scanf(" %ld ", &tabl[i] ); } writedifdword(&nchan, &neq, &nb, &adr, tabl, &status); if (status != 0) { printf(" !! Défaut : Demande différée non prise en compte \n"); } else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writediffword

- Ecriture de mots flottants => WRITEDIFFWORD prototype en C :

void writediffword( short *, short *, short *, long *, float *, short * ) prototype en MS pascal :

procédure writediffword(var nchan,neq,nb:integer;var adr: integer4;var tabl:real; var status:integer);extern; Syntaxe : C writediffword(&nchan,&neq,&nb,&adr,tabl,&status) PASCAL writediffword(nchan,neq,nb,adr,tabl[1],status) BASIC WRITEDIFFWORD(NCHAN,NEQ,NB,ADR(1),TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). neq Entier 16 bits, Numéro d'équipement (0-255). nb Entier 16 bits, Nombre de mots flottants à écrire (1-MAX). (le nombre maximum dépend du protocole et de l'équipement cible). adr Entier 32 bits, Adresse du premier mot flottant à écrire. tabl Tableau de réels 32 bits contenant les données. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Tentative d'écriture différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'écriture différée de mots flottants au format IEEE dans

un équipement. Les différentes valeurs sont rangées dans le tableau de réels 32 bits 'tabl'. Le compte rendu d'écriture sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writediffword exemple en langage C Microsoft Ecriture différée de 11 mots flottants à partir de l'adresse 20 dans l'équipement numéro 1, raccordé

sur le canal numéro 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ float tabl[11]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; neq=1; nb=11; adr=20; for (i=0;i<nb;i++) { printf("\n valeur mot flottant %ld ?",adr+i); scanf(" %f ", &tabl[i] ); } writediffword(&nchan, &neq, &nb, &adr, tabl, &status); if (status != 0) { printf(" !! Défaut : Demande différée non prise en compte \n"); } else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


readdifmes

- Fonctions "Ports sans protocole" Dans ce chapitre :

- Réception de messages => READDIFMES - Emission de messages => WRITEDIFMES - Emission réception de messages => WRITEREADDIFMES

- Réception de messages => READDIFMES prototype en C :

void readdifmes( short *, short *, short *, short *, short *, short *) prototype en MS pascal :

procédure readdifmes( var nchan, stop, nb, tim_out, tim_ic, status: integer ); extern; Syntaxe : C readdifmes(&nchan,&stop,&nb,&tim_out,&tim_ic,&status) PASCAL readdifmes(nchan,stop,nb,tim_out,tim_ic,status) BASIC READDIFMES(NCHAN,STOP,NB,TIM_OUT,TIM_IC,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). stop Entier 16 bits pouvant contenir jusqu'à deux caractères ASCII. La fin de message

sera détectée sur l'un ou l'autre de ces 2 caractères. - Si stop = -1, la gestion du ou des caractères d'arrêts est inactive. nb Entier 16 bits, Nombre de caractères à recevoir (1 à MAX). tim_out Entier 16 bits, time-out (0 à 65535 ms) - Si tim_out = 0, alors le time-out est inactif. tim_ic Entier 16 bits, time-out inter-caractères (0 à 4000 ms). - Si tim_ic = 0, alors le time-out inter-caratères est inactif. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Demande différée alors que le registre est plein. Description : Cette fonction standard applicom® permet la réception en mode différé d'une trame sur un canal

de l'interface applicom®. Les différentes valeurs seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.

Lorsque le time-out est inactif (time-out = 0), le canal reste bloqué en réception jusqu'à l'arrivée d'au moins 1 caractère. A partir de cet instant le time-out est inhibé et le time-out inter-caractères est activé. La sortie en réception aura lieu soit :

- sur nombre de caractères reçus (nb). - sur caractère d'arrêt, si sa valeur est différente de -1. - sur tim_ic, si sa valeur est différente de 0. Remarques :


WoodheadWoodhead


Protocole 3964/3964R messagerie libre : - Cette fonction permet de déstocker un bloc d'informations de la mémoire tampon du canal. Afin que le canal puisse recevoir les blocs d'informations et les stocker dans sa mémoire tampon,

vous devez exécuter la fonction "AppConnect" au préalable. - Les paramètres "Stop" et "Tim_ic" sont non significatifs.


WoodheadWoodhead


readdifmes exemple en langage C Microsoft Mise en réception différée sur le canal 0 de l'interface applicom®. La fin de réception sera

détectée sur le caractère ASCII LF (h'0A'). Pas de gestion de time-out ni de time-out inter-caractères. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short stop; /* Caractère de fin */ short nb; /* Nombre de variables */ short tim_out; /* Time-out */ short tim_ic; /* Time-out inter-caractères */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; stop = 0x0A0A; nb=256; tim_out =0; tim_ic=0; readdifmes(&nchan, &stop, &nb, &tim_out, &tim_ic, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writedifmes

- Emission de messages => WRITEDIFMES prototype en C :

void writedifmes( short *, short *, char *, short * ) prototype en MS pascal :

procédure writedifmes( var nchan, nb: integer; var tabl: byte; var status :integer ); extern; Syntaxe : C writedifmes( &nchan, &nb, tabl, &status ) PASCAL writedifmes( nchan, nb, tabl[1], status ) BASIC WRITEDIFMES( NCHAN, NB, TABL(1), STATUS ) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb Entier 16 bits, Nombre de caractères à envoyer (1-MAX). tabl Tableau d'octets contenant le message. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Demande différée alors que le registre est plein. Description : Cette fonction standard applicom® permet l'émission en mode différé d'une trame sur un canal de

l'interface applicom®. Le message rangé dans le tableau d'octets 'tabl' est émis sans interprétation. Le compte rendu d'émission sera remonté par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


writedifmes exemple en langage C Microsoft Emission en mode différé du message " POMPE VIDANGE EN DEFAUT !! " vers l'équipement

raccordé sur le canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short nb; /* Nombre de variables */ char tabl[26]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; nb=26; strcpy(tabl,"POMPE VIDANGE EN DEFAUT !!"); writedifmes(&nchan, &nb, tabl, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


writereaddifmes

- Emission réception de messages => WRITEREADDIFMES prototype en C :

void writereaddifmes( short *, short *, char *, short *, short *, short *, short *, short * ) prototype en MS pascal :

procédure writereaddifmes(var nchan, nbtx :integer; var tabltx: byte; var stop, nbrx, tim, tim_ic,status: integer);extern;

Syntaxe :

C writereaddifmes(&nchan,&nbtx,tabltx,&stop,&nbrx,&tim,&tim_ic,&status) PASCAL writereaddifmes(nchan,nbtx,tabltx[1],stop,nbrx,tim,tim_ic,status) BASIC WRITEREADDIFMES(NCHAN,NBTX,TABLTX(1),STOP,NBRX,TIM,TIM_IC,STATUS)

Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nbtx Entier 16 bits, Nombre de caractères à envoyer (1-MAX). tabltx Tableau d'octets contenant le message à envoyer. stop Entier 16 bits pouvant contenir jusqu'à deux caractères ASCII. La fin de message

sera détectée sur l'un ou l'autre de ces 2 caractères. - Si stop = -1, la gestion du ou des caractères d'arrêts est inactive. nbrx Entier 16 bits, Nombre de caractères à recevoir (1 à MAX). tim Entier 16 bits, time-out (0 à 65535 ms). - Si tim = 0, alors le time-out est inactif. tim_ic Entier 16 bits, time-out inter-caractères (0-4000 ms). - Si tim_ic = 0, alors le time-out inter-caratères est inactif. status Entier 16 bits, Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Demande différée alors que le registre est plein. Description : Cette fonction standard applicom® permet d'émettre puis de recevoir une trame en mode différé

sur un canal de l'interface applicom®. Le message à émettre est rangé dans le tableau d'octets 'tabl'. Le compte rendu d'émission/réception ainsi que les données reçues seront remontés par la

fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.

Lorsque le time-out est inactif (time-out = 0), le canal reste bloqué en réception jusqu'à l'arrivée d'au moins 1 caractère. A partir de cet instant le time-out est inhibé et le time-out inter-caractères est activé. La sortie en réception aura lieu soit :

- sur nombre de caractères reçus (nb). - sur caractère d'arrêt, si sa valeur est différente de -1. - sur tim_ic, si sa valeur est différente de 0. Remarques : Protocole 3964/3964R messagerie libre : - La partie "READ" de cette fonction permet de déstocker un bloc d'informations de la mémoire

tampon du canal. Afin que le canal puisse recevoir les blocs d'informations et les stocker dans sa mémoire tampon, vous devez exécuter la fonction "AppConnect" au préalable.


WoodheadWoodhead


- Les paramètres "Stop" et "Tim_ic" sont non significatifs.


WoodheadWoodhead


writereaddifmes exemple en langage C Microsoft Emission en mode différé du message " POMPE VIDANGE EN DEFAUT !! " vers l'équipement

raccordé sur le canal 0 de l'interface applicom®. Puis mise en réception d'un caractère pendant 3 secondes.

#include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short nbtx; /* Nombre de caractères à émettre */ char tabltx[26]; /* Table contenant les données à émettre */ short stop; /* Caractère de fin de réception */ short nbrx; /* Nombre de caractères à recevoir */ short tim; /* Time-out */ short tim_ic; /* Time-out inter-caractères */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=0; nbtx=26; stop=-1; nbrx=1; tim=3000, tim_ic=0; strcpy(tabltx,"POMPE VIDANGE EN DEFAUT !!"); writereaddifmes(&nchan, &nbtx, tabltx, &stop, &nbrx, &tim, &tim_ic, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { . . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


AuWriteReadDifMsg

- Fonction ouverte Dans ce chapitre :

Accès libre à la messagerie => AuWriteReadDifMsg

Accès libre à la messagerie => AuWriteReadDifMsg Prototype en C : BOOL WINAPI AuWriteReadDifMsg (WORD wChan, WORD wNes, DWORD dwMsgParam, WORD wNbTx, BYTE* lpbyBufTx, DWORD* pdwStatus);

Prototype en Visual Basic : Public Declare Function AuWriteReadDifMsg Lib "applicom" (ByVal wChan As Integer, ByVal wEquip As Integer, ByVal dwMsgParam As Long, ByVal wNbTx As Integer, lpbyBufTx As Byte, dwStatus As Long)

Syntaxe :

C: AuWriteReadDifMsg (wChan, wEquip, dwMsgParam, wNbTx, &byBufTx, &dwStatus);

BASIC: Call AuWriteReadDifMsg (wChan, wEquip, dwMsgParam, wNbTx, byBufTx, dwStatus);

Paramètre Type wchan Entier 16 bits, Numéro de canal (0-31). wEquip Entier 16 bits. Numéro d’équipement visé dwMsgParam Entier 32 bits. Paramètre lié à la messagerie. wNbTx Entier 16 bits. Nombre d’octets envoyés. byBufTx Tableau d’octets. Message ou commande à envoyer. dwStatus Entier 32 bits. Status de prise en compte par le gestionnaire de fonctions

différées. 0 = Prise en compte correcte. 41 = Demande différée alors que le registre est plein.

Description : Cette fonction permet sur certain protocole un accès direct à la messagerie en mode différé. Vous devez donc au-préalable, consulter le manuel lié à votre protocole pour savoir si cette fonction est supportée.

Le compte rendu d'émission/réception ainsi que les données reçues seront remontées par la fonction TRANSDIF ou TRANSDIFPACK. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.

Attention : la récupération des données par le biais des fonctions TRANSDIF ou TRANSDIFPACK présente des particularités d’utilisation. Consultez la documentation de ces fonctions

Valeur retournée : TRUE si OK. Si cette fonction retourne FALSE en cas d’erreur, consulter la variable dwStatus pour plus d’information.

exemple en langage C Microsoft


WoodheadWoodhead


Consultez le manuel lié à votre protocole pour avoir un exemple d’utilisation de cette fonction.


WoodheadWoodhead


transdif

- Transfert de demande différée. Dans ce chapitre :

- Transfert différé au format dépacké => TRANSDIF - Transfert différé au format packé => TRANSDIFPACK - Test de demandes différées => TESTTRANSDIF

- Transfert différé au format dépacké => TRANSDIF prototype en C :

void transdif(short *, short *, short *, void *, short *) prototype en MS pascal :

procédure transdif(var nchan, nb, typ: integer; var tabl: integer4; var status: integer); extern; Syntaxe : C transdif(&nchan,&nb,&typ,tabl,&status) PASCAL transdif(nchan,nb,typ,tabl[1],status) BASIC TRANSDIF(NCHAN,NB,TYP,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb Entier 16 bits, Nombre de variables transférées. typ Entier 16 bits, Mot indiquant le type des variables retournées. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant 32 bits. tabl Tableau d'éléments 32 bits recevant les données. status Entier 16 bits. Status de l'échange. Description : Cette fonction permet de consulter le résultat d'une demande différée. Suite à une demande différée de lecture (ou de réception de message) les variables seront

rangées au format dépacké, une variable par élément 32 bits du tableau "tabl". Suite à une demande différée d'écriture (ou d'émission de message), aucune donnée n'est

transférée et l'argument "status" sera égal à -1 si l'échange s'est passé correctement. Si TRANSDIF est utilisé alors que la demande différée n'est pas encore réalisée, le status -5 vous

sera retourné. Si vous procédez à des TRANSDIF alors qu'il n'y a plus de demandes différées en cours le status

42 vous sera retourné. Remarque: Lors de l’utilisation de cette fonction dans le cadre de la récupération de données faisant suite à un

appel à la fonction AuWriteReadDifMsg, l’utilisateur doit indiquer dans le paramètre nb la taille maximale du tableau d’octet pouvant être retourné par la fonction.


WoodheadWoodhead


Consultez le manuel lié à votre protocole de communication pour plus d’informations Si la taille du tableau d’octets récupéré lors de l’appel de la fonction est supérieure au nombre

indiqué dans le paramètre nb, le status 74 sera retourné.


WoodheadWoodhead


transdif exemple en langage C Microsoft Lecture différée du mot 20 de l'équipement numéro 1, puis du mot 30 de l'équipement 2, raccordés

sur le canal numéro 0 de l'interface applicom®. Puis transfert des résultats. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short typ; /* Type de variables */ long tablong[10]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . nchan=0; neq=1; nb=1; adr=20; readdifword(&nchan, &neq, &nb, &adr, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { neq=2; adr=30; readdifword(&nchan, &neq, &nb, &adr, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { . do { do { transdif(&nchan, &nb, &typ, tablong, &status); } while(status == -5); switch(status) { case 0 : /* Lecture correcte */ for(i=0; i<nb; i++) printf("%ld \n" ; tablong[i]); break; case -1 : /* Ecriture correcte */ printf("ECRITURE REALISEE CORRECTEMENT \n"); break; case 42 : printf("PLUS DE DEMANDE DIFFEREE EN COURS \n"); break; default : /* Echange incorrect */ printf("ECHANGE INCORRECT SUR LE CANAL %hd STATUS %hd \n", nchan, status); } } while(status != 42); } } } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


transdifpack

- Transfert différé au format packé => TRANSDIFPACK prototype en C :

void transdifpack(short *, short *, short *, void *, short *) prototype en MS pascal :

procédure transdifpack(var nchan, nb, typ, status: integer);extern; Syntaxe : C transdifpack(&nchan,&nb,&typ,tabl,&status) PASCAL transdifpack(nchan,nb,typ,tabl[1],status) BASIC TRANSDIFPACK(NCHAN,NB,TYPE,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb Entier 16 bits, Nombre de variables transférées. typ Entier 16 bits, Indique la nature des variables retournées. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant 32 bits. tabl Tableau recevant les données. status Entier 16 bits. Description : Cette fonction permet de consulter le résultat d'une demande différée. Suite à une demande différée de lecture (ou de réception de message) les variables seront

rangées au format packé dans le tableau d'éléments "tabl". Les données (bit, octet, mot, mot double) sont rangées en mémoire selon des adresses contiguëes sans interprétation de type.

Suite à une demande différée d'écriture (ou d'émission de message), aucune donnée n'est

transférée et l'argument "status" sera égal à -1 si l'échange s'est passé correctement. Si TRANSDIFPACK est utilisé alors que la demande différée n'est pas encore réalisée, le status -5

vous sera retourné. Si vous procédez à des TRANSDIFPACK alors qu'il n'y a plus de demandes différées en cours le

status 42 vous sera retourné. Remarque: Lors de l’utilisation de cette fonction dans le cadre de la récupération de données faisant suite à un

appel à la fonction AuWriteReadDifMsg, l’utilisateur doit indiquer dans le paramètre nb la taille maximale du tableau d’octet pouvant être retourné par la fonction.

Consultez le manuel lié à votre protocole de communication pour plus d’informations Si la taille du tableau d’octets récupéré lors de l’appel de la fonction est supérieure au nombre

indiqué dans le paramètre nb, le status 74 sera retourné.


WoodheadWoodhead


transdifpack exemple en langage C Microsoft Lecture différée de 10 mots à partir de l'adresse 20 dans l'équipement numéro 1, puis dans

l'équipement 2, raccordés sur le canal numéro 0 de l'interface applicom®. Puis transfert des résultats. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short neq; /* Numéro d'équipement */ short nb; /* Nombre de variables */ long adr; /* Adresse de la première variable */ short typ; /* Type de variables */ short tabl[10]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . nchan=0; neq=1; nb=10; adr=20; readdifword(&nchan, &neq, &nb, &adr, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { neq=2; readdifword(&nchan, &neq, &nb, &adr, &status); if (status != 0) printf(" !! Défaut : Demande différée non prise en compte \n"); else { . do { do { transdifpack(&nchan, &nb, &typ, tabl, &status); } while(status == -5); switch(status) { case 0 : /* Lecture correcte */ for(i=0; i<nb; i++) printf("%hd \n" ; tabl[i]); break; case -1 : /* Ecriture correcte */ printf("ECRITURE REALISEE CORRECTEMENT \n"); break; case 42 : printf("PLUS DE DEMANDE DIFFEREE EN COURS \n"); break; default : /* Echange incorrect */ printf("ECHANGE INCORRECT SUR LE CANAL %hd STATUS %hd \n", nchan, status); } } while(status != 42); } } } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


testtransdif

- Test de demandes différées => TESTTRANSDIF prototype en C :

void testtransdif(short *, short *, short *, short *) prototype en MS pascal :

procédure testtransdif(var nchan, nb1, nb2, status: integer);extern; Syntaxe : C testtransdif(&nchan,&nb1,&nb2,&status) PASCAL testtransdif(nchan,nb1,nb2,status) BASIC TESTTRANSDIF(NCHAN,NB1,NB2,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb1 Entier 16 bits, Nombre de demandes différées en cours. nb2 Entier 16 bits, Nombre de demandes différées réalisées. status Entier 16 bits. Description : Cette fonction permet de connaître le nombre de demandes différées en cours et le nombre de

demandes différées réalisées. Le nombre de demandes différées en cours d'exécution par interface applicom® est limité à 64.


WoodheadWoodhead


testtransdif exemple en langage C Microsoft Affichage de l'état des demandes différées du canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short nb1; /* Nombre de demandes */ short nb2; /* Nombre de demandes réalisées */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . nchan=0; testtransdif(&nchan, &nb1, &nb2, &status); if (status == 0) { printf("Fonction(s) différée(s) demandée(s) : %hd \n ", nb1); printf("Fonction(s) différée(s) réalisée(s) : %hd \n ", nb2); } else { . } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead

Librairie/DLL • 177 • - Fonctions du mode cyclique

createcyc

7. - Fonctions du mode cyclique

Dans ce chapitre : - Création d'une fonction cyclique => CREATECYC - Démarrage d'une fonction cyclique => STARTCYC - Arrêt d'une fonction cyclique => STOPCYC - Activation ponctuelle => ACTCYC - Transfert de demande cyclique - Demande d’informations sur des fonctions cycliques

- Création d'une fonction cyclique => CREATECYC prototype en C :

void createcyc(short *, short *, short *, short *,short *, short *, short *, short *, long *, short *, short *,short *) prototype en MS pascal :

procédure createcyc(var nchan, nfonc,per,act,typf,vardb,neq,nb :integer; var adreq :integer4; var adrdb, adrstat, status :integer); extern;

Syntaxe :

C createcyc(&nchan,&nfonc,&per,&act,&typf,&vardb,&neq,&nb,&adreq,&adrbd,&adrstat,&status) PASCAL createcyc(nchan,nfonc,per,act,typf,vardb,neq,nb,adreq,adrbd,adrstat,status) BASIC CREATECYC(NCHAN,NFONC,PER,ACT,TYPF,VARDB,NEQ,NB,ADREQ(1),ADRDB,ADRSTAT,STATUS)

Paramètre Type nchan Entier 16 bits, Numéro du canal (0-31). nfonc Entier 16 bits, Numéro de fonction cyclique (1-255) (1-100 pour boîtier GT4000). per Entier 16 bits, période d'activation désirée exprimée en multiple de 100

millisecondes (0-65535).

- Si per = 0 : Les fonctions sont enchaînées sans délai d'attente. act Entier 16 bits, indique l'état de la fonction à l'issue du CREATECYC act = 0, Fonction non active (nécessitera STARTCYC pour être activée). act = 1, Fonction active après l'exécution de CREATECYC. typf Entier 16 bits, Code de sélection du type d'échange.

Type de variable Type de fonction (typf) dans LECTURE ECRITURE

l'équipement Décimal Hexa Décimal Hexa Bits 4099 1003 4105 1009 Bits d'entrée 4100 1004 Bits de sortie 4186 105A 4187 105B Rapide de 8 bits 4109 100D


WoodheadWoodhead


Octets packés 4190 105E 4192 1060 Octets 4191 105F 4193 1061 Octets packés d'entrée 4200 1068 Octets d'entrée 4201 1069 Octets packés de sortie 4202 106A 4204 106C Octets de sortie 4203 106B 4205 106D

Mots 4101 1005 4106 100A Mots BCD 4194 1062 4195 1063 Mots d'entrée 4102 1006 Mots de sortie 4197 1065 4198 1066

Mots doubles 32 bits 4103 1007 4107 100B Mots flottants IEEE 4104 1008 4108 100C


WoodheadWoodhead


createcyc Paramètre Type vardb Entier 16 bits, Type de variables de DATA BASE lues ou forcées. 1 - Bit 2 - Octet 3 - Entier 16 bits 4 - Entier 32 bits 5 - Flottant IEEE 32 bits neq Entier 16 bits, Numéro d'équipement cible (0-255). nb Entier 16 bits, Nombre de variables accédées dans l'équipement. adreq Entier 32 bits, Adresse de la première variable dans l'équipement. adrdb Entier 16 bits, Adresse de la première variable dans DATA-BASE. Les zones d'adresses supérieur à 31999 ont des affectations particulières (voir

chapitre "Base de données DATA-BASE" du manuel "Fonctionnalité". adrstat Entier 16 bits, Adresse de rangement du mot status de la fonction cyclique dans

DATA-BASE. - Si adrstat = -1, le status n'est pas copié dans DATA BASE. status Entier 16 bits, Status de création de la fonction cyclique. Description : A l'initialisation du produit applicom® le fichier de commande APPLICOM.BAT ou "PCINIT"

active la commande LOADCYC qui transfert la configuration des fonctions cycliques des fichiers CONFCYC.AP1 à CONFCYC.AP8 dans les interfaces applicom® (1 à 8). Ces fonctions peuvent être modifiées ou créées de façon dynamique par le programme utilisateur.

Si le type d'échange "TYPF" n'est pas correct, le status sera égal à 1 et la fonction ne sera pas modifiée.

La destruction d'une fonction cyclique se fait en initialisant "TYPF" à 0. Remarques : Protocole Jbus / Modbus : Il est possible de créer une fonction de lecture des compteurs du maître si typf = 4123 (101B H).

Dans ce cas le paramètre ADREQ est ignoré et nb est limité à 10 (5 mots par esclaves donc 2 esclaves maximum).

Dans les cas de création de la fonction lecture rapide de 8 bits, le paramètre ADREQ est ignoré. Protocole Uni-Te : L'argument adresse "adreq", est codé sur 32 bits. Le codage des 16 bits de poids fort permet

l'accès à des segments et types d'objets particuliers (NUM) (voir chapitre "Fonction de lecture et écriture d'objets" du manuel fonctionnalité).

Protocole Profibus messagerie S5 : Pour le codage de l'argument adresse "adreq" et le nombre de variable accédées, consulter le

chapitre "Profibus" du "Manuel fonctionnalité".


WoodheadWoodhead


createcyc exemple en langage C Microsoft Création de la fonction cyclique n°52 sur le canal 2 pour la lecture de 10 mots à partir de l'adresse

24 dans l'équipement n° 12. La fréquence de l'échange est de une seconde et les variables seront rangées dans la base de données "mot" de l'interface applicom® à partir de l'adresse 100. La fonction doit être activée dès l'exécution du sous-programme et le status des échanges cycliques sera rangé à l'adresse 110.

#include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short nfonc; /* numéro de fonction cyclique */ short per; /* période de rafraîchissement */ short act; /* activation ou non de la fonct.cycl. */ short typf; /* . */ short vardb; /* type de variable dans data-base */ short neq; /* numéro d'esclave */ short nb; /* nombre de variables à échanger */ long adreq; /* adresse dans l'esclave */ short adrdb; /* adresse dans data-base */ short adrstat; /* adresse du status dans data-base */ short status; /* status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . . nchan = 2; /* Numéro de canal

*/ nfonc = 52; /* Numéro de fonction

*/ per = 10; /* Période 1 seconde

*/ act = 1; /* activation de la fonction

*/ typf = 0x1005; /* Fonction lecture de mot

*/ vardb = 3; /* Zone mots de DATA BASE

*/ neq = 12; /* Esclave numéro 12

*/ nb = 10; /* 10 variables

*/ adreq = 24; /* Lecture à l'adresse 24 de l'esclave

*/ adrdb = 100; /* Résultat adresse 100 de DATA-BASE

*/ adrstat = 110; /* Pas de copie de status dans DATA BASE

*/ createcyc(&nchan,&nfonc,&per,&act,&typf,&vardb,&neq,&nb,&adreq,&adrbd,&adrstat,&status); swicth(status) { case 0 : printf(" Création fonction : OK !!"); break; default : printf(" Création fonction NOK, Status = %hd", status);


WoodheadWoodhead


} . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


createcyc


WoodheadWoodhead


startcyc

- Démarrage d'une fonction cyclique => STARTCYC prototype en C :

void startcyc(short *, short *, short *) prototype en MS pascal :

procédure startcyc(vars nchan, fonc, status: integer); extern; Syntaxe : C startcyc(&nchan,&fonc,&status) PASCAL startcyc(nchan,fonc,status) BASIC STARTCYC (NCHAN,FONC,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). fonc Entier 16 bits, Numéro de fonction cyclique (1-255). status Entier 16 bits. Description : Cette fonction assure le démarrage d'une fonction cyclique


WoodheadWoodhead


startcyc exemple en langage C Microsoft Lancement de la fonction cyclique n° 1 du canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short fonc; /* Numéro de fonction */ short status; /* status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . . nchan=0; fonc=1; startcyc(&nchan,&fonc,&status); if(status == 0) printf(" Fonction %hd du canal %hd active \n ", fonc, nchan); else { . } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


stopcyc

- Arrêt d'une fonction cyclique => STOPCYC prototype en C :

void stopcyc(short *, short *, short *) prototype en MS pascal :

procédure stopcyc(vars nchan, fonc, status: integer); extern; Syntaxe : C stopcyc(&nchan,&fonc,&status) PASCAL stopcyc(nchan,fonc,status) BASIC STOPCYC (NCHAN,FONC,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). fonc Entier 16 bits, Numéro de fonction cyclique (1-255). status Entier 16 bits. Description : Cette fonction assure l'arrêt d'une fonction cyclique.


WoodheadWoodhead


stopcyc exemple en langage C Microsoft Arrêt de la fonction cyclique n° 1 du canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short fonc; /* Numéro de fonction */ short status; /* status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . . nchan=0; fonc=1; stopcyc(&nchan,&fonc,&status); if(status == 0) printf(" Fonction %hd du canal %hd arrêtée active \n ", fonc, nchan); else { . } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


actcyc

- Activation ponctuelle => ACTCYC prototype en C :

void actcyc(short *, short *, short *) prototype en MS pascal :

procédure actcyc(vars nchan, fonc, status: integer); extern; Syntaxe : C actcyc(&nchan,&fonc,&status) PASCAL actcyc(nchan,fonc,status) BASIC ACTCYC (NCHAN,FONC,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). fonc Entier 16 bits, Numéro de fonction cyclique (1-255). status Entier 16 bits. Description : Cette fonction assure le démarrage d'une fonction cyclique de manière ponctuelle, un seul échange

est réalisé par exécution de la fonction ACTCYC.


WoodheadWoodhead


actcyc exemple en langage C Microsoft Activation de la fonction cyclique n° 1 du canal 0 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short fonc; /* Numéro de fonction */ short status; /* status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { . . nchan=0; fonc=1; actcyc(&nchan,&fonc,&status); if(status == 0) printf(" Fonction %hd du canal %hd activé 1 fois \n ", fonc, nchan); else { . } } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


transcyc

- Transfert de demande cyclique

Dans ce chapitre : - Transfert cyclique au format dépacké => TRANSCYC - Transfert cyclique au format packé => TRANSCYCPACK

- Transfert cyclique au format dépacké => TRANSCYC prototype en C :

void transcyc(short *, short *, short *, short *, void *, short *) prototype en MS pascal :

procédure transcyc(var nchan, fonc, nb, typ: integer; var tabl: integer4; var status:integer);extern; Syntaxe : C transcyc(&nchan,&fonc,&nb,&typ,tabl,&status) PASCAL transcyc(nchan,fonc,nb,typ,tabl[1],status) BASIC TRANSCYC(NCHAN,FONC,NB,TYP,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). fonc Entier 16 bits, Numéro de la fonction cyclique (1-255). nb Entier 16 bits, Retourné par la fonction. Nombre de variables transférées. typ Entier 16 bits, Retourné par la fonction. Indique le type des variables retournées. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant 32 bits. tabl Tableau d'éléments 32 bits recevant les données. status Entier 16 bits. Status de l'échange. Description : Cette fonction permet de consulter le résultat d'une fonction cyclique. Lors de l'appel de TRANSCYC, les données sont récupérées dans la base de données de

l'interface applicom®. Ceci implique que si une fonction cyclique range des variables dans la base de données, un maître externe ou le programme PC peut aussi modifier ces variables, TRANSCYC retournera alors les dernières valeurs forcées.

Si TRANSCYC est utilisé pour une fonction qui n'a jamais été activée, le status 35 vous sera retourné et aucune donnée ne sera transférée.

SI TRANSCYC est utilisé pour une fonction qui a été déjà activée mais qui ne l'est plus, le status -6 vous sera retourné et les données seront transférées.

Suite au transfert du résultat d'une fonction cyclique de lecture les variables seront rangées au format dépacké dans le tableau "tabl" (une variable par élément 32 bits du tableau). L'interprétation des valeurs retournées dépend de TYP (bit, octet, mot, mot double ou mot flottant). C'est au programme application de prendre en compte le format des variables.


WoodheadWoodhead


transcyc exemple en langage C Microsoft Transfert du résultat d'une fonction cyclique. Le numéro du canal, ainsi que le numéro de la

fonction sont saisies au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nchan; /* Numéro de canal */ short fonc; /* Numéro de fonction */ short nb; /* Nombre de variables */ short typ; /* Type de variables */ long tablong[2048]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ printf("TRANSFERT de fonction cyclique \n "); printf("Numéro de canal : \n"); scanf(" %hd", &nchan); printf("Numéro de fonction : \n"); scanf(" %hd", &fonc); transcyc(&nchan, &fonc, &nb, &typ, tablong, &status); printf("status transcyc = %d\n",status); if ( status <= 0 ) { printf(" %d ",nb); switch (typ) { case 1 : printf("bit(s)\n"); for (i=0 ; i<nb ; i++) printf("%ld ",tablong[i]); break; case 2 : printf("octet(s)\n"); for (i=0 ; i<nb ; i++) printf("%ld ",tablong[i]); break; case 3 : printf("mot(s)\n"); for (i=0 ; i<nb ; i++) printf("%ld ",tablong[i]); break; case 4 : printf("mot(s) double(s)\n"); for (i=0 ;i<nb ; i++) printf ("%ld ",tablong[i]); break; case 5 : printf("mot(s) flottant(s)\n"); for ( i=0 ; i<nb ; i++ )printf("%f ",*(float *)&tablong[i]); break; default : break; } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


transcycpack

- Transfert cyclique au format packé => TRANSCYCPACK prototype en C :

void transcycpack(short *, short *, short *, short *, void *, short *) prototype en MS pascal :

procédure transcycpack(var nchan, fonc, nb, typ, status: integer);extern; Syntaxe : C transcycpack(&nchan,&fonc,&nb,&typ,tabl,&status) PASCAL transcycpack(nchan,fonc,nb,typ,tabl[1],status) BASIC TRANSCYCPACK(NCHAN,FONC,NB,TYP,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). fonc Entier 16 bits, Numéro de la fonction cyclique (1-255). nb Entier 16 bits, Retourné par la fonction. Nombre de variables transférées. typ Entier 16 bits, Retourné par la fonction. Indique le type des variables retournées. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant 32 bits. tabl Tableau recevant les données. status Entier 16 bits. Description : Cette fonction permet de consulter le résultat d'une fonction cyclique. Lors de l'appel de TRANSCYCPACK, les données sont récupérées dans la base de données de

l'interface applicom®. Ceci implique que si une fonction cyclique range des variables dans la base de données, un maître externe ou le programme PC peut aussi modifier ces variables, TRANSCYCPACK retournera alors les dernières valeurs forcées.

Si TRANSCYCPACK est utilisé pour une fonction qui n'a jamais été activée, le status 35 vous sera retourné et aucune donnée ne sera transférée.

SI TRANSCYCPACK est utilisé pour une fonction qui a été déjà activée mais qui ne l'est plus, le status -6 vous sera retourné et les données seront transférées.

Suite au transfert du résultat d'une fonction cyclique de lecture les variables seront rangées au format packé dans le tableau d'éléments "tabl". Les données (bit, octet, mot, mot double) sont rangées en mémoire selon des adresses contiguëes sans interprétation de type.


WoodheadWoodhead


transcycpack exemple en langage C Microsoft Transfert du résultat d'une fonction cyclique au format packé. Le numéro du canal, ainsi que le

numéro de la fonction sont saisies au clavier. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short fonc; /* Numéro de fonction */ short nb; /* Nombre de variables */ short typ; /* Type de variables */ short tabl[128]; /* Table contenant les données */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ printf("TRANSFERT de fonction cyclique \n "); printf("Numéro de canal : \n"); scanf(" %hd", &nchan); printf("Numéro de fonction : \n"); scanf(" %hd", &fonc); transcycpack(&nchan, &fonc, &nb, &typ, tabl, &status); printf("status transcyc = %hd\n",status); if ( status == 0 ) { . /* Interprétation des données */ . } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


CycExecuted

- Demande d’informations sur des fonctions cycliques

Dans ce chapitre : - Liste des fonctions cycliques exécutées => CYCEXECUTED - Paramètres d’une fonction cyclique => APPGETCYCPARAM

- Liste des fonctions cycliques exécutées => CYCEXECUTED prototype en C :

void CycExecuted(short *, short *, short *, short *) prototype en MS pascal :

procédure CycExecuted(var nchan, nb, tabl, status:integer);extern; Syntaxe : C CycExecuted(&nchan,&nb,tabl,&status) PASCAL CycExecuted(nchan,nb,tabl[1],status) BASIC CYCEXECUTED(NCHAN,NB,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nb Entier 16 bits, Retourné par la fonction. (vaut 1280 au retour) tabl Tableau d'éléments 16 bits recevant les flags. Ce tableau doit être dimensionné à

80 short au minimum status Entier 16 bits. Status de l'échange. Description : Fonction disponible uniquement sous MS_Windows NT. Cette fonction permet d’obtenir dans les 16 premiers « short » du tableau « tabl »des flags (16 * 16

=256 flags). Chacun de ces flags correspond à une fonction cyclique (de la numéro 0 à la numéro 255). Si le flag correspondant à une fonction cyclique est à 1, c’est que les données ont été rafraîchies par la fonction cyclique depuis le dernier appel à la fonction « transcyc » sur cette fonction.

Au retour : le premier élément (short) du tableau contient les flags pour les fonctions cycliques 0 à 15 (le bit

de poids faible du short correspond à la fonction 0, celui de poids fort à la fonction 15. l’élément suivant contient les flags pour les fonction cycliques 16 à 31. etc...


WoodheadWoodhead


CycExecuted exemple en langage C Microsoft Cet exemple teste si de nouvelles valeurs ont été déposées par la fonction cyclique n° 110 et

récupère les valeurs si c’est le cas : . . . short nchan =0; /* Numéro de canal */ short nb; /* Nombre de variables */ short tabl[81]; /* Table recevant les flags avant éclatement */ short tablbit[256]; /* Table recevant les flags après éclatement */ short status; /* Status */ short nfonc; /* Numéro de fonction cyclique à tester */ main() { . . . /* appel de "CycExecuted" */

CycExecuted(&nchan, &nb, tabl, &status); if ( status == 0 )

{ nb=256 ; transwordbit(&nb, tabl, tablbit, &status) ; if( status == 0 ) { nfonc=110 ; if ( tablbit[nfonc]==1 ) { /*la fonction cyclique a rafraîchi ses données */ transcyc(....) ; ) } } . . . }


WoodheadWoodhead


AppGetCycParam

- Paramètres d’une fonction cyclique => APPGETCYCPARAM prototype en C :

void AppGetCycParam(short *, short *, long *, short *) prototype en MS pascal :

procédure AppGetCycParam(var nchan, fonc :integer, tabl :integer4, status:integer);extern; Syntaxe : C AppGetCycParam(&nchan,&nfonc,tabl,&status) PASCAL AppGetCycParam(nchan,nfonc,tabl[1],status) BASIC APPGETCYCPARAM(NCHAN,NFONC,TABL(1),STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). nfonc Entier 16 bits, Numéro de la fonction cyclique (0 à 255). tabl Tableau d'éléments 32 bits recevant les paramètres. Ce tableau doit être

dimensionné à 64 long. status Entier 16 bits. Status de l'échange. Description : Fonction disponible uniquement sous MS_Windows NT. Cette fonction permet d’obtenir dans un tableau tous les paramètres en cours d’une fonction cyclique. Au retour : tabl[0] période d'activation de la fonction cyclique exprimée en multiple de 100 ms (0-

65535). tabl[1] Code de sélection du type d'échange. Selon le principe suivant :

Type de variable Type de fonction dans LECTURE ECRITURE

l'équipement Décimal Hexa Décimal Hexa Bits 4099 1003 4105 1009 Bits d'entrée 4100 1004 Bits de sortie 4186 105A 4187 105B Rapide de 8 bits 4109 100D Octets packés 4190 105E 4192 1060 Octets 4191 105F 4193 1061 Octets packés d'entrée 4200 1068 Octets d'entrée 4201 1069 Octets packés de sortie 4202 106A 4204 106C Octets de sortie 4203 106B 4205 106D Mots 4101 1005 4106 100A Mots BCD 4194 1062 4195 1063


WoodheadWoodhead


Mots d'entrée 4102 1006 Mots de sortie 4197 1065 4198 1066 Mots doubles 32 bits 4103 1007 4107 100B Mots flottants IEEE 4104 1008 4108 100C


WoodheadWoodhead


AppGetCycParam

tabl[2] Type de variables dans la DATA BASE lues ou forcées. 1 - Bit 2 - Octet 3 - Entier 16 bits 4 - Entier 32 bits 5 - Flottant IEEE 32 bits tabl[3] Numéro d'équipement cible (0-255). tabl[4] Nombre de variables accédées dans l'équipement. tabl[5] Adresse de la première variable dans l'équipement. tabl[6] Adresse de la première variable dans DATA-BASE. tabl[7] Adresse de rangement du mot status de la fonction cyclique dans DATA-BASE. Si adrstat = -1, le status n'est pas copié dans DATA BASE.

tabl[8] Status de la fonction cyclique. tabl[9] Non utilisé. tabl[10] état de la fonction : 0 = inactive ; 1 = active.


WoodheadWoodhead

Librairie/DLL • 198 • - Fonctions Data-Base

getpackbit

8. - Fonctions Data-Base

Dans ce chapitre :

- Lecture - Ecriture - Incrémentation - Décrémentation - FIFO d'événements

- Lecture

Dans ce chapitre : - Lecture de bits packés contigus => GETPACKBIT - Lecture de bits non packés contigus => GETBIT - Lecture de mots contigus => GETWORD - Lecture de mots doubles contigus => GETDWORD - Lecture de mots flottants contigus => GETFWORD - Lecture de bits non contigus => GETDISPBIT - Lecture de mots non contigus => GETDISPWORD - Lecture de mots doubles non contigus => GETDISPDWORD - Lecture de mots flottants non contigus => GETDISPFWORD

- Lecture de bits packés contigus => GETPACKBIT prototype en C :

void getpackbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure getpackbit(var ncard, nb, adr, tabl, status : integer);extern; Syntaxe : C getpackbit(&ncard,&nb,&adr,tabl,&status) PASCAL getpackbit(ncard,nb,adr,tabl[1],status) BASIC GETPACKBIT(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de bits à lire (1-MAX). adr Entier 16 bits, Adresse du premier bit à lire (0-32767). tabl Tableau d'entiers 16 bits recevant les données. status Entier 16 bits.


WoodheadWoodhead


Description : Cette fonction standard applicom® permet la lecture de bits dans la base de données de l'interface

applicom® en format packé. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum une chaîne de 16 bits. Les bits non lus dans le dernier mot recevant les données sont dans un état indéterminé.



WoodheadWoodhead


getpackbit exemple en langage C Microsoft Lecture des bits de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de bits */ short status; /* Status */ short adr = 0; /* Adresse du premier bit */ short tabl[1]; /* Table recevant les données */ short tablbit[8]; /* Table contenant les valeurs éclatées */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getpackbit(&ncard, &nb, &adr, tabl, &status); if (!status) { transwordbit(&nb, tabl, tablbit, &status); for (i=0; i < nb ; i++) printf(" %hd",tablbit[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getbit

- Lecture de bits non packés contigus => GETBIT prototype en C :

void getbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure getbit(var ncard, nb, adr, tabl, status: integer); extern; Syntaxe : C getbit(&ncard,&nb,&adr,tabl,&status) PASCAL getbit(ncard,nb,adr,tabl[1],status) BASIC GETBIT(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8) nb Entier 16 bits, Nombre de bits à lire (1-MAX). adr Entier 16 bits, Adresse du premier bit à lire (0 à 32767). tabl Tableau d'entiers 16 bits recevant les données. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de bits dans la base de données de l'interface

applicom® en format dépacké. Les bits sont rangés au format dépacké dans le tableau "tabl" (un bit par entier 16 bits du tableau).


WoodheadWoodhead


getbit exemple en langage C Microsoft Lecture des bits de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de bits */ short status; /* Status */ short adr = 0; /* Adresse du premier bit */ short tabl[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getbit(&ncard, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb ; i++) printf(" %hd",tabl[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getpackbyte

- Lecture d'octets contigus => GETPACKBYTE prototype en C :

void getpackbyte(short *, short *, short *, char *, short *) prototype en MS pascal :

procédure getpackbyte(var ncard, nb, adr: integer; var tabl :byte; var status :integer); extern; Syntaxe : C getpackbyte(&ncard,&nb,&adr,tabl,&status) PASCAL getpackbyte(ncard,nb,adr,tabl[1],status) BASIC GETPACKBYTE(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre d'octets à lire (1-MAX). adr Entier 16 bits, Adresse du premier octet à lire (0-13 999). tabl Tableau d'octets recevant les données. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture d'octets dans la base de données de

l'interface applicom®. Les différentes valeurs sont retournées par la fonction dans le tableau d'octets 'tabl'.

Remarques : La zone octets est commune à la zone mots avec un offset de 25 000 sur l'adressage mots (voir

chapitre base de données DATA-BASE du manuel "Fonctionnalité »).

Adresse Mot Adresse Octet Octet poids fort Octet poids faible

24 999 25 000 1 0 25 001 3 2

. . .

. . . 31 998 13 997 13 996 31 999 13 999 13 998


WoodheadWoodhead


getpackbyte exemple en langage C Microsoft Lecture des octets de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre d'octets */ short status; /* Status */ short adr = 0; /* Adresse du premier octet */ char tablbyte[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getpackbyte(&ncard, &nb, &adr, tablbyte, &status); if (!status) { for (i=0; i < nb ; i++) printf(" %X",tablbyte[i]); } else printf(" problème !! status = %hd \n", status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getword

- Lecture de mots contigus => GETWORD prototype en C:

void getword(short *, short *, short *, short *, short *) prototype en pascal:

procédure getword(var ncard, nb, adr, tabl, status:integer); extern; Syntaxe : C getword(&ncard,&nb,&adr,tabl,&status) PASCAL getword(ncard,nb,adr,tabl[1],status) BASIC GETWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à lire (1-MAX). adr Entier 16 bits, Adresse du premier mot à lire (0-32767). tabl Tableau d'entiers 16 bits recevant les données. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots dans la base de données de

l'interface applicom®. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'.


WoodheadWoodhead


getword exemple en langage C Microsoft Lecture des mots de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de mots */ short status; /* Status */ short adr = 0; /* Adresse du premier mot */ short tabl[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getword(&ncard, &nb, &adr, tabl, &status); if (!status) { for (i=0; i < nb ; i++) printf(" %hd",tabl[i]); } else printf(" problème !! status = %hd \n", status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getdword

- Lecture de mots doubles contigus => GETDWORD prototype en C :

void getdword(short *, short *, short *, long *,short *) prototype en pascal :

procédure getdword(var ncard, nb, adr:integer; var tabl :integer4; var status:integer); extern; Syntaxe : C getdword(&ncard,&nb,&adr,tabl,&status) PASCAL getdword(ncard,nb,adr,tabl[1],status) BASIC GETDWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots doubles à lire (1-MAX). adr Entier 16 bits, Adresse du premier mot double à lire (0-32766). tabl Tableau d'entiers 32 bits recevant les données. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots doubles dans la base de données de

l'interface applicom®. Les différentes valeurs sont rangées dans le tableau d'entiers 32 bits 'tabl'. Remarques : La zone mots doubles est commune à la zone mots.


WoodheadWoodhead


getdword exemple en langage C Microsoft Lecture des 8 mots doubles à partir de l'adresse 0 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de mots doubles */ short status; /* Status */ short adr = 0; /* Adresse du premier mot double */ long tablong[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getdword(&ncard, &nb, &adr, tablong, &status); if (!status) { for (i=0; i < nb ; i++) printf(" %ld",tablong[i]); } else printf(" problème !! status = %hd \n", status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getfword

- Lecture de mots flottants contigus => GETFWORD prototype en C :

void getfword(short *, short *, short *, float *, short *) prototype en MS pascal :

procédure getfword(var ncard, nb, adr: integer; var tabl: real; var status: integer); extern; Syntaxe : C getfword(&ncard,&nb,&adr,tabl,&status) PASCAL getfword(ncard,nb,adr,tabl1],status) BASIC GETFWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots flottants à lire (1-MAX). adr Entier 16 bits, Adresse du premier mot flottant à lire (0-32766). tabl Tableau de réels 32 bits recevant les données. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots flottants au format IEEE dans la base

de données de l'interface applicom®. Les différentes valeurs sont rangées dans le tableau de réels 32 bits 'tabl'.

Remarques : La zone mots flottants est commune à la zone mots.


WoodheadWoodhead


getfword exemple en langage C Microsoft Lecture des 8 mots flottants à partir de l'adresse 0 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de mots flottants */ short status; /* Status */ short adr = 0; /* Adresse du premier mot flottant */ float tablfloat[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { getfword(&ncard, &nb, &adr, tablfloat, &status); if (!status) { for (i=0; i < nb ; i++) printf(" %f",tablfloat[i]); } else printf(" problème !! status = %hd \n", status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getdispbit

- Lecture de bits non contigus => GETDISPBIT prototype en C :

void getdispbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure getdispbit(var ncard, nb, tabladr, tablval, status :integer); extern; Syntaxe : C getdispbit(&ncard,&nb,tabladr,tablval,&status) PASCAL getdispbit(ncard,nb,tabladr[1],tablval1],status) BASIC GETDISPBIT(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de bits à lire (1 à MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des bits à lire (0 à 32767). tablval Tableau d'entiers 16 bits recevant l'état (0 ou 1) des bits dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de bits non contigus dans la base de données

de l'interface applicom®. Les bits sont rangés au format dépacké dans le tableau "tablval" (un bit par entier 16 bits du tableau).


WoodheadWoodhead


getdispbit exemple en langage C Microsoft Lecture des 4 bits d'adresse 0, 5, 10, et 15 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de bits */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 5; tabladr[2] = 10; tabladr[3] = 15; do { getdispbit(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Etat du bit d'adresse %hd = %hd", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getdispword

- Lecture de mots non contigus => GETDISPWORD prototype en C :

void getdispword(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure getdispword(var ncard, nb, tabladr, tablval, status: integer); extern; Syntaxe : C getdispword(&ncard,&nb,tabladr,tablval,&status) PASCAL getdispword(ncard,nb,tabladr[1],tablval[1],status) BASIC GETDISPWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à lire (1 à MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots à lire (0 à 32767). tablval Tableau d'entiers 16 bits recevant la valeur des mots dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots non contigus dans la base de

données de l'interface applicom®. Les mots sont rangés dans le tableau "tablval".


WoodheadWoodhead


getdispword exemple en langage C Microsoft Lecture des 4 mots d'adresse 0, 5, 10, et 15 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 5; tabladr[2] = 10; tabladr[3] = 15; do { getdispword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Etat du mot d'adresse %hd = %hd", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getdispdword

- Lecture de mots doubles non contigus => GETDISPDWORD prototype en C :

void getdispdword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure getdispdword(var ncard, nb, tabladr :integer; var tablval :integer4; var status :integer); extern; Syntaxe : C getdispdword(&ncard,&nb,tabladr,tablval,&status) PASCAL getdispdword(ncard,nb,tabladr[1],tablval[1],status) BASIC GETDISPDWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots doubles à lire (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots doubles à lire (0 à 32766). tablval Tableau d'entiers 32 bits recevant la valeur des mots doubles dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots doubles non contigus dans la base

de données de l'interface applicom®. Les mots doubles sont rangés dans le tableau d'entiers 32 bits "tablval".


WoodheadWoodhead


getdispdword exemple en langage C Microsoft Lecture des 4 mots doubles d'adresse 0, 10, 20 et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ long tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; do { getdispdword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Etat du mot double d'adresse %hd = %ld", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getdispfword

- Lecture de mots flottants non contigus => GETDISPFWORD prototype en C :

void getdispfword=>(short *, short *, short *, float *,short *) prototype en MS pascal :

procédure getdispfword(var ncard, nb, tabladr :integer; var tablval :real; var status:integer); extern; Syntaxe : C getdispfword(&ncard,&nb,tabladr,tablval,&status) PASCAL getdispfword(ncard,nb,tabladr[1],tablval[1],status) BASIC GETDISPFWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots flottants à lire (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots flottants à lire (0 à 32766). tablval Tableau de réel 32 bits recevant la valeur des mots flottants dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet la lecture de mots flottants non contigus dans la base

de données de l'interface applicom®. Les mots flottants sont rangés dans le tableau de réels 32 bits "tablval".


WoodheadWoodhead


getdispfword exemple en langage C Microsoft Lecture des 4 mots flottants d'adresse 0, 10, 20 et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ float tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; do { getdispfword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Etat du mot flottant d'adresse %hd = %f", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setpackbit

- Ecriture

Dans ce chapitre : - Ecriture de bits packés contigus => SETPACKBIT - Ecriture de bits non packés contigus => SETBIT - Ecriture d'octets contigus => SETPACKBYTE - Ecriture de mots contigus => SETWORD - Ecriture de mots doubles contigus => SETDWORD - Ecriture de mots flottants contigus => SETFWORD - Ecriture de bits non contigus => SETDISPBIT - Ecriture de mots non contigus => SETDISPWORD - Ecriture de mots doubles non contigus => SETDISPDWORD - Ecriture de mots flottants non contigus => SETDISPFWORD

- Ecriture de bits packés contigus => SETPACKBIT prototype en C :

void setpackbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure setpackbit(var ncard, nb, adr, tabl, status: integer); extern; Syntaxe : C setpackbit(&ncard,&nb,&adr,tabl,&status) PASCAL setpackbit(ncard,nb,adr,tabl[1],status) BASIC SETPACKBIT(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de bits à écrire (1-MAX). adr Entier 16 bits, Adresse du premier bit à écrire (0-32767). tabl Tableau d'entiers 16 bits recevant les bits à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de bits dans la base de données de l'interface

applicom® en format packé. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum une chaîne de 16 bits.

La fonction applicom® "transbitword" vous permet de regrouper les chaînes de bits. Remarques : La zone bits supérieur à 31999 a des affectations particulières, voir le chapitre "Base de données

DATA-BASE" du manuel "Fonctionnalité".


WoodheadWoodhead


setpackbit exemple en langage C Microsoft Mise à 1 des bits de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de bits */ short status; /* Status */ short adr = 0; /* Adresse du premier bit */ short tabl[1]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabl[0] = 0x00FF; do { setpackbit(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setbit

- Ecriture de bits non packés contigus => SETBIT prototype en C :

void setbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure setbit(var ncard, nb, adr, tabl, status: integer); extern; Syntaxe : C setbit(&ncard,&nb,&adr,tabl,&status) PASCAL setbit(ncard,nb,adr,tabl[1],status) BASIC SETBIT(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de bits à écrire (1-MAX). adr Entier 16 bits, Adresse du premier bit à écrire (0-32767). tabl Tableau d'entiers 16 bits recevant les bits à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de bits dans la base de données de l'interface

applicom® en format dépacké. Les différentes valeurs sont rangées dans le tableau d'entiers 'tabl'. Un élément de ce tableau contient donc au maximum un bit.

Remarques : La zone bits supérieur à 31999 a des affectations particulières, voir le chapitre "Base de données



WoodheadWoodhead


setbit exemple en langage C Microsoft Mise à 1 des bits de 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de bits */ short status; /* Status */ short adr = 0; /* Adresse du premier bit */ short tabl[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { for (i=0; i<nb; i++) tabl[i] = 1; do { setbit(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setpackbyte

- Ecriture d'octets contigus => SETPACKBYTE prototype en C :

void setpackbyte(short *, short *, short *, char *, short *) prototype en MS pascal :

procédure setpackbyte(var ncard, nb, adr: integer; var tabl :byte; var status :integer); extern; Syntaxe : C setpackbyte(&ncard,&nb,&adr,tabl,&status) PASCAL setpackbyte(ncard,nb,adr,tabl[1],status) BASIC SETPACKBYTE(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre d'octets à écrire (1-MAX). adr Entier 16 bits, Adresse du premier octet à écrire (0-13 999). tabl Tableau d'octets recevant les données à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture d'octets dans la base de données de

l'interface applicom®. Les différentes valeurs sont rangées dans le tableau d'octets 'tabl'. Remarques : La zone octets est commune à la zone mots avec un offset de 25 000 sur l'adressage mots (voir

chapitre base de données DATA-BASE du manuel "Fonctionnalité").

Adresse Mot Adresse Octet Octet poids fort Octet poids faible

24 999 25 000 1 0 25 001 3 2

. . .

. . . 31 998 13 997 13 996 31 999 13 999 13 998


WoodheadWoodhead


setpackbyte exemple en langage C Microsoft Mise à 1 des octets 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre d'octets */ short status; /* Status */ short adr = 0; /* Adresse du premier octet */ char tabl[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { for (i=0; i<nb; i++) tabl[i] = 1; do { setpackbyte(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setword

- Ecriture de mots contigus => SETWORD prototype en C :

void setword(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure setword(var ncard, nb, adr, tabl, status: integer); extern; Syntaxe : C setword(&ncard,&nb,&adr,tabl,&status) PASCAL setword(ncard,nb,adr,tabl[1],status) BASIC SETWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à écrire (1-MAX). adr Entier 16 bits, Adresse du premier mot à écrire (0-32767). tabl Tableau d'entiers 16 bits recevant les données à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots dans la base de données de

l'interface applicom®. Les différentes valeurs sont rangées dans le tableau d'entiers 16 bits 'tabl'. Remarques : La zone mots supérieur à 31999 a des affectations particulières, voir le chapitre "Base de données



WoodheadWoodhead


setword exemple en langage C Microsoft Mise à 1 des mots 0 à 7 dans la base de données de la carte applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 8; /* Nombre de mots */ short status; /* Status */ short adr = 0; /* Adresse du premier mot */ short tabl[8]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { for (i=0; i<nb; i++) tabl[i] = 1; do { setword(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setdword

- Ecriture de mots doubles contigus => SETDWORD prototype en C :

void setdword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure setdword(var ncard, nb, adr; var tabl: integer4; var status: integer); extern; Syntaxe : C setdword(&ncard,&nb,&adr,tabl,&status) PASCAL setdword(ncard,nb,adr,tabl[1],status) BASIC SETDWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots doubles à écrire (1-MAX). adr Entier 16 bits, Adresse du premier mot double à écrire (0-32766). tabl Tableau d'entiers 32 bits recevant les données à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots doubles dans la base de données de

l'interface applicom®. Les différentes valeurs sont rangées dans le tableau d'entiers 32 bits 'tabl'. Remarques : La zone mots doubles supérieur à 31999 a des affectations particulières, voir le chapitre "Base de

données DATA-BASE" du manuel "Fonctionnalité". La zone mots doubles est commune à la zone mots.


WoodheadWoodhead


setdword exemple en langage C Microsoft Mise à 1 de 3 mots doubles à partir de l'adresse 0 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 3; /* Nombre de mots doubles */ short status; /* Status */ short adr = 0; /* Adresse du premier mot double */ long tabl[3]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { for (i=0; i<nb; i++) tabl[i] = 1; do { setdword(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setfword

- Ecriture de mots flottants contigus => SETFWORD prototype en C:

void setfword(short *, short *, short *, float *, short *) prototype en MS pascal :

procédure setfword(var ncard, nb, adr; var tabl : real4; var status: integer); extern; Syntaxe : C setfword(&ncard,&nb,&adr,tabl,&status) PASCAL setfword(ncard,nb,adr,tabl[1],status) BASIC SETFWORD(NCARD,NB,ADR,TABL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots flottants à écrire (1-MAX). adr Entier 16 bits, Adresse du premier mot flottant à écrire (0-32766). tabl Tableau de réel 32 bits recevant les données à écrire. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots flottants au format IEEE dans la base

de données de l'interface applicom®. Les différentes valeurs sont rangées dans le tableau de réel 32 bits 'tabl'.

Remarques : La zone mots flottants supérieur à 31999 a des affectations particulières, voir le chapitre "Base de

données DATA-BASE" du manuel "Fonctionnalité". La zone mots flottants est commune à la zone mots.


WoodheadWoodhead


setfword exemple en langage C Microsoft Mise à 1 de 3 mots flottants à partir de l'adresse 0 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 3; /* Nombre de mots flottants */ short status; /* Status */ short adr = 0; /* Adresse du premier mot flottant */ float tabl[3]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { for (i=0; i<nb; i++) tabl[i] = 1; do { setfword(&ncard, &nb, &adr, tabl, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setdispbit

- Ecriture de bits non contigus => SETDISPBIT prototype en C :

void setdispbit(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure setdispbit(var ncard, nb, tabladr, tablval, status: integer); extern; Syntaxe : C setdispbit(&ncard,&nb,tabladr,tablval,&status) PASCAL setdispbit(ncard,nb,tabladr[1],tablval[1],status) BASIC SETDISPBIT(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de bits à écrire (1 à MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des bits à écrire (0 à 32767). tablval Tableau d'entiers 16 bits recevant l'état (0 ou 1) des bits dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de bits non contigus dans la base de données

de l'interface applicom®. Les bits sont rangés au format dépacké dans le tableau "tablval" (un bit par entier 16 bits du tableau).


WoodheadWoodhead


setdispbit exemple en langage C Microsoft Mise à 1 des 4 bits d'adresse 0, 5, 10, et 15 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de bits */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 5; tabladr[2] = 10; tabladr[3] = 15; for (i=0; i<nb; i++) tablval[i] = 1; do { setdispbit(&ncard, &nb, tabladr, tablval, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setdispword

- Ecriture de mots non contigus => SETDISPWORD prototype en C :

void setdispword(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure setdispword(var ncard, nb, tabladr, tablval, status: integer); extern; Syntaxe : C setdispword(&ncard,&nb,tabladr,tablval,&status) PASCAL setdispword(ncard,nb,tabladr[1],tablval[1],status) BASIC SETDISPWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à écrire (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots à écrire (0 à 32767). tablval Tableau d'entiers 16 bits recevant la valeur des mots dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots non contigus dans la base de

données de l'interface applicom®. Les mots sont rangés dans le tableau "tablval".


WoodheadWoodhead


setdispword exemple en langage C Microsoft Mise à 1 des 4 mots d'adresse 0, 5, 10, et 15 dans la base de données de la carte applicom®

numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 5; tabladr[2] = 10; tabladr[3] = 15; for (i=0; i<nb; i++) tablval[i] = 1; do { setdispword(&ncard, &nb, tabladr, tablval, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setdispdword

- Ecriture de mots doubles non contigus => SETDISPDWORD prototype en C :

void setdispdword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure setdispdword(var ncard, nb, tabladr :integer; var tablval :integer4; var status :integer); extern; Syntaxe : C setdispdword(&ncard,&nb,tabladr,tablval,&status) PASCAL setdispdword(ncard,nb,tabladr[1],tablval[1],status) BASIC SETDISPDWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots double à écrire (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots doubles à écrire (0 à

32766). tablval Tableau d'entiers 32 bits recevant la valeur des mots doubles dont les adresses

correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots doubles non contigus dans la base de

données de l'interface applicom®. Les mots doubles sont rangés dans le tableau "tablval". La zone mots doubles est commune à la zone mots.


WoodheadWoodhead


setdispdword exemple en langage C Microsoft Mise à 1 des 4 mots doubles d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ long tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; for (i=0; i<nb; i++) tablval[i] = 1; do { setdispdword(&ncard, &nb, tabladr, tablval, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setdispfword

- Ecriture de mots flottants non contigus => SETDISPFWORD prototype en C :

void setdispfword( short *, short *, short *, float *, short * ) prototype en MS pascal :

procédure setdispfword( var ncard, nb, tabladr :integer; var tablval :real4; var status :integer ); extern; Syntaxe : C setdispfword( &ncard, &nb, tabladr, tablval, &status ) PASCAL setdispfword( ncard, nb, tabladr[1], tablval[1], status ) BASIC SETDISPFWORD( NCARD, NB, TABLADR(1), TABLVAL(1), STATUS ) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots flottants à écrire (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots flottants à écrire (0 à

32766). tablval Tableau de réels 32 bits recevant la valeur des mots flottants dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction standard applicom® permet l'écriture de mots flottants au format IEEE non contigus

dans la base de données de l'interface applicom®. Les mots flottants sont rangés dans le tableau "tablval".

La zone mots flottants est commune à la zone mots.


WoodheadWoodhead


setdispfword exemple en langage C Microsoft Mise à 1 des 4 mots flottants d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots flottants */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ float tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; for (i=0; i<nb; i++) tablval[i] = 1.0; do { setdispfword(&ncard, &nb, tabladr, tablval, &status); if (!status) printf(" Ecriture OK \n "); else printf(" problème !! status = %hd \n",status); } while(status == 0); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


incdispword

- Incrémentation

Dans ce chapitre : - Incrément mots non contigus => INCDISPWORD - Incrément mots doubles non contigus => INCDISPDWORD

- Incrément mots non contigus => INCDISPWORD prototype en C :

void incdispword( short *, short *, short *, short * , short * ) prototype en MS pascal :

procédure incdispword( var ncard, nb, tabladr, tablval, status: integer ); extern; Syntaxe : C incdispword( &ncard, &nb, tabladr, tablval, &status ) PASCAL incdispword( ncard, nb, tabladr[1], tablval[1], status ) BASIC INCDISPWORD( NCARD, NB, TABLADR(1), TABLVAL(1), STATUS ) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à incrémenter (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots à incrémenter (0 à

32767). tablval Tableau d'entiers 16 bits retourné par la fonction. Contient la valeur des mots incrémentés dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction applicom® permet d'incrémenter des mots non contigus dans la base de données

de l'interface applicom®.


WoodheadWoodhead


incdispword exemple en langage C Microsoft Incrémentation des 4 mots d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; incdispword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Valeur du mot d'adresse %hd après incrément = %hd \n", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


incdispdword

- Incrément mots doubles non contigus => INCDISPDWORD prototype en C :

void incdispdword( short *, short *, short *, long *, short * ) prototype en MS pascal :

procédure incdispdword( var ncard, nb, tabladr: integer; var tablval: integer4; var status: integer ); extern; Syntaxe : C incdispdword( &ncard, &nb, tabladr, tablval, &status ) PASCAL incdispdword( ncard, nb, tabladr[1], tablval[1], status ) BASIC INCDISPDWORD( NCARD, NB, TABLADR(1), TABLVAL(1), STATUS ) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots doubles à incrémenter (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots doubles à incrémenter (0

à 32766). tablval Tableau d'entiers 32 bits retourné par la fonction. Contient la valeur des mots doubles incrémentés dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction applicom® permet d'incrémenter des mots doubles non contigus dans la base de

données de l'interface applicom®.


WoodheadWoodhead


incdispdword exemple en langage C Microsoft Incrémentation des 4 mots doubles d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots doubles */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ long tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; incdispdword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Valeur du mot double d'adresse %hd après incrément = %ld \n", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


decdispword

- Décrémentation

Dans ce chapitre : - Décrément mots non contigus => DECDISPWORD - Décrément mots doubles non contigus => DECDISPDWORD

- Décrément mots non contigus => DECDISPWORD prototype en C :

void decdispword(short *, short *, short *, short *, short *) prototype en MS pascal :

procédure decdispword(var ncard, nb, tabladr, tablval, status :integer); extern; Syntaxe : C decdispword(&ncard,&nb,tabladr,tablval,&status) PASCAL decdispword(ncard,nb,tabladr[1],tablval[1],status) BASIC DECDISPWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots à décrémenter (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots à décrémenter (0 à

32767). tablval Tableau d'entiers 16 bits retourné par la fonction. Contient la valeur des mots décrémentés dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction applicom® permet de décrémenter des mots non contigus dans la base de données

de l'interface applicom®.


WoodheadWoodhead


decdispword exemple en langage C Microsoft Décrémentation des 4 mots d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ short tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; decdispword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Valeur du mot d'adresse %hd après décrément = %hd \n", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


decdispdword

- Décrément mots doubles non contigus => DECDISPDWORD prototype en C :

void decdispdword(short *, short *, short *, long *, short *) prototype en MS pascal :

procédure decdispdword(var ncard, nb, tabladr: integer; var tablval: integer4; var status: integer); extern; Syntaxe : C decdispdword(&ncard,&nb,tabladr,tablval,&status) PASCAL decdispdword(ncard,nb,tabladr,tablval,status) BASIC DECDISPDWORD(NCARD,NB,TABLADR(1),TABLVAL(1),STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre de mots doubles à décrémenter (1-MAX). tabladr Tableau d'entiers 16 bits contenant l'adresse des mots doubles à décrémenter (0

à 32766). tablval Tableau d'entiers 32 bits retourné par la fonction. Contient la valeur des mots doubles décrémentés dont les adresses correspondent à tabladr. status Entier 16 bits. Description : Cette fonction applicom® permet de décrémenter des mots doubles non contigus dans la base de

données de l'interface applicom®.


WoodheadWoodhead


decdispdword exemple en langage C Microsoft Décrémentation des 4 mots doubles d'adresse 0, 10, 20, et 30 dans la base de données de la carte

applicom® numéro 1. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short ncard = 1; /* Numéro de carte */ short nb = 4; /* Nombre de mots doubles */ short status; /* Status */ short tabladr[4]; /* Table recevant les adresses */ long tablval[4]; /* Table recevant les données */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { tabladr[0] = 0; tabladr[1] = 10; tabladr[2] = 20; tabladr[3] = 30; decdispdword(&ncard, &nb, tabladr, tablval, &status); if (!status) { for (i=0; i < nb ; i++) printf(" Valeur du mot double d'adresse %hd après décrément = %ld", tabladr[i], tablval[i]); } else printf(" problème !! status = %hd \n",status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


confdb

- FIFO d'événements Attention : Les fonctions applicom® faisant appel au fifo d’événement ne peuvent être utilisées

que par une seule application active (process ou thread). Dans ce chapitre :

- Configuration des variables consignées => CONFDB - Lecture du FIFO de consignation => GETEVENT - Copie d'événements dans le FIFO => SETEVENT

- Configuration des variables consignées => CONFDB prototype en C :

void confdb(short *,short *, short *, short *,short *, short *) prototype en MS pascal :

procédure confdb(var ncard, typ, nb, adr, cond, status: integer); extern; Syntaxe : C confdb(&ncard,&typ,&nb,&adr,&cond,&status) PASCAL confdb(ncard,typ,nb,adr,cond,status) BASIC CONFDB(NCARD,TYP,NB,ADR(1),COND,STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). typ Entier 16 bits, Type de variable à consigner. 1 = bit 2 = octet 3 = mot 16 bits 4 = mot double 32 bits 5 = mot flottant IEEE 32 bits nb Entier 16 bits, Nombre de variables consignées. adr Entier 16 bits, Adresse de la première variable consignée dans DATA-BASE. cond Entier 16 bits, Type de consignation. 0 = Déconsignation. 1 = Sur changement d'état. 2 = Inconditionnelle. status Entier 16 bits. Description : L'évolution des variables dans la base de données de l'interface applicom® peut être consignée et

horodatée automatiquement dans un FIFO de 4096 positions. La fonction CONFDB permet de définir les différentes zones de variables à surveiller dans la base de données.

La fonction applicom® GETEVENT permet de consulter les événements répertoriés dans le FIFO.


WoodheadWoodhead


confdb exemple en langage C Microsoft #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short typ; /* Type de variables */ short nb; /* Nombre de variables */ short adr; /* Adresse dans data-base */ short cond; /* Condition de consignation */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { printf("CONSIGNATION dans le FIFO d'evenements \n"); printf("Type de consignation \n"); scanf(" 1=Bit, 2=Byte, 3=Word, 4=DWord, 5=FWord : %hd \n ",&typ); scanf("Nombre de variables a consigner : %hd \n ",&nb); scanf("Adresse debut de consignation : %hd \n ",&adr); printf("Condition de consignation \n"); printf(" 0 : déconsignation \n "); printf(" 1 : consignation conditionnelle \n "); scanf(" 2 : consignation inconditionnelle \n %hd",&cond); confdb (&ncard,&typ,&nb,&adr,&cond,&status); printf ("status = %d\n",status); } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


getevent

- Lecture du FIFO de consignation => GETEVENT prototype en C :

void getevent(short *,short *, short *, short *, long *, short *, short *, short *) prototype en MS pascal :

procédure getevent(var ncard, nb, tabltyp, tabladr: integer; var tablval: integer4; var tabldate, tabltime, status: integer); extern;

Syntaxe :

C getevent(&ncard,&nb,tabltyp,tabladr,tablval,tabldate,tabltime,&status) PASCAL getevent(ncard,nb,tabltyp[1],tabladr[1],tablval[1],tabldate[1],tabltime[1],status) BASIC GETEVENT(NCARD,NB,TABLTYP(1),TABLADR(1),TABLVAL(1),TABLDATE(1),TABLTIME(1),STATUS)

Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). nb Entier 16 bits, Nombre d'événements à lire dans le FIFO (1-MAX). Si le nombre est inférieur à nb, DATA-BASE retourne dans nb le nombre

d'événements retournés. tabltyp Tableau d'entiers 16 bits, Types des variables consignées. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant IEEE 32 bits. tabladr Tableau d'entiers 16 bits, Adresse des variables consignées. tablval Tableau d'éléments 32 bits, Valeur forcée. tabldate Tableau d'entiers 16 bits, Date de l'événement au format packé. tabltime Tableau d'entiers 16 bits, Heure de l'événement au format packé. status Entier 16 bits, Status de la demande. Description : GETEVENT retourne NB consignations. Si le nombre d'événements consignés dans le FIFO est

inférieur à NB, NB sera modifié par GETEVENT. TABLVAL est un tableau d'éléments de 32 bits. L'interprétation des valeurs retournées dépend de TABLTYP (bit, octet, mot, mot double ou flottant). C'est au programme application de prendre en compte le format des variables.

Les fonctions applicom® UNPACKDATE et UNPACKTIME permettent d'éclater le format de la date et de l'heure.

Le bit à l'adresse 32767 (7FFF H) dans DATA-BASE indique si le FIFO d'événements est plein. Il doit être remis à 0 par le programme utilisateur ou par les automates.

Le bit à l'adresse 32766 (7FFE H) dans DATA-BASE permet la remise à 0 du FIFO d'événements. Ce bit est monostable.

Le mot d'adresse 32766 (7FFE H) dans DATA-BASE indique le nombre de places disponibles dans le FIFO d'événements.


WoodheadWoodhead


getevent exemple en langage C Microsoft Affichage des événements consignés dans le FIFO. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short nb; /* Nombre d'événements */ short tabltyp[20]; /* Type de variables */ short tabladr[20]; /* Adresse dans data-base */ long tablval[20]; /* Type de variables */ short tabldate[20]; /* Date événement */ short tabltime[20]; /* Heure événement */ short status; /* Status */ short i, jour, mois, annee; short heure, minute, seconde; main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . printf("LECTURE du FIFO d'événements \n"); scanf("Numéro de carte : %hd \n",&ncard); scanf("Nombre d'événements à lire : %hd \n",&nb); getevent(&ncard, &nb, tabltyp, tabladr, tablval, tabldate, tabltime, &status); printf("status getevent = %d \n",status); if ( status == 0 ) { if ( nb == 0 ) printf("FIFO vide \n"); else { printf("Nombre d'événements consignés : %d \n",nb); for ( i=0 ; i<nb ; i++ ) { unpackdate (&tabldate[i],&jour,&mois,&annee,&status); unpacktime (&tabltime[i],&seconde,&minute,&heure,&status); printf("%2d / %2d / %2d %2d: %2d: %2d ",jour,mois,annee,heure,minute,seconde); switch (tabltyp[i]) { case 1 : printf (" Bit adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 2 : printf (" Byte adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 3 : printf (" Word adresse : %6d Valeur : %12d H%8lX\n",tabladr[i],tablval[i],tablval[i]); break; case 4 : printf (" DWord adresse : %6d Valeur : %12ld H%8lX\n",tabladr[i],tablval[i],tablval[i]); break; case 5 : printf (" FWord adresse : %6d Valeur : %12.3f\n",tabladr[i],*(float *)&tablval[i]); break; default : break; } } } } . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


setevent

- Copie d'événements dans le FIFO => SETEVENT prototype en C :

void setevent(short *,short *, short *, short *, short *) prototype en MS pascal :

procédure setevent(var ncard, typ, nb, adr, status: integer); extern; Syntaxe : C setevent(&ncard,&typ,&nb,&adr,&status) PASCAL setevent(ncard,typ,nb,adr,status) BASIC SETEVENT(NCARD,TYP,NB,ADR,STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). typ Entier 16 bits, Type de variable à copier. 1 = Bit. 2 = Octet. 3 = Entier 16 bits. 4 = Entier 32 bits. 5 = Flottant IEEE 32 bits. nb Entier 16 bits, Nombre de variables à copier dans le FIFO. adr Entier 16 bits, Adresse de la première variable de Data-Base à copier. status Entier 16 bits, Status. Description : Cette fonction applicom® copie la valeur de variables de Data-Base dans le FIFO de consignation

d'événements de l'interface applicom®. La consultation de ces événements sera réalisée par la fonction GETEVENT.


WoodheadWoodhead


setevent exemple en langage C Microsoft Copie des valeurs des 20 premiers mots de Data-Base dans le FIFO de consignation

d'événements. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short typ; /* Type de variables */ short nb; /* Nombre de variables */ short adr; /* Adresse dans data-base */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . ncard=1; typ=3; nb=20; adr=0; setevent(&ncard, &typ, &nb, &adr, &status); printf("status setevent = %hd \n",status); if ( status == 0 ) printf("Copie OK !! \n"); else printf("Problème !! status = %hd \n",status); . . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead

Librairie/DLL • 253 • - Fonctions de redondance d’équipements

redondance

9. - Fonctions de redondance d’équipements

Dans ce chapitre :

- Fonctionnalité - Fonction de lecture de la définition active ⇒ AppGetEquipmentSwap - Fonction de sélection de la définition active ⇒ AppSetEquipmentSwap - Exemple de programme en langage C.

- Fonctionnalité La fonctionnalité redondance d’équipements est disponible avec les interfaces applicom® PCI

2000 ETH et PCI 2000 MBP sur les messageries :

• ALLEN-BRADLEY sur TCP/IP • CEGELEC sur TCP/IP • GE FANUC sur TCP/IP • INDUSTRIAL ETHERNET sur ISO et/ou TCP/IP • MITSUBISHI sur TCP/IP • MODBUS sur TCP/IP • OMRON sur TCP/IP • UNI-TE sur TCP/IP • Modbus Plus

Cette fonctionnalité permet à l’application de changer d’équipement cible sur un même canal applicom®. De manière générale, chaque fonction applicom® vise un numéro d’équipement. A ce numéro d’équipement applicom® est associé, lors de la configuration, une adresse protocole. Soit :

• Une adresse IP sur Ethernet TCP/IP. • Une adresse MAC sur Ethernet ISO. • Un « Path » sur 5 octets sur Modbus Plus.

L’exemple suivant est appliqué sur TCP/IP, mais le principe reste est identique pour les autres messageries.

Numéro d’équipement applicom®

Adresse TCP/IP

0 128 127 055 000 1 128 127 055 001 .. ….

126 128 127 055 126 127 128 127 055 127

Avec la fonctionnalité redondance d’équipements, la plage des 128 équipements applicom® configurables est divisée en deux parties : 64 équipements pour la définition primaire et 64 équipements pour la définition secondaire.


WoodheadWoodhead


Exemple :

Numéro d’équipement applicom®

Adresse TCP/IP

0 128 127 055 000 Définition 1 128 127 055 001 primaire … …

62 128 127 055 062 63 128 127 055 063 64 128 127 055 064

Définition 65 128 127 055 065 secondaire ….. ….

126 128 127 055 126 127 128 127 055 127

Ainsi chaque équipement est appairé avec une définition primaire et une définition secondaire.

Numéro d’équipement applicom® appairé 0 64 1 65 … … 62 126 63 127

L’application peut changer d’automate cible par une simple commande via la fonction AppSetEquipmentSwap(…). Ainsi toutes les fonctions visant l’équipement passent de l’adresse IP de la définition primaire à l’adresse IP de la définition secondaire (et vice versa). Inversement, pour lire l'état de la permutation, l’application dispose de la fonction AppGetEquipementSwap(…).


WoodheadWoodhead


- Fonction de lecture de la définition active ⇒ AppGetEquipmentSwap

Description : Cette fonction permet la lecture d’une table d’octets. Chaque octet correspond à un numéro d’équipement applicom®, sa valeur indique si le numéro d’équipement utilise la définition primaire ou secondaire. Prototype en C : void AppGetEquipmentSwap ( short int * Channel, short int * FisrtEquipment, short int * Nb, char * State, short int * Status ) Syntaxe : AppGetEquipmentSwap ( &Channel, &FisrtEquipment, &Nb, State, &Status )

Paramètre Type Channel Entier 16 bits, numéro de canal (0-31). FisrtEquipment Entier 16 bits, numéro du premier équipement (0-63) Nb Entier 16 bits, nombre d’équipements (1-64) State Tableau d'octets contenant l’état des équipements :

0 : Définition primaire active 1 : Définition secondaire active 255 : Equipement non configuré (primaire et/ou

secondaire). Status Entier 16 bits, status de l'échange.

Se reporter aux status généraux du manuel protocole.

- Fonction de sélection de la définition active ⇒ AppSetEquipmentSwap

Description : Cette fonction permet l’écriture d’une table d’octets. Chaque octet correspond à un numéro d’équipement applicom® et sa valeur sélectionne si le numéro d’équipement applicom® doit utiliser la définition primaire ou secondaire. Prototype en C : void AppSetEquipmentSwap ( short int * Channel, short int * FisrtEquipment, short int * Nb, char * State, short int * Status ) Syntaxe : AppSetEquipmentSwap ( &Channel, &FisrtEquipment, &Nb, State, &Status )

Paramètre Type Channel Entier 16 bits, numéro de canal (0-31). FisrtEquipment Entier 16 bits, numéro du premier équipement (0-63) Nb Entier 16 bits, nombre d’équipements (1-64) State Tableau d'octets contenant l’état des équipements :

0 : Activation de la définition primaire. 1 : Activation de la définition secondaire.

Status Entier 16 bits, status de l'échange. Se reporter aux status généraux du manuel protocole.


WoodheadWoodhead


- Exemple de programme en langage C.

Un programme indépendant peut assurer automatiquement la permutation des équipements 0 à 63

: - dans Windows, en utilisant APPLICOM.DLL - dans la carte applicom®, en utilisant le kit de développement applicom®. En surveillant les status des fonctions cycliques (recopiés dans la base de données de la carte), il est possible de définir une loi de permutation des équipements. Cette loi sera plus ou moins complexe selon l'application de supervision, le degré de sécurité exigé, ou les types d'équipements utilisés. Que ce soit dans Windows ou dans la carte applicom®, l'utilisation des fonctions AppSetEquipmentSwap et AppGetEquipmentSwap est identique. L'exemple suivant montre une utilisation typique de ces deux fonctions.

short nChannel; short nFirstEquip; short nNbEquip; char cState[64]; short nStatus; . . . /*-- ecriture de l'etat 'swap' ----------------------------------------------------------*/ nChannel = 0; nFirstEquip = 12; nNbEquip = 3; cState[0] = 1; /* equipement 12 : swap */ cState[1] = 0; /* equipement 13 : normal */ cState[2] = 1; /* equipement 14 : swap */ AppSetEquipmentSwap(&nChannel, &nFirstEquip, &nNbEquip, &cState[0], &nStatus); if (nStatus != 0) return -1; . . . /*-- lecture de l'etat 'swap' -----------------------------------------------------------*/ nChannel = 0; nFirstEquip = 12; nNbEquip = 3; AppGetEquipmentSwap(&nChannel, &nFirstEquip, &nNbEquip, &cState[0], &nStatus); if (nStatus != 0) return -1; printf( "Etat swap : %d %d %d", cState[0], cState[1], cState[2] ); . . .


WoodheadWoodhead



WoodheadWoodhead

Librairie/DLL • 258 • - Fonctions locales

transwordbit

10. - Fonctions locales

Dans ce chapitre :

- Eclatement de bits => TRANSWORDBIT - Regroupement de bits => TRANSBITWORD - Comparaison de tableau d'entiers => COMPWORD - Inversion des bits de mots => INVBIT - Eclatement de la date applicom® => UNPACKDATE - Eclatement de l'heure applicom® => UNPACKTIME - Transcodage BCD-binaire => BCDBIN - Transcodage binaire BCD => BINBCD

- Eclatement de bits => TRANSWORDBIT prototype en C :

void transwordbit( short*, short*, short *, short * ) prototype en MS pascal :

procédure transwordbit( var nb, tabls, tabld, status :integer );extern; Syntaxe : C transwordbit( &nb, tabls, tabld, &status ) PASCAL transwordbit( nb, tabls[1], tabld[1], status ) BASIC TRANSWORDBIT( NB, TABLS(1), TABLD(1), STATUS ) Paramètre Type nb Entier 16 bits, Nombre de bits à éclater. tabls Tableau d'entiers 16 bits contenant les entiers à éclater. tabld Tableau d'entiers 16 bits recevant le résultat (0 ou 1). status Entier Description : Cette fonction applicom® vous permet d'éclater les bits d'entiers dans un tableau. Un entier du

tableau "tabls" est éclaté en 16 bits dans le tableau "tabld".


WoodheadWoodhead


transwordbit exemple en langage C Microsoft Eclater les 16 bits contenus dans l'entier val. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de bit à éclater */ short tabls[1]; /* Table contenant les données */ short tabld[16]; /* Table recevant le résultat (0 ou 1) */ short status; /* Status */ short val; /* Valeur à éclater */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nb =16; tabls[0] = val; transwordbit(&nb, tabls, tabld, &status); if (status == 0) { for (i=0; i<nb; i++) printf( "l'état du bit %hd = %hd \n ", i, tabld[i]); } else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


transbitword

- Regroupement de bits => TRANSBITWORD prototype en C :

void transbitword( short*, short*, short *, short * ) prototype en MS pascal :

procédure transbitword( var nb, tabls, tabld, status :integer );extern; Syntaxe : C transbitword( &nb, tabls, tabld, &status ) PASCAL transbitword( nb, tabls[1], tabld[1], status ) BASIC TRANSBITWORD( NB, TABLS(1), TABLD(1), STATUS ) Paramètre Type nb Entier 16 bits, Nombre de bits à regrouper. tabls Tableau d'entiers 16 bits contenant les données à regrouper (0 ou 1). tabld Tableau d'entiers recevant le résultat. status Entier 16 bits. Description : Cette fonction applicom® vous permet de regrouper les bits d'un tableau d'entiers contenant des

valeurs binaire (0-1). 16 entiers du tableau "tabls" sont regroupés en 1 entier du tableau "tabld".


WoodheadWoodhead


transbitword

exemple en langage C Microsoft Regrouper les 16 bits contenus dans les 16 éléments du tableau d'entiers tabls dans l'entier val. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de bit à regrouper */ short tabls[16]; /* Table source */ short val; /* Variable destination */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { nb =16; transbitword(&nb, tabls, &val, status); if (status == 0) printf( "Valeur regroupée = %hd \n ", val[0]); else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


compword

- Comparaison de tableau d'entiers => COMPWORD prototype en C :

void compword(short*, short*, short*, short *, short *) prototype en MS pascal :

procédure compword(var nb, tabl1, tabl2, tablr, status :integer); extern; Syntaxe : C compword(&nb, tabl1, tabl2, tablr, &status) PASCAL compword(nb, tabl1[1], tabl2[1], tablr[1], status) BASIC COMPWORD(NB,TABL1(1),TABL2(1),TABLR(1),STATUS) Paramètre Type nb Entier 16 bits, Nombre d'entiers 16 bits à comparer. tabl1 Tableau d'entiers 16 bits source. tabl2 Tableau d'entiers 16 bits de mémorisation des états précédents de tabl1. tablr Tableau d'entiers résultats. 0 = Si pas de changement 1 = Si l'entier correspondant a augmenté. -1 = Si l'entier correspondant a diminué. status Entier 16 bits. Description: Cette fonction applicom® vous permet de comparer deux tableaux d'entiers. Le tableau "tablr"

vous indique élément par élément les différences en les 2 tableaux.


WoodheadWoodhead


compword exemple en langage C Microsoft #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de mots à éclater */ short tabl1[16]; /* Table des données sources */ short tabl2[16]; /* Table de mémo des états précédents */ short tablr[16]; /* Table contenant les résultats */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . { nb = 16; compword(&nb, tabls1, tabls2, tablr, &status); if (status == 0) { for (i=0; i<nb; i++) { switch ( tablr[i]) { case 0 : printf( " éléments %hd identiques \n" , i ); break; case 1 : printf( " éléments %hd en augmentation \n", i ); break; case -1 : printf( " éléments %hd en diminution \n", i ); break; default : break; } } } else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


invbit

- Inversion des bits de mots => INVBIT prototype en C :

void invbit(short*, short*, short*, short *) prototype en MS pascal :

procédure invbit(var nb, tabls, tabld, status :integer);extern; Syntaxe : C invbit(&nb, tabls, tabld, &status) PASCAL invbit(nb, tabl1[1], tabl2[1], status) BASIC INVBIT(NB,TABLS(1),TABLD(1),STATUS) Paramètre Type nb Entier 16 bits, Nombre de mots à inverser. tabls Tableau d'entiers 16 bits source. tabld Tableau d'entiers 16 bits destination. status Entier 16 bits. Description: Cette fonction applicom® est particulièrement intéressante pour les automates de la gamme PB

de APRIL car les bits de poids faible correspondent aux bits de poids fort d'un mot.


WoodheadWoodhead


invbit exemple en langage C Microsoft Inversion des bits des 16 mots de tabls. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de mots à inverser */ short tabls[16]; /* Table source */ short tabld[16]; /* Table destination */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . { nb = 16; invbit(&nb, tabls, tabld, &status); if (status == 0) { for (i=0; i<nb; i++) { printf( " valeur avant inversion %hd \n", tabls[i] ); printf( " valeur aprés inversion %hd \n", tabld[i] ); } } else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


unpackdate

- Eclatement de la date applicom® => UNPACKDATE prototype en C :

void unpackdate(short*, short*, short*, short*, short *) prototype en MS pascal :

procédure unpackdate(var date, jour, mois, annee, status :integer);extern; Syntaxe : C unpackdate(&date,&jour,&mois,&annee,&status) PASCAL unpackdate(date,jour,mois,annee,status) BASIC UNPACKDATE(DATE,JOUR,MOIS,ANNEE,STATUS) Paramètre Type date Entier 16 bits, Date applicom® au format packé. jour Entier 16 bits. mois Entier 16 bits. annee Entier 16 bits. status Entier 16 bits. Description : Cette fonction applicom® permet d'éclater la date applicom® au format packé renvoyée par la

fonction Data-Base GETEVENT.


WoodheadWoodhead


unpackdate exemple en langage C Microsoft Affichage des événements horodatés consignés dans le FIFO. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short nb; /* Nombre d'événements */ short tabltyp[20]; /* Type de variables */ short tabladr[20]; /* Adresse dans data-base */ long tablval[20]; /* Type de variables */ short tabldate[20]; /* Date événement */ short tabltime[20]; /* Heure événement */ short status; /* Status */ short i, jour, mois, annee; short heure, minute, seconde; main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . printf("LECTURE du FIFO d'événements \n"); scanf("Numéro de carte : %hd \n",&ncard); scanf("Nombre d'événements à lire : %hd \n",&nb); getevent(&ncard, &nb, tabltyp, tabladr, tablval, tabldate, tabltime, &status); printf("status getevent = %d \n",status); if ( status == 0 ) { if ( nb == 0 ) printf("FIFO vide \n"); else { printf("Nombre d'événements consignés : %hd \n",nb); for ( i=0 ; i<nb ; i++ ) { unpackdate (&tabldate[i],&jour,&mois,&annee,&status); unpacktime (&tabltime[i],&seconde,&minute,&heure,&status); printf("%2d / %2d / %2d %2d: %2d: %2d ",jour,mois,annee,heure,minute,seconde); switch (tabltyp[i]) { case 1 : printf (" Bit adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 2 : printf (" Byte adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 3 : printf (" Word adresse : %6d Valeur : %12d H%8X\n",tabladr[i],tablval[i],tablval[i]); break; case 4 : printf (" DWord adresse : %6d Valeur : %12ld H%8lX\n",tabladr[i],tablval[i],tablval[i]); break; case 5 : printf (" FWord adresse : %6d Valeur : %12.3f\n",tabladr[i],*(float *)&tablval[i]); break; default : break; } } } } /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead


unpacktime

- Eclatement de l'heure applicom® => UNPACKTIME prototype en C :

void unpacktime(short*, short*, short*, short*, short *) prototype en MS pascal :

procédure unpacktime(var time, seconde, minute, heure, status :integer);extern; Syntaxe : C unpacktime(&time,&seconde,&minute,&heure,&status) PASCAL unpacktime(time,seconde,minute,heure,status) BASIC UNPACKTIME(TIME,SECONDE,MINUTE,HEURE,STATUS) Paramètre Type time Entier 16 bits, Heure applicom® au format packé. seconde Entier 16 bits, (arrondie à 2 secondes) minute Entier 16 bits, heure Entier 16 bits, status Entier 16 bits, Description : Cette fonction applicom® permet d'éclater l'heure applicom® au format packé renvoyée par la

fonction Data-Base GETEVENT.


WoodheadWoodhead


unpacktime exemple en langage C Microsoft Affichage des événements horodatés consignés dans le FIFO. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short nb; /* Nombre d'événements */ short tabltyp[20]; /* Type de variables */ short tabladr[20]; /* Adresse dans data-base */ long tablval[20]; /* Type de variables */ short tabldate[20]; /* Date événement */ short tabltime[20]; /* Heure événement */ short status; /* Status */ short i, jour, mois, annee; short heure, minute, seconde; main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . printf("LECTURE du FIFO d'événements \n"); scanf("Numéro de carte : %hd \n",&ncard); scanf("Nombre d'événements à lire : %hd \n",&nb); getevent(&ncard, &nb, tabltyp, tabladr, tablval, tabldate, tabltime, &status); printf("status getevent = %d \n",status); if ( status == 0 ) { if ( nb == 0 ) printf("FIFO vide \n"); else { printf("Nombre d'événements consignés : %hd \n",nb); for ( i=0 ; i<nb ; i++ ) { unpackdate (&tabldate[i],&jour,&mois,&annee,&status); unpacktime (&tabltime[i],&seconde,&minute,&heure,&status); printf("%2d / %2d / %2d %2d: %2d: %2d ",jour,mois,annee,heure,minute,seconde); switch (tabltyp[i]) { case 1 : printf (" Bit adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 2 : printf (" Byte adresse : %6d Valeur : %12d \n",tabladr[i],tablval[i]); break; case 3 : printf (" Word adresse : %6d Valeur : %12d H%8X\n",tabladr[i],tablval[i],tablval[i]); break; case 4 : printf (" DWord adresse : %6d Valeur : %12ld H%8lX\n",tabladr[i],tablval[i],tablval[i]); break; case 5 : printf (" FWord adresse : %6d Valeur : %12.3f\n",tabladr[i],*(float *)&tablval[i]); break; default : break; } } } } /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead


bcdbin

- Transcodage BCD-binaire => BCDBIN prototype en C :

void bcdbin(short*, short*, short*, short *) prototype en MS pascal :

procédure bcdbin(var nb, tabls, tabld, status :integer);extern; Syntaxe : C bcdbin(&nb,tabls,tabld,&status) PASCAL bcdbin(nb,tabls[1],tabld [1],status) BASIC BCDBIN(NB,TABLS(1),TABLD(1),STATUS) Paramètre Type nb Entier 16 bits, Nombre de mots à convertir tabls Tableau d'entiers 16 bits, valeurs BCD à convertir tabld Tableau d'entiers 16 bits, valeurs binaire converties status Entier 16 bits. Description : Cette fonction applicom® assure la conversion d'entiers 16 bits exprimés en BCD (Binaire Codé

Décimal) au format binaire. Exemple : Valeur BCD = 1234 (Hexa) Valeur après conversion = 1234 (Décimal) Si une des valeurs positionnées dans "tabls" n'est pas au format BCD, le status 3 vous sera

retourné et aucun échange ne sera exécuté.


WoodheadWoodhead


bcdbin exemple en langage C Microsoft Conversion des 16 mots de tabls. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de mots */ short tabls[16]; /* Table source */ short tabld[16]; /* Table destination */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . { nb = 16; bcdbin(&nb, tabls, tabld, &status); if (status == 0) { for (i=0; i<nb; i++) { printf( " valeur avant conversion %hd \n", tabls[i] ); printf( " valeur aprés conversion %hd \n", tabld[i] ); } } else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead


binbcd

- Transcodage binaire BCD => BINBCD prototype en C :

void binbcd(short*, short*, short*, short *) prototype en MS pascal :

procédure binbcd(var nb, tabls, tabld, status :integer);extern; Syntaxe : C binbcd(&nb,tabls,tabld,&status) PASCAL binbcd(nb,tabls[1],tabld[1],status) BASIC BINBCD(NB,TABLS(1),TABLD(1),STATUS) Paramètre Type nb Entier 16 bits, Nombre de mots à convertir. tabls Tableau d'entiers 16 bits, Valeurs binaire à convertir. tabld Tableau d'entiers 16 bits, Valeurs BCD converties. status Entier 16 bits. Description: Cette fonction applicom® assure la conversion d'entiers 16 bits exprimés en binaire au format

BCD (Binaire Codé Décimal). exemple : Valeur BCD = 1234 (Décimal) Valeur après conversion = 1234 (Hexa) Si une des valeurs positionnées dans "tabls" est supérieure à 9999, le status 3 vous sera retourné

et aucune conversion ne sera exécuté.


WoodheadWoodhead


binbcd exemple en langage C Microsoft Conversion des 16 mots de tabls. #include "inimsc.h" /* Fichier déclarations des prototypes */ short i; /* Compteur de boucle for */ short nb; /* Nombre de mots */ short tabls[16]; /* Table source */ short tabld[16]; /* Table destination */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . { nb = 16; binbdc(&nb, tabls, tabld, &status); if (status == 0) { for (i=0; i<nb; i++) { printf( " valeur avant conversion %hd \n", tabls[i] ); printf( " valeur aprés conversion %hd \n", tabld[i] ); } } else printf("Problème !! status = %hd \n",status); . } . /* exécuter la fonction "exitbus" avant de sortir */ exit(0); }


WoodheadWoodhead

Librairie/DLL • 274 • - Fonctions modem

getmodem

11. - Fonctions modem

Dans ce chapitre :

- Lecture des signaux modem => GETMODEM - Forçage des signaux modem => SETMODEM

- Lecture des signaux modem => GETMODEM prototype en C :

void getmodem(short *, short *, short *, short *) prototype en MS pascal :

procédure getmodem(vars nchan, cts, dcd, status : integer); extern; Syntaxe : C getmodem(&nchan,&cts,&dcd,&status) PASCAL getmodem(nchan,cts,dcd,status) BASIC GETMODEM(NCHAN,CTS,DCD,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). cts Entier 16 bits, Clear To Send. 0 = inactif. 1 = actif. dcd Entier 16 bits, Data Carrier Detect 0 = inactif 1 = actif status Entier 16 bits, Status. Description: Cette fonction applicom® permet la lecture des signaux modem (CTS, DCD) d'un canal RS232 de

l'interface applicom®. Voir chapitre "Gestion des signaux modem" du manuel fonctionnalité.


WoodheadWoodhead


getmodem exemple en langage C Microsoft Lecture des signaux modem CTS et DCD du canal numéro 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short cts; /* Signal clear to send */ short dcd; /* Signal data carrier detect */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { do { nchan=3; getmodem(&nchan, &cts, &dcd, &status); if (status == 0) { printf (" Etat du signal CTS = %hd \n ", cts); printf (" Etat du signal DCD = %hd \n ", dcd); } } while(status == 0); } /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead


setmodem

- Forçage des signaux modem => SETMODEM prototype en C :

void setmodem(short *, short *, short *, short *) prototype en MS pascal :

procédure setmodem(vars nchan, rts, dtr , status : integer); extern; Syntaxe : C setmodem(&nchan,&rts,&dtr,&status) PASCAL setmodem(nchan,rts,dtr,status) BASIC SETMODEM(NCHAN,RTS,DTR,STATUS) Paramètre Type nchan Entier 16 bits, Numéro de canal (0-31). rts Entier 16 bits, Signal Request To Send. 0 = inactif. 1 = actif. dtr Entier 16 bits, Signal Data Terminal Ready. 0 = inactif. 1 = actif. status Entier 16 bits. Description : Cette fonction applicom® permet de positionner les signaux modem (DTR, RTS) d'un canal RS232

de l'interface applicom®. Voir chapitre "Gestion des signaux modem" du manuel fonctionnalité.


WoodheadWoodhead


setmodem exemple en langage C Microsoft Mise à un des signaux modem RTS et DTR du canal numéro 3 de l'interface applicom®. #include "inimsc.h" /* Fichier déclarations des prototypes */ short nchan; /* Numéro de canal */ short rts; /* Signal request to send */ short dtr; /* Signal data terminal ready */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ { . { nchan=3; rts=1; dtr=1; setmodem(&nchan, &rts, &dtr, &status); if (status == 0) { printf (" Signaux modem RTS et DTR actifs \n"); } } . } /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead

Librairie/DLL • 278 • - Fonctions annexes

watchdog

12. - Fonctions annexes

Dans ce chapitre :

- Activation du contact chien de garde => WATCHDOG - Lecture entrée/sortie T.O.R. => AppGetWatchDog - Accès à la clé de protection logiciel => ACCESSKEY - Initialisation date et heure => AppIniTime

- Activation du contact chien de garde => WATCHDOG prototype en C :

void watchdog(short *, short*, short *) prototype en MS pascal :

procédure watchdog(var ncard, time, status :integer);extern; Syntaxe : C watchdog(&ncard,&time,&status) PASCAL watchdog(ncard,time,status) BASIC WATCHDOG(NCARD,TIME,STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). time Entier 16 bits, Période de fermeture du contact en secondes. time = 0, Ouverture du contact sans période. time = -1, Fermeture du contact sans période. status Entier Description: Cette fonction applicom® est accessible sur toutes les interfaces applicom®. Un contact chien de

garde est à la disposition de l'utilisateur. Ce contact peut être forcé fermé, ouvert ou rafraîchi pour une période donnée. Dans ce dernier cas, le contact se ferme dès l'appel à la fonction et retombe après le temps passé en paramètre, à moins qu'avant l'expiration de ce temps, le programme utilisateur ait rafraîchi cette fonction de nouveau.


WoodheadWoodhead


watchdog exemple en langage C Microsoft Le sous-programme suivant rafraîchi le contact chien de garde pour une période de 10 secondes.

Si ce sous programme n'est pas exécuté de nouveau avant 10 secondes, le contact chien de garde s'ouvrira.

#include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard; /* Numéro de carte */ short time; /* Temps de fermeture */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ do { ncard=1;time=10; watchdog(&ncard, &time, &status); if ( status == 0 ) printf(" Contact Chien de garde fermé pendant %hd seconde \n ", time); } while(1); . /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead


AppGetWatchDog

- Lecture entrée/sortie T.O.R. => AppGetWatchDog prototype en C :

void AppGetWatchDog(short *, unsigned short *, unsigned short *, short *) prototype en MS pascal :

procédure AppGetWatchDog(var ncard :integer ; var digital_input, time_contact : word ; var status :integer);extern; Syntaxe : C AppGetWatchDog(&ncard, &digital_input, &time_contact, &status) PASCAL AppGetWatchDog(ncard, digital_input, time_contact, status) BASIC APPGETWATCHDOG(NCARD, DIGITALINPUT, TIMECONTACT, STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). digital_input Entier 16 bits, Etat de l'entrée T.O.R. (0 ou 1). time_contact Entier 16 bits, Etat du contact de sortie watchdog. time_contact = 0, Contact ouvert. time_contact = 65535, Contact forcé fermé. 0 < time_contact < 65535, Contact fermé jusqu'a écoulement du temps exprimé

en secondes dans "time_contact". status Entier Description: Cette fonction applicom® permet de consulter l'état : - De l'entrée T.O.R. - Du contact de sortie "watchdog". Pour piloter ce contact reportez-vous à la fonction applicom®

"WATCHDOG". Cette fonction est utilisable sur les interfaces applicom® équipées d'une EPROM version 3.2 ou

supérieure.


WoodheadWoodhead


AppGetWatchDog exemple en langage C Microsoft Le sous-programme suivant lit l'état de l'entrée T.O.R. et du contact chien de garde. #include "inimsc.h" /* Fichier déclarations des prototypes */ short ncard = 1; /* Numéro de carte */ unsigned short digital_input; /* Etat de l'entrée */ unsigned short time_contact; /* Temps de fermeture */ short status; /* Status */ main() { /* initialiser le dialogue avec le produit applicom® par "initbus" */ . . AppGetWatchDog( &ncard, &digital_input, &time_contact, &status); if ( status == 0 ) { printf(" Entrée tout ou rien = %hu \n ", digital_input ); printf(" Timer du contact = %hu secondes \n ", time_contact ); } else printf(" Status AppGetWatchDog = %hd \n ", status ); . . . /* exécuter la fonction "exitbus" avant de sortir */ }


WoodheadWoodhead


accesskey

- Accès à la clé de protection logiciel => ACCESSKEY prototype en C :

void accesskey(short *, short *, short*, short *) prototype en MS pascal :

procédure accesskey(var ncard, type, val, status :integer);extern; Syntaxe C accesskey(&ncard,&typ,&val,&status) PASCAL accesskey(ncard,typ,val,status) BASIC ACCESSKEY(NCARD,TYPE,VAL,STATUS) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). type Entier 16 bits, Type d'accès au circuit de protection. 0 = Lecture du circuit 1 = Ecriture du circuit val Entier 16 bits, Valeur lue dans le circuit si "type" = 0. Valeur forcée dans le circuit si "type" = 1. status Entier Description : Un algorithme peut être défini pour protéger votre logiciel contre les copies. Dans ce but, la fonction

ACCESSKEY peut être utilisée pour lire ou écrire un séquence d'octets. Votre programme devra vérifier que le séquencement des lectures/écritures est conforme à l'algorithme que vous aviez défini.

Veuillez contacter applicom international afin d'obtenir des informations complémentaires sur la marche à suivre pour définir cet algorithme.


WoodheadWoodhead


AppIniTime

- Initialisation date et heure => AppIniTime prototype en C :

void AppIniTime( short *, short * ) prototype en MS pascal :

procédure AppIniTime( var ncard, status :integer ); extern; Syntaxe C AppIniTime( &ncard, &status) PASCAL AppIniTime( ncard, status ) BASIC APPINITIME( NCARD,STATUS ) Paramètre Type ncard Entier 16 bits, Numéro de carte (1-8). status Entier Description : Cette fonction applicom® permet d'initialiser la date et l'heure de l'interface applicom® avec la

date et l'heure du PC.


WoodheadWoodhead

Librairie/DLL • 284 • - Index

13. - Index

accesskey, 291 actcyc, 194 AppConnect, 90 AppFmsGetOd, 121 AppFmsStatus, 123 AppGetCycParam, 202 AppGetEquipmentSwap, 264 AppGetWatchDog, 289 AppIniTime, 293 AppSetEquipmentSwap, 264 AppUnconnect, 92 AuSetApplicationMaxSize, 13, 15 automatic, 88 bcdbin, 279 binbcd, 281 Borland C/C++, 2 compword, 271 confdb, 254 createcyc, 184 CVI, 2 CycExecuted, 200 decdispdword, 252 decdispword, 250 Delphi, 2 DLL, 2 exitbus, 17 getbit, 208 getdispbit, 218 getdispdword, 222 getdispword, 220 getdword, 214 getevent, 256 getfword, 216 getmodem, 283 getpackbit, 205 getpackbyte, 210 getword, 212 incdispdword, 248 incdispword, 246 initbus, 11 Initialisation du driver, 11 invbit, 273 iocounter, 96 LabVIEW, 2 librairie, 2 manual, 86 MSVC, 2 readbyte, 28 readcounter, 54 readdiag, 82 readdiagute, 104 readdifbit, 127


WoodheadWoodhead


readdifbyte, 133 readdifdword, 145 readdiffword, 147 readdifibit, 129 readdifibyte, 135 readdifiword, 141 readdifmes, 167 readdifqbit, 131 readdifqbyte, 137 readdifquickbit, 149 readdifqword, 143 readdifword, 139 readdword, 48 readeven, 84 readfword, 50 readibyte, 30 readident, 106 readiword, 42 readmes, 113 readpackbit, 19 readpackbyte, 34 readpackibit, 22 readpackibyte, 36 readpackqbit, 24 readpackqbyte, 38 readqbyte, 32 readquickbit, 26 readqword, 44 readtimer, 52 readtrace, 102 readword, 40 readwordbcd, 46 redondance, 261 resetcounterute, 100 resetiocounter, 98 setbit, 228 setdispbit, 238 setdispdword, 242 setdispfword, 244 setdispword, 240 setdword, 234 setevent, 258 setfword, 236 setmodem, 285 setpackbit, 226 setpackbyte, 230 setword, 232 startcyc, 190 statjbus, 94 stopcyc, 192 swap, 261 testtransdif, 182 transbitword, 269 transcyc, 196 transcycpack, 198 transdif, 177 transdifpack, 180 transwordbit, 267 Turbo-Pascal, 2 txtute, 108


WoodheadWoodhead


unpackdate, 275 unpacktime, 277 VB, 2 Visual Basic, 2 watchdog, 287 Windev, 2 writebyte, 60 writecounter, 80 writedifdword, 163 writediffword, 165 writedifmes, 170 writedifpackbit, 151 writedifpackbyte, 155 writedifpackqbit, 153 writedifpackqbyte, 157 writedifqword, 161 writedifword, 159 writedword, 74 writefword, 76 writemes, 116 writepackbit, 56 writepackbyte, 64 writepackqbit, 58 writepackqbyte, 66 writeqbyte, 62 writeqword, 70 writereaddifmes, 172 writereadmes, 118 writetimer, 78 writeword, 68 writewordbcd, 72

electrical & safety · industrial connectivty · software

Documents