Archives de catégorie : Labo

cifX : Siemens WinAC RTX – Application de test – CANopen Master – SDO

Bonjour,

Dans les articles précédents concernant l’application de test pour le pilote cifX pour WinAC RTX® il était question de configurer une carte Hilscher cifX 50E-RE avec les firmwares Open Modbus TCP en IO Server, PROFINET IO IRT Device ou Ethernet/IP Adapter.

Faisant suite à la requête d’un de nos clients, une nouvelle version de cette application de test est disponible qui permet, en utilisant une carte Hilscher cifX 50E-CO avec le firmware CANopen Master, de lire une donnée du dictionnaire d’objet d’un esclave via SDO :
http://www.hf-news.fr/download/cifX/WinACRTX2009/cifXWACDriver/20131023.zip

Comme l’application implémente plusieurs options de configuration, ces options sont maintenant configurables depuis l’OB de démarrage.

Enfin, les blocs fonctions gérant les messages ont été retouchés pour traiter d’éventuelles erreurs.

Le bloc fonction qui implémente la lecture via SDO a donc été rajouté :

FB47 CIFX_COM_SDOR0_0 Hilscher cifX Driver : Messaging / CANopen Master SDO Read

La carte Hilscher cifX 50E-CO est configurée avec l’outil SYCON.net en CANopen Master et l’application de test montre la lecture de l’objet (Identity Object, Product code) d’index := 1018, sous-index := 2 de l’esclave d’adresse 2.

Une VAT permet de piloter cette requête et d’afficher le résultat :

cifXWACVATSDO1

Il suffit de renseigner les paramètres de la requête et de lancer la commande (Do).

La réponse est contenue dans les quatre octets de données 00 1A 20 20, soit 1712160 en décimal, ce qui correspond au code produit de la passerelle Hilscher netTAP CANopen esclave utilisée pour les essais.

cifXWACVATSDO2

Votre NanoBox Siemens peut donc se voir adjoindre une fonctionnalité Maitre CANopen et ainsi être tout à fait capable de gérer des esclaves CANopen en prenant en charge les PDO, c’est à dire les données process cycliques, les SDO pour l’accès en lecture et écriture aux données du dictionnaire, et les commandes NMT pour la gestion des modes de marche des nœuds.

N’hésitez pas à nous solliciter pour obtenir un exemple de code convenant à votre besoin.

Cordialement,
Stéphane

cifX : FDT/DTM – Un exemple intéressant – E+H FieldCare

Bonjour,

J’ai abordé dans cet article la technologie FDT/DTM mise en œuvre dans l’outil Hilscher SYCON.net.

J’y décrivais l’utilisation du DTM pour l’instrument Micropilot M FMR 244 de chez Endress + Hauser dans SYCON.net.

S’il est possible d’utiliser les DTM Endress + Hauser dans SYCON.net, il est tout aussi possible d’utiliser les DTM Hilscher avec l’outil FieldCare.

Pour pouvoir utiliser la carte Hilscher cifX DP/DPM dans FieldCare il suffit d’installer SYCON.net, ce qui installera les DTM Hilscher, de mettre à jour le catalogue des DTM FieldCare et de sélectionner le DTM de la carte cifX DP/DPM comme interface PROFIBUS DP V1.

Le seul bémol c’est que ça ne fonctionne pas si l’on sélectionne le Français comme langue d’interface dans FieldCare… En choisissant US English, ça le fait !
Comme de bien entendu j’ai remonté le problème à mes collègues et je ne désespère pas qu’il soit réglé très bientôt.

Voici quelques copies d’écran montrant une configuration avec une carte PROFIBUS DP Hilscher cifX 50-DP Maitre et un Micropilot M FMR 244 de chez Endress + Hauser.

Une vue du catalogue des DTM, avec le minimum d’équipements importés :

FieldCare-DTM-Catalog

Une portion de la configuration de la carte cifX 50-DP :

FieldCare-DTM-cifX-Config

Les diagnostics intégrés de la carte cifX :

FieldCare-DTM-cifX-Diag

Une vue du IO Monitor qui permet d’afficher les données dans la Dual Port Memory de la carte, c’est à dire l’image procédé en octets :

FieldCare-DTM-cifX-IOMonitor

Et pour terminer, une vue de diagnostic de l’équipement Endress + Hauser :

FieldCare-DTM-FMR-Diag

Bien sûr, il est possible de réaliser toutes les autres opérations sur cet équipement comme la configuration en / hors ligne, la sauvegarde des paramètres, la surveillance du procédé…

Cordialement,
Stéphane

cifX : Mise en œuvre : API – Messages – PROFIBUS DP V1 Class 2

Bonjour,

J’ai déjà abordé l’API cifX dans cet article d’introduction et les messages de configuration dans celui-ci entre autres.

Comme je dispose d’un équipement Endress + Hauser Micropilot M FMR 244, un instrument de mesure de niveau radar qui peut répondre à des requêtes PROFIBUS DP V1 Class 2 pour la lecture / écriture des paramètres de l’instrument, j’en profite pour vous donner cet autre exemple d’utilisation de la messagerie Hilscher.

Le document suivant de chez Endress + Hauser nous renseigne sur les éléments adressables de cet instrument :
https://portal.endress.com/wa001/dla/5000415/7572/000/08/BA00249FEN_1311.pdf

L’instrument est DP V0 et supporte une communication PROFIBUS DP V1 Class 2 mais pas la communication PROFIBUS DP V1 Class 1.

La carte Hilscher cifX 50-DP est donc configurée en PROFIBUS DP Maitre et la documentation suivante est nécessaire :
PROFIBUS DP Master Protocol API

On la trouve bien sûr également sur le DVD dans le répertoire Documentation :
6. Programming Manuals\english\4. Protocol Application Programming Interface\PROFIBUS DP Master

Cette documentation nous indique que nous pouvons utiliser les services d’un maitre DP V1 Class 1 ou ceux d’un maitre DP V1 Class 2. Dans cette manipulation nous utiliserons donc la seconde option.

Nous y trouvons la commande à employer pour la lecture d’un bloc de données d’un esclave DP V1 en p.192 :
PROFIBUS_FSPMM2_CMD_READ_REQ/CNF – V1 Class 2 Read Request

Cependant, avant il nous faut ouvrir une connexion entre le maitre Class 2, notre carte cifX, et l’esclave DP.

Nous disposons dans le document E+H au chapitre 5.5.6 Slot/index tables en p.48 de la table des données avec les paramètres nécessaires à l’élaboration de notre requête.

Ainsi essayons de lire par exemple :
Block parameters
Software revision 1 73 16 OSTRING X constant

Il nous faut l’adresse de l’esclave, dans notre cas 2, le numéro de slot, ici 1, l’index, ici 73 et la taille des données, soit 16 pour notre chaine de caractères.

L’algorithme est simple :

  • S’enregistrer auprès de la pile de protocole PROFIBUS DP Maitre pour pouvoir recevoir les indications, notamment celle que nous allons recevoir à notre demande de déconnexion, cf. « Register / Unregister an Application » dans le document netX Dual-Port Memory Interface (DPM).
  • Se connecter à l’esclave, cf. PROFIBUS_FSPMM2_CMD_INITIATE_REQ/CNF– Initiate DPV1C2 Connection
  • Envoyer notre requête de lecture, cf. PROFIBUS_FSPMM2_CMD_READ_REQ/CNF – V1 Class 2 Read Request
  • Envoyer notre requête de déconnexion, cf. PROFIBUS_FSPMM2_CMD_ABORT_REQ/CNF – Request Abort of Connection
  • Purger les indications, cf. PROFIBUS_FSPMM2_CMD_CLOSED_IND/RES – Closed Indication
  • Se dés-enregistrer.

Bien sûr, c’est un code de démonstration. On peut et on doit faire mieux !

D’où le code du jour :

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include "rcX_Public.h"
#include "cifxuser.h"
#include "cifxErrors.h"
#include "TLR_Types.h"
#include "ProfibusFspmm_Public.h"
#include "ProfibusFspmm2_Public.h"

#define IO_WAIT_TIMEOUT     10

/*****************************************************************************/
/*! Show error
 *                                                                           */

/*****************************************************************************/
void ShowError( long lError)
{
  if( lError != CIFX_NO_ERROR)
    {
      /* Read driver error description */
      char szError[1024] ={0};
      xDriverGetErrorDescription( lError,  szError, sizeof(szError));
      printf("Error: 0x%X, <%s>\r\n", lError, szError);
    }
}

static uint32_t      ulMsgId         = 0;
static uint32_t      ulCRef          = 0;

/*****************************************************************************/
/*! Register Application Request
 *   \return 0 on success                                                    */

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

int Register_Application(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;

  CIFX_PACKET   tSendPacket     = {0};
  CIFX_PACKET   tRecvPacket     = {0};

  RCX_REGISTER_APP_REQ_T    *pPktRegisterReq;
  RCX_REGISTER_APP_CNF_T    *pPktRegisterCnf;

  pPktRegisterReq = (RCX_REGISTER_APP_REQ_T *)&tSendPacket;

  pPktRegisterReq->tHead.ulDest   = 0x20; /* Channel mailbox */
  pPktRegisterReq->tHead.ulSrc    = 0x00;
  pPktRegisterReq->tHead.ulDestId = 0x00;
  pPktRegisterReq->tHead.ulSrcId  = 0x00;
  pPktRegisterReq->tHead.ulLen    = 0;
  pPktRegisterReq->tHead.ulId     = ulMsgId++;
  pPktRegisterReq->tHead.ulSta    = 0x00;
  pPktRegisterReq->tHead.ulCmd    = RCX_REGISTER_APP_REQ;
  pPktRegisterReq->tHead.ulExt    = 0x00;
  pPktRegisterReq->tHead.ulRout   = 0x00;

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  else
    {
      printf("Register Request sent...\r\n");
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          pPktRegisterCnf = (RCX_REGISTER_APP_CNF_T *)&tRecvPacket;
          if(pPktRegisterCnf->tHead.ulCmd != RCX_REGISTER_APP_CNF)
            {
              printf("Wrong CNF received : pPktRegisterCnf->tHead.ulCmd = 0x%08X\r\n",
                     pPktRegisterCnf->tHead.ulCmd);
            }
          else if(pPktRegisterCnf->tHead.ulSta != 0)
            {
              printf("Wrong CNF received : pPktRegisterCnf->tHead.ulSta = 0x%08X\r\n",
                     pPktRegisterCnf->tHead.ulSta);
            }
          else
            {
              printf("Register Request confirmation received.\r\n");
              iResult = 0;
            }
        }
    }
  return iResult;
}

/*****************************************************************************/
/*! Unregister Application Request
 *   \return 0 on success                                                    */

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

int Unregister_Application(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;

  CIFX_PACKET   tSendPacket     = {0};
  CIFX_PACKET   tRecvPacket     = {0};

  RCX_UNREGISTER_APP_REQ_T    *pPktUnregisterReq;
  RCX_UNREGISTER_APP_CNF_T    *pPktUnregisterCnf;

  pPktUnregisterReq = (RCX_UNREGISTER_APP_REQ_T *)&tSendPacket;

  pPktUnregisterReq->tHead.ulDest   = 0x20; /* Channel mailbox */
  pPktUnregisterReq->tHead.ulSrc    = 0x00;
  pPktUnregisterReq->tHead.ulDestId = 0x00;
  pPktUnregisterReq->tHead.ulSrcId  = 0x00;
  pPktUnregisterReq->tHead.ulLen    = 0;
  pPktUnregisterReq->tHead.ulId     = ulMsgId++;
  pPktUnregisterReq->tHead.ulSta    = 0x00;
  pPktUnregisterReq->tHead.ulCmd    = RCX_UNREGISTER_APP_REQ;
  pPktUnregisterReq->tHead.ulExt    = 0x00;
  pPktUnregisterReq->tHead.ulRout   = 0x00;

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  else
    {
      printf("Unregister Request sent...\r\n");
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          pPktUnregisterCnf = (RCX_UNREGISTER_APP_CNF_T *)&tRecvPacket;
          if(pPktUnregisterCnf->tHead.ulCmd != RCX_UNREGISTER_APP_CNF)
            {
              printf("Wrong CNF received : pPktUnregisterCnf->tHead.ulCmd = 0x%08X\r\n",
                     pPktUnregisterCnf->tHead.ulCmd);
            }
          else if(pPktUnregisterCnf->tHead.ulSta != 0)
            {
              printf("Wrong CNF received : pPktUnregisterCnf->tHead.ulSta = 0x%08X\r\n",
                     pPktUnregisterCnf->tHead.ulSta);
            }
          else
            {
              printf("Unregister Request confirmation received.\r\n");
              iResult = 0;
            }
        }
    }
  return iResult;
}

/*****************************************************************************/
/*! DPV1 Class 2 Initiate Connection Request to a PROFIBUS DP Slave
 *   \return 0 on success                                                    */

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

int DPV1Class2_Initiate(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;

  CIFX_PACKET   tSendPacket     = {0};
  CIFX_PACKET   tRecvPacket     = {0};

  PROFIBUS_FSPMM2_PACKET_INITIATE_REQ_T    *pPktInitiateReq;
  PROFIBUS_FSPMM2_PACKET_INITIATE_CNF_T    *pPktInitiateCnf;

  pPktInitiateReq = (PROFIBUS_FSPMM2_PACKET_INITIATE_REQ_T *)&tSendPacket;

  pPktInitiateReq->tHead.ulDest   = 0x20; /* Channel mailbox */
  pPktInitiateReq->tHead.ulSrc    = 0x00;
  pPktInitiateReq->tHead.ulDestId = 0x00;
  pPktInitiateReq->tHead.ulSrcId  = 0x00;
  pPktInitiateReq->tHead.ulLen    = PROFIBUS_FSPMM2_INITIATE_REQ_SIZE + 4 + 4;
  pPktInitiateReq->tHead.ulId     = ulMsgId++;
  pPktInitiateReq->tHead.ulSta    = 0x00;
  pPktInitiateReq->tHead.ulCmd    = PROFIBUS_FSPMM2_CMD_INITIATE_REQ;
  pPktInitiateReq->tHead.ulExt    = 0x00;
  pPktInitiateReq->tHead.ulRout   = 0x00;

  pPktInitiateReq->tData.ulRemAdd        =    2;   /* Slave address */
  pPktInitiateReq->tData.usSendTimeout   =  100;

  pPktInitiateReq->tData.bFeaturesSupported1 =  1;
  pPktInitiateReq->tData.bFeaturesSupported2 =  0;

  pPktInitiateReq->tData.bProfileFeaturesSupported1 =  0;
  pPktInitiateReq->tData.bProfileFeaturesSupported2 =  0;
  pPktInitiateReq->tData.usProfileIdentNumber       =  0;

  pPktInitiateReq->tData.tAddAddrParam.bS_Type =  0;
  pPktInitiateReq->tData.tAddAddrParam.bS_Len  =  2;
  pPktInitiateReq->tData.tAddAddrParam.bD_Type =  0;
  pPktInitiateReq->tData.tAddAddrParam.bD_Len  =  2;

  pPktInitiateReq->tData.tAddAddrParam.abAddParam[0] =  0;
  pPktInitiateReq->tData.tAddAddrParam.abAddParam[1] =  0;
  pPktInitiateReq->tData.tAddAddrParam.abAddParam[2] =  0;
  pPktInitiateReq->tData.tAddAddrParam.abAddParam[3] =  0;

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  else
    {
      printf("Initiate Request sent...\r\n");
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          pPktInitiateCnf = (PROFIBUS_FSPMM2_PACKET_INITIATE_CNF_T *)&tRecvPacket;
          if(pPktInitiateCnf->tHead.ulCmd != PROFIBUS_FSPMM2_CMD_INITIATE_CNF)
            {
              printf("Wrong CNF received : pPktInitiateCnf->tHead.ulCmd = 0x%08X\r\n",
                     pPktInitiateCnf->tHead.ulCmd);
            }
          else if(pPktInitiateCnf->tHead.ulSta != 0)
            {
              printf("Wrong CNF received : pPktInitiateCnf->tHead.ulSta = 0x%08X\r\n",
                     pPktInitiateCnf->tHead.ulSta);
              printf("ulRemAdd     = 0x%08X\r\n"
                     "bErrorDecode = 0x%02X\r\n"
                     "bErrorCode1  = 0x%02X\r\n"
                     "bErrorCode2  = 0x%02X\r\n"
                     "usDetail     = 0x%04X\r\n",
                     pPktInitiateCnf->tData.tCnfNeg.ulRemAdd,
                     pPktInitiateCnf->tData.tCnfNeg.bErrorDecode,
                     pPktInitiateCnf->tData.tCnfNeg.bErrorCode1,
                     pPktInitiateCnf->tData.tCnfNeg.bErrorCode2,
                     pPktInitiateCnf->tData.tCnfNeg.usDetail);
            }
          else
            {
              printf("Initiate Request confirmation received.\r\n");
              ulCRef = pPktInitiateCnf->tData.tCnfPos.ulCRef;
              iResult = 0;
            }
        }
    }
  return iResult;
}

/*****************************************************************************/
/*! DPV1 Class 2 Read Request PROFIBUS DP Slave
 *   \return 0 on success                                                    */

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

int DPV1Class2_Read(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;

  CIFX_PACKET   tSendPacket     = {0};
  CIFX_PACKET   tRecvPacket     = {0};

  PROFIBUS_FSPMM2_PACKET_READ_REQ_T    *pPktReadReq;
  PROFIBUS_FSPMM2_PACKET_READ_CNF_T    *pPktReadCnf;

  pPktReadReq = (PROFIBUS_FSPMM2_PACKET_READ_REQ_T *)&tSendPacket;

  pPktReadReq->tHead.ulDest   = 0x20; /* Channel mailbox */
  pPktReadReq->tHead.ulSrc    = 0x00;
  pPktReadReq->tHead.ulDestId = 0x00;
  pPktReadReq->tHead.ulSrcId  = 0x00;
  pPktReadReq->tHead.ulLen    = PROFIBUS_FSPMM2_READ_REQ_SIZE;
  pPktReadReq->tHead.ulId     = ulMsgId++;
  pPktReadReq->tHead.ulSta    = 0x00;
  pPktReadReq->tHead.ulCmd    = PROFIBUS_FSPMM2_CMD_READ_REQ;
  pPktReadReq->tHead.ulExt    = 0x00;
  pPktReadReq->tHead.ulRout   = 0x00;

  pPktReadReq->tData.ulCRef     = ulCRef;   /* Connection Reference */
  pPktReadReq->tData.ulSlot     =      1;   /* Requested slot */
  pPktReadReq->tData.ulIndex    =     73;   /* Requested index */
  pPktReadReq->tData.ulLength   =     16;   /* Requested data length */

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  else
    {
      printf("Read Request sent...\r\n");
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          pPktReadCnf = (PROFIBUS_FSPMM2_PACKET_READ_CNF_T *)&tRecvPacket;
          if(pPktReadCnf->tHead.ulCmd != PROFIBUS_FSPMM2_CMD_READ_CNF)
            {
              printf("Wrong CNF received : pPktReadCnf->tHead.ulCmd = 0x%08X\r\n",
                     pPktReadCnf->tHead.ulCmd);
            }
          else if(pPktReadCnf->tHead.ulSta != 0)
            {
              printf("Wrong CNF received : pPktReadCnf->tHead.ulSta = 0x%08X\r\n",
                     pPktReadCnf->tHead.ulSta);
            }
          else
            {
              printf("Read Request confirmation received.\r\n");
              printf("Software revision : %.16s\r\n", pPktReadCnf->tData.tCnfPos.abData);
              iResult = 0;
            }
        }
    }
  return iResult;
}

/*****************************************************************************/
/*! DPV1 Class 2 Abort Request
 *   \return 0 on success                                                    */

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

int DPV1Class2_Abort(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;

  CIFX_PACKET   tSendPacket     = {0};
  CIFX_PACKET   tRecvPacket     = {0};

  PROFIBUS_FSPMM2_PACKET_ABORT_REQ_T    *pPktAbortReq;
  PROFIBUS_FSPMM2_PACKET_ABORT_CNF_T    *pPktAbortCnf;

  pPktAbortReq = (PROFIBUS_FSPMM2_PACKET_ABORT_REQ_T *)&tSendPacket;

  pPktAbortReq->tHead.ulDest   = 0x20; /* Channel mailbox */
  pPktAbortReq->tHead.ulSrc    = 0x00;
  pPktAbortReq->tHead.ulDestId = 0x00;
  pPktAbortReq->tHead.ulSrcId  = 0x00;
  pPktAbortReq->tHead.ulLen    = PROFIBUS_FSPMM2_ABORT_REQ_SIZE;
  pPktAbortReq->tHead.ulId     = ulMsgId++;
  pPktAbortReq->tHead.ulSta    = 0x00;
  pPktAbortReq->tHead.ulCmd    = PROFIBUS_FSPMM2_CMD_ABORT_REQ;
  pPktAbortReq->tHead.ulExt    = 0x00;
  pPktAbortReq->tHead.ulRout   = 0x00;

  pPktAbortReq->tData.ulCRef      = ulCRef;   /* Connection Reference */
  pPktAbortReq->tData.bSubnet     = PROFIBUS_FSPMM2_SUBNET_NO;
  pPktAbortReq->tData.bInstance   = PROFIBUS_FSPMM2_INSTANCE_USER;
  pPktAbortReq->tData.bReasonCode =      0;

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  else
    {
      printf("Abort Request sent...\r\n");
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          pPktAbortCnf = (PROFIBUS_FSPMM2_PACKET_ABORT_CNF_T *)&tRecvPacket;
          if(pPktAbortCnf->tHead.ulCmd != PROFIBUS_FSPMM2_CMD_ABORT_CNF)
            {
              printf("Wrong CNF received : pPktAbortCnf->tHead.ulCmd = 0x%08X\r\n",
                     pPktAbortCnf->tHead.ulCmd);
            }
          else if(pPktAbortCnf->tHead.ulSta != 0)
            {
              printf("Wrong CNF received : pPktAbortCnf->tHead.ulSta = 0x%08X\r\n",
                     pPktAbortCnf->tHead.ulSta);
            }
          else
            {
              printf("Abort Request confirmation received.\r\n");
              iResult = 0;
            }
        }
    }
  return iResult;
}

int Purge(HANDLE hChannel)
{
  long          lRet            = CIFX_NO_ERROR;
  int           iResult         = -1;
  int           iCount          = 3; /* Wait 3 times */

  CIFX_PACKET   tRecvPacket     = {0};

  do
    {
      iCount--;
      lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
      if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }
      else
        {
          printf("Packet received :\r\n"
                 "ulCmd      = 0x%08X\r\n"
                 "ulDest     = 0x%08X\r\n"
                 "ulSrc      = 0x%08X\r\n"
                 "ulDestId   = 0x%08X\r\n"
                 "ulSrcId    = 0x%08X\r\n",
                 tRecvPacket.tHeader.ulCmd,
                 tRecvPacket.tHeader.ulDest,
                 tRecvPacket.tHeader.ulSrc,
                 tRecvPacket.tHeader.ulDestId,
                 tRecvPacket.tHeader.ulSrcId);

          switch (tRecvPacket.tHeader.ulCmd)
            {
              case PROFIBUS_FSPMM2_CMD_CLOSED_IND:
                {
                  printf("Closed Indication received : tRecvPacket->tHead.ulSta = 0x%08X\r\n",
                         tRecvPacket.tHeader.ulState);

                  tRecvPacket.tHeader.ulDest = 0x20; /* Channel mailbox */
                  tRecvPacket.tHeader.ulCmd  = PROFIBUS_FSPMM2_CMD_CLOSED_RES;

                  lRet = xChannelPutPacket(hChannel, &tRecvPacket, 1000);
                  if(lRet != CIFX_NO_ERROR)
                    {
                      ShowError( lRet);
                    }
                  else
                    {
                      printf("Closed Response sent...\r\n");
                      iResult = 0;
                    }
                  break;
                }

              default:
                {
                  printf("Message received : tRecvPacket->tHead.ulCmd = 0x%08X\r\n",
                         tRecvPacket.tHeader.ulCmd);
                  break;
                }
            }
        }
    }
    while (iCount > 0);
  return iResult;
}

/*****************************************************************************/
/*! The main function
 *   \return 0 on success                                                    */

/*****************************************************************************/
int main(int argc, char* argv[])
{
  HANDLE hDriver  = NULL;
  HANDLE hChannel = NULL;
  long   lRet     = CIFX_NO_ERROR;
  long   lOldRet  = CIFX_NO_ERROR;

  UNREFERENCED_PARAMETER(argc);
  UNREFERENCED_PARAMETER(argv);

  /* Open the cifX driver */
  lRet = xDriverOpen(&hDriver);
  if(CIFX_NO_ERROR != lRet)
    {
      printf("Error opening driver!\r\n");
      ShowError(lRet);
    }
  else
    {
      lRet = xChannelOpen(hDriver, "cifX0", 0, &hChannel);
      if(CIFX_NO_ERROR != lRet)
        {
          printf("Error opening Channel!\r\n");
          ShowError(lRet);
        }
      else
        {
          printf("\n--- DPV1 Class 2 Read Request PROFIBUS DP Slave 2, Slot 1, Index 73 ---\r\n");

          printf("\n--- Register Application Request ---\r\n");

          if(Register_Application(hChannel) != 0)
            {
              printf("Error registering application\r\n");
            }
          else
            {
              printf("\n--- DPV1 Class 2 Initiate Request PROFIBUS DP Slave 2 ---\r\n");

              if(DPV1Class2_Initiate(hChannel) != 0)
                {
                  printf("Error initiating connection\r\n");
                }
              else
                {
                  printf("\n--- DPV1 Class 2 Read Request PROFIBUS DP Slave 2 ---\r\n");

                  if(DPV1Class2_Read(hChannel) != 0)
                    {
                      printf("Error reading\r\n");
                    }

                  printf("\n--- DPV1 Class 2 Abort Request PROFIBUS DP Slave 2 ---\r\n");

                  if(DPV1Class2_Abort(hChannel) != 0)
                    {
                      printf("Error aborting\r\n");
                    }

          Purge(hChannel);
        }
            }

      if(Unregister_Application(hChannel) != 0)
        {
          printf("Error unregistering application\r\n");
        }

          /* Close the communication channel */
          xChannelClose(hChannel);
        }
      /* Close the cifX driver */
      xDriverClose(hDriver);
    }
  return 0;
}

Et la trace qui nous montre que c’est tombé en marche !

On lit bien la version du logiciel : Software revision : 01.05.00

H:\Steve\GNAT\ENDRESS\C05\exe\DPV1C2_main

--- DPV1 Class 2 Read Request PROFIBUS DP Slave 2, Slot 1, Index 73 ---


--- Register Application Request ---

Register Request sent...

Register Request confirmation received.


--- DPV1 Class 2 Initiate Request PROFIBUS DP Slave 2 ---

Initiate Request sent...

Initiate Request confirmation received.


--- DPV1 Class 2 Read Request PROFIBUS DP Slave 2 ---

Read Request sent...

Read Request confirmation received.

Software revision : 01.05.00        


--- DPV1 Class 2 Abort Request PROFIBUS DP Slave 2 ---

Abort Request sent...

Abort Request confirmation received.

Packet received :

ulCmd      = 0x00004428

ulDest     = 0x00000000

ulSrc      = 0x80169C80

ulDestId   = 0xA009A021

ulSrcId    = 0x00000000

Closed Indication received : tRecvPacket->tHead.ulSta = 0x00000000

Closed Response sent...

Error: 0x800C0019, <No packet available>

Error: 0x800C0019, <No packet available>

Unregister Request sent...

Unregister Request confirmation received.

Cordialement,
Stéphane

cifX : FDT/DTM – Un exemple intéressant

Bonjour,

SYCON.net est l’outil de configuration des cartes Hilscher cifX pour tous les bus de terrain classiques ou Ethernet Temps Réel.

C’est aussi l’outil permettant de configurer tous les produits Hilscher de la nouvelle génération comme les modules (comX, netJACK) et les passerelles (netTAP, netBRICK).

Bien sûr, l’une des raisons permettant cette versatilité est que ces équipements partagent le même système sur puce, le netX, le même OS, rcX, les mêmes piles de protocoles.

Une autre raison proéminente est que SYCON.net est basé sur la technologie FDT/DTM, une technologie orientée composant spécifiée par le FDT Group, une organisation de fabricants d’équipements travaillant à l’interopérabilité entre équipements de différents fabricants.

Ainsi, un outil de configuration d’un fabricant peut utiliser un composant permettant la configuration d’un équipement d’un autre fabricant, un peu comme les fichiers GSD de PROFIBUS ou EDS de CANopen permettent d’intégrer des esclaves divers dans un réseau, mais avec bien plus de possibilités.

J’avais envie de tester cette technologie et j’ai pu récupérer des équipements Endress + Hauser pour équiper notre laboratoire. Merci, merci mes amis !

En plus on me les a fournis avec un convertisseur PROFIBUS DP/PA de chez Pepperl + Fuchs, sinon ça m’aurait fait faute.

J’ai donc constitué une petite maquette avec un superbe instrument de mesure de niveau en technologie radar, un Micropilot M FMR244, le convertisseur DP/PA et une carte PROFIBUS Hilscher cifX-50-PB.

Après câblage et configuration à vue de nez je connais la distance du prochain mur : 73.4%…

La documentation est épaisse, l’on y apprend que l’instrument peut être configuré et paramétré en utilisant les services PROFIBUS DP V1. Je me frotte les mains en pensant à toutes les expériences que je vais pouvoir mener avec cet appareil.

Certains outils de configuration ne sont pas basés sur la technologie FDT/DTM et E+H fournit donc un fichier GSD pour ses équipements. Il est tout à fait possible de configurer la carte cifX 50-PB avec ce GSD, comme avec n’importe quel esclave PROFIBUS DP. On récupère le GSD sur le site E+H que l’on importe dans SYCON.net, on l’insère dans la configuration et on choisit les modules qui vont bien pour l’application. Pas de problème, ça juste marche.

Mais il y a mieux. Endress + Hauser est membre, comme Hilscher, du FDT Group. On trouve un descriptif de la technologie FDT/DTM sur leur site que je trouve intéressant d’indiquer, il est en français :
http://www.fr.endress.com/#products/fdt

On trouve également en cherchant un peu la bibliothèque de DTM qui nous intéresse et le logiciel FieldCare qui permet de configurer d’une part les équipements et de faire de la gestion d’actifs dans sa version évoluée :
http://www.endress.com/corporate#products/dtm-download

Je m’intéresse pour le moment uniquement à la bibliothèque de DTM et je n’installe que ceux de niveaux, ça en fait déjà un certain nombre et mon PC est à l’agonie…

Maintenant, si j’actualise le catalogue des composants dans SYCON.net je retrouve ceux de Endress + Hauser classés selon différents critères.

J’ai bien essayé la reconnaissance automatique du réseau depuis SYCON.net, je n’ai pas obtenu le bon DTM, sans doute un petit souci au niveau de l’identification. Je rapporte à mon service spécialisé FDT/DTM chez Hilscher qui me confirme qu’une nouvelle version arrive normalement début Août. Wait and see…

Après quelques essais infructueux je trouve le bon DTM.

E+H-FMR244DTM-SDN

A noter qu’il existe un profil PA pour la configuration de la carte cifX :

E+H-FMR244DTM-SDN-PA

Après configuration des échanges entre l’appareil et la carte, chargement de la configuration et passage en mode « en ligne » on obtient le menu contextuel suivant :

E+H-FMR244DTM-SDN-OnLine

Ainsi on peut accéder à toutes les fonctions proposées par le DTM comme la configuration en ligne, le diagnostic, les valeurs de mesure ou les états, et d’autres encore.

E+H-FMR244DTM-SDN-OnLineParam

E+H-FMR244DTM-SDN-OnLineValue

E+H-FMR244DTM-SDN-OnLineDiag

Cordialement,
Stéphane

Champignons chez Hilscher France !

Bonjour,

J’aime bien les plantes, j’en ai quelques unes chez moi et quelques autres chez Hilscher France.

Parmi celles-ci j’ai un ficus bicolore qui trône sur mon bureau depuis longtemps maintenant.
Il me fait un peu d’ombre et me rapproche un peu de la nature.

Depuis quelques jours il a des copains d’un genre particulier…

Vous vous demandiez à quoi carbure l’auteur de ces articles, je vous laisse à votre découverte.

Champignons

Si vous les reconnaissez, n’hésitez pas à m’indiquer leur petit nom !

Cordialement,
Stéphane