Archives par mot-clé : cifXSetup

cifX : Mise en œuvre : API – Chargement d’un firmware

Bonjour,

Il est possible de réaliser le chargement du firmware des cartes Hilscher cifX via l’API.

Ainsi, nos clients peuvent par exemple mettre à jour le firmware depuis leur propre application en combinant cette mise à jour avec celle de leur application par intégration dans le programme d’installation.

On peut aussi imaginer que l’ensemble des firmwares disponibles soit stocké dans les dossiers de l’application et que la sélection du firmware se fasse depuis l’interface utilisateur de cette application, un peu à la manière du netX Configuration Tool par exemple.

Donc, en prérequis, le pilote cifX est installé et les répertoires de la carte ne contiennent pas de firmware, ce que l’on peut vérifier avec cifXSetup sous Windows.

Au démarrage, le pilote ne va charger que le programme d’amorce dans la carte. Ce programme offre uniquement le canal système et l’on va utiliser celui-ci pour charger notre firmware.

Rien de compliqué ici, le code source présenté ci-dessous effectue les opérations suivantes :

  • lecture du fichier en mode binaire,
  • chargement du firmware via le canal système,
  • démarrage du firmware.
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include "cifxuser.h"
#include "cifxErrors.h"
#include "rcX_Public.h"

#define IO_WAIT_TIMEOUT     10

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);
  }
}

int get_file_size(FILE *hFile)
{
  if (fseek(hFile, 0L, SEEK_END) != 0)
  {
    return (0);
  }
  return ftell(hFile);
}


BOOLEAN DownloadFirmware( HANDLE hDriver)
{
  //------------------------------
  // Load a file
  //------------------------------
  char* pszFileName = "D:\\SLO\\GNAT\\C03\\cifX\\cifxdps.nxf";
  unsigned char* pabFileData = NULL;

  FILE      *hFile           = NULL;
  int       iFileSize        = 0;
  int       iBytesRead       = 0;
  long      lRet             = CIFX_NO_ERROR;
  BOOLEAN   fDownloadSuccess = FALSE;
  HANDLE    hSysDevice       = NULL;

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

  RCX_CHANNEL_INSTANTIATE_REQ_DATA_T *pChannelInstantiateReqData;

  hFile = fopen(pszFileName, "rb");
  if ( hFile == NULL)
  {
    // Error opening the file
    printf("DownloadFirmware(): File <%s> open error\r\n", pszFileName);
    return FALSE;
  }

  iFileSize = get_file_size(hFile);
  printf("DownloadFirmware(): File size is %i\r\n", iFileSize);
  if ( iFileSize == 0 )
  {
    fclose(hFile);
    return FALSE;
  }

  pabFileData = (unsigned char *)malloc(iFileSize);
  if (pabFileData == NULL)
  {
    printf("DownloadFirmware(): could not malloc\r\n");
  }

  if (fseek(hFile, 0L, SEEK_SET) != 0) {
    printf("DownloadFirmware(): could not rewind\r\n");
    fclose(hFile);
    free(pabFileData);
    return FALSE;
  }

  iBytesRead = fread(pabFileData, (size_t)1, iFileSize, hFile);
  if ( iBytesRead != iFileSize)
  {
    printf("DownloadFirmware(): iBytesRead != iFileSize (%i != %i)\r\n",
           iBytesRead, iFileSize);

    fclose(hFile);
    free(pabFileData);
    return FALSE;
  }

  //------------------------------
  // Download firmware
  //------------------------------

  lRet = xSysdeviceOpen( hDriver, "CifX0", &hSysDevice);
  if(lRet != CIFX_NO_ERROR)
  {
    ShowError( lRet);
  } else
  {
    printf("DownloadFirmware(): downloading file...\r\n");
    lRet = xSysdeviceDownload( hSysDevice, 0, DOWNLOAD_MODE_FIRMWARE,
                              "cifxdps.nxf", pabFileData, iFileSize,
                              NULL, NULL, NULL);
    if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    } else
    {
      /*Start Firmware Request*/
      tSendPacket.tHeader.ulDest  = 0; /*System*/
      tSendPacket.tHeader.ulSrc   = 0;
      tSendPacket.tHeader.ulDestId= 0; /*System*/
      tSendPacket.tHeader.ulSrcId = 0;
      tSendPacket.tHeader.ulLen   = 4;
      tSendPacket.tHeader.ulId    = 1;
      tSendPacket.tHeader.ulState = 0;
      tSendPacket.tHeader.ulCmd   = RCX_CHANNEL_INSTANTIATE_REQ;
      tSendPacket.tHeader.ulExt   = 0;
      tSendPacket.tHeader.ulRout  = 0;

      pChannelInstantiateReqData = (RCX_CHANNEL_INSTANTIATE_REQ_DATA_T *)tSendPacket.abData;
      pChannelInstantiateReqData->ulChannelNo  = 0;

      printf("DownloadFirmware(): Starting firmware...\r\n");
      lRet = xSysdevicePutPacket(hSysDevice, &tSendPacket, 1000);
      if(CIFX_NO_ERROR != lRet)
      {
        ShowError( lRet);
      }
      else
      {
        lRet = xSysdeviceGetPacket(hSysDevice, sizeof(tRecvPacket), &tRecvPacket, 1000);
        if(CIFX_NO_ERROR != lRet)
        {
          ShowError( lRet);
        }
        else
        {
          printf( "Received Packet\n" \
                 "---------------\n" \
                 "Source : 0x%08X\n" \
                 "Dest   : 0x%08X\n" \
                 "Cmd    : 0x%08X\n" \
                 "Len    : 0x%08X\n" \
                 "Id     : 0x%08X\n" \
                 "State  : 0x%08X\n" \
                 "Ext    : 0x%08X\n" \
                 "lRet   : 0x%X\n",
                 tRecvPacket.tHeader.ulSrc,   tRecvPacket.tHeader.ulDest,
                 tRecvPacket.tHeader.ulCmd,   tRecvPacket.tHeader.ulLen,
                 tRecvPacket.tHeader.ulId,
                 tRecvPacket.tHeader.ulState, tRecvPacket.tHeader.ulExt,
                 lRet);

          if((tRecvPacket.tHeader.ulCmd == RCX_CHANNEL_INSTANTIATE_CNF)
             && (tRecvPacket.tHeader.ulState == 0))
          {
            fDownloadSuccess = TRUE;
          }
        }
      }
    }

    printf("DownloadFirmware(): Closing SysDevice\r\n");
    lRet = xSysdeviceClose(hSysDevice);
    if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
  }

  fclose(hFile);
  free(pabFileData);
  return fDownloadSuccess;
}

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

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

  UNREFERENCED_PARAMETER(argc);
  UNREFERENCED_PARAMETER(argv);

  /* Open the cifX driver */
  lRet = xDriverOpen(&hDriver);
  if(CIFX_NO_ERROR != lRet)
  {
    ShowError( lRet);
  } else
  {
    if (DownloadFirmware(hDriver) == TRUE)
    {
      printf("DownloadFirmware(): success\r\n");
    }
    else
    {
      printf("DownloadFirmware(): bullshit\r\n");
    }
    /* Close the cifX driver */
    xDriverClose(hDriver);
  }
  return 0;
}

Bien sûr, il faudra également configurer la carte cifX, soit en chargeant les fichiers de configuration issus des outils fournis, SYCON.net ou netX Configuration Tool, ou par programme avec les fonctions de l’API cifX, comme expliqué ici par exemple.

N’hésitez pas à nous solliciter si besoin.

Cordialement,
Stéphane

cifX : Mise en œuvre : API – Configuration PROFIBUS DP Esclave

Bonjour,

Nous avons introduit l’API Hilscher cifX ici et testé quelques fonctions en se servant des cartes cifX configurées avec « netX Configuration Tool » en Modbus TCP Serveur ou en PROFIBUS DP Esclave.

Comme vous suivez ce fil depuis le début, vous savez qu’il est également possible de configurer les cartes cifX, les comX et les netJACK de même, par programme. Bien sûr, c’est plus simple pour les versions esclaves que pour les versions maitres.

Pourquoi devrait-on configurer les cartes par programme alors que Hilscher fournit les logiciels pour le faire ?
Vous avez sans doute vos propres raisons mais je vais en donner une pour ce qui suit.

Votre application nécessite donc une connexion PROFIBUS DP Esclave car votre superbe machine doit s’intégrer dans une ligne de production pilotée par un automate de ligne et cet automate de ligne est Maitre PROFIBUS DP.

Votre client va donc devoir intégrer votre équipement dans son réseau PROFIBUS DP et vous devez pour cela lui fournir d’une part un fichier GSD de votre équipement et d’autre part la configuration que vous avez réalisée pour celui-ci, adresse PROFIBUS, modules d’E/S, options…

Mais il est possible que votre produit ne dispose pas de roues codeuses pour l’adresse, c’est le cas de certaines cifX, ou que des options sélectionnées sur l’IHM de votre équipement induisent une modification des données d’E/S échangées et donc des modules nécessaires.

Dans un cas comme dans l’autre, vous avez le choix d’effectuer cette adaptation avec le « netX Configuration Tool » ou de le faire par programme.

Si c’est à votre client que revient la tâche de réaliser ces modifications il faut qu’il se forme à l’utilisation d’un outil pour ne l’utiliser que très rarement.
Alors que quelques champs de configuration au niveau de l’IHM lui permettraient de réaliser cette configuration très simplement et sans installer l’outil.

Pour réaliser cette configuration par programme il est nécessaire d’utiliser la messagerie Hilscher.

  • Dans netX Dual-Port Memory Interface (DPM) celle-ci est décrite en détail ; on y apprend qu’il existe une boite à lettres pour l’envoi et une pour la réception de messages dont le contenu est constitué d’un en-tête commun et d’une cohorte de données propres à chaque commande. Il existe ainsi des messages indépendants des piles de protocoles et documentés dans ce même manuel et qui fournissent un grand nombre de services.
  • Dans cifX Device Driver – cifX API : on apprend qu’il existe des fonctions pour envoyer et recevoir ces messages.

Enfin, pour chaque pile de protocole, une documentation spécifie les commandes existantes et leur utilisation. Pour notre exemple du jour, la documentation est celle-ci :
PROFIBUS DP Slave Protocol API
Elle est disponible sur le DVD dans le dossier Documentation :
6. Programming Manuals\english\4. Protocol Application Programming Interface\PROFIBUS DP Slave

Ainsi, il est possible d’utiliser la commande « PROFIBUS_APS_SET_CONFIGURATION_REQ/CNF », en p. 75, afin de fournir à notre pile PROFIBUS DP Esclave les paramètres de configuration. On remarque sans trop d’étonnement que ceux-ci sont ceux que l’on trouve au niveau de l’interface du « netX Configuration Tool ».

Il faut donc :

  • envoyer notre requête « PROFIBUS_APS_SET_CONFIGURATION_REQ »,
  • recevoir notre confirmation « PROFIBUS_APS_SET_CONFIGURATION_CNF »,
  • tester le résultat,
  • et procéder à l’initialisation du canal afin que les nouveaux paramètres soient pris en compte.

Nous supprimons donc les fichiers de configuration à l’aide de cifXSetup, on laisse juste le fichier de firmware.

Nous reprenons notre code simplissime de la veille.

Et l’on crée une fonction dont le rôle est de remplir notre message de configuration, de l’envoyer, de récupérer la réponse et la tester.

Si cette fonction fournit un résultat positif on initialise le canal et l’on continue notre démonstration.

Voilà le code du jour :

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include "cifxuser.h"
#include "cifxErrors.h"
#include "TLR_Types.h"
#include "ProfibusAps_Public.h"
#include "ProfibusDl_BusParameter.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;

/*****************************************************************************/
/*! Configure PROFIBUS DP Slave
 *   \return 0 on success                                                    */

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

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

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

  PROFIBUS_APS_PACKET_SET_CONFIGURATION_REQ_T    *pPktSetConfReq;
  PROFIBUS_APS_PACKET_SET_CONFIGURATION_CNF_T    *pPktSetConfCnf;

  pPktSetConfReq = (PROFIBUS_APS_PACKET_SET_CONFIGURATION_REQ_T *)&tSendPacket;

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

  pPktSetConfReq->tData.ulSystemFlags   =    0;   /* Auto start */
  pPktSetConfReq->tData.ulWdgTime       = 1000;

  pPktSetConfReq->tData.usIdentNumber   = 0x0B69; /* cifX Id */
  pPktSetConfReq->tData.bBusAddr        =      2; /* Station adress */
  pPktSetConfReq->tData.bBaudRate       = PROFIBUS_DL_DATA_RATE_AUTO;

  pPktSetConfReq->tData.bFlags          =  WRMSTRT_FLG_DPV1_ENABLE
                                          |WRMSTRT_FLG_SYNC_SUPP
                                          |WRMSTRT_FLG_FREEZE_SUPP
                                          |WRMSTRT_FLG_FAILSAFE_SUPP
                                      /*  |WRMSTRT_FLG_AUTOCONFIG */
                                          |WRMSTRT_FLG_NO_ADDR_CHANGE;

  pPktSetConfReq->tData.bRes[0]         = 0;
  pPktSetConfReq->tData.bRes[1]         = 0;

  pPktSetConfReq->tData.bCfgLen         = 4;
  pPktSetConfReq->tHead.ulLen           = 16 + pPktSetConfReq->tData.bCfgLen;
  /* 32 Word Out */
  pPktSetConfReq->tData.abCfgData[0]    = 0x80;
  pPktSetConfReq->tData.abCfgData[1]    = 0xDF;
  /* 64 Word In */
  pPktSetConfReq->tData.abCfgData[2]    = 0x40;
  pPktSetConfReq->tData.abCfgData[3]    = 0xFF;

  lRet = xChannelPutPacket(hChannel, &tSendPacket, 1000);
  if(lRet != CIFX_NO_ERROR)
  {
    ShowError( lRet);
  }
  else
  {
    printf("DPS Configuration Request sent...\r\n");
    lRet = xChannelGetPacket(hChannel, sizeof(tRecvPacket), &tRecvPacket, 1000);
    if(lRet != CIFX_NO_ERROR)
    {
      ShowError( lRet);
    }
    else
    {
      pPktSetConfCnf = (PROFIBUS_APS_PACKET_SET_CONFIGURATION_CNF_T *)&tRecvPacket;
      if(pPktSetConfCnf->tHead.ulCmd != PROFIBUS_APS_SET_CONFIGURATION_CNF)
      {
        printf("Wrong CNF received : pPktSetConfCnf->tHead.ulCmd = 0x%08X\r\n",
               pPktSetConfCnf->tHead.ulCmd);
      }
      else if(pPktSetConfCnf->tHead.ulSta != 0)
      {
        printf("Wrong CNF received : pPktSetConfCnf->tHead.ulSta = 0x%08X\r\n",
               pPktSetConfCnf->tHead.ulSta);
      }
      else
      {
        printf("Configuration confirmation received.\r\n");
        iResult = 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--- Configuration ---\r\n");

      if(DPS_SetConfig(hChannel) == 0)
      {
        printf("\n--- Channel Init ---\r\n");
        lRet = xChannelReset( hChannel, CIFX_CHANNELINIT, 5000);
        if(lRet != CIFX_NO_ERROR)
        {
          ShowError( lRet);
        }else
        {
          /* Read and write I/O data (32Bytes) */
          unsigned char abSendData[32] = {0};
          unsigned char abRecvData[32] = {0};

          printf("\n--- I/O Data exchange ---\r\n");
          /* Do I/O Data exchange until a key is hit */
          printf("Hit any key to stop the process!\r\n");
          while(!kbhit())
          {
            lRet = xChannelIORead(hChannel, 0, 0, sizeof(abRecvData), abRecvData, IO_WAIT_TIMEOUT);
            if(CIFX_NO_ERROR != lRet)
            {
              if(lOldRet != lRet)
              {
                printf("Error reading IO Data area!\r\n");
                ShowError(lRet);
              }
            }else
            {
              memcpy(abSendData, abRecvData, sizeof(abSendData));

              lRet = xChannelIOWrite(hChannel, 0, 0, sizeof(abSendData), abSendData, IO_WAIT_TIMEOUT);
              if(CIFX_NO_ERROR != lRet)
              {
                if(lOldRet != lRet)
                {
                  printf("Error writing to IO Data area!\r\n");
                  ShowError(lRet);
                }
              }
            }
            lOldRet = lRet;
          }
        }
      }
      /* Close the communication channel */
      xChannelClose(hChannel);
    }
    /* Close the cifX driver */
    xDriverClose(hDriver);
  }
  return 0;
}

Avec un peu de chance, ça tombe en marche.
N’hésitez pas à nous solliciter si besoin.
Si vous souhaitez le projet dans son intégralité, faites m’en la demande et je vous le transmettrais bien volontiers.

Cordialement,
Stéphane

cifX : Mise en œuvre : PROFIBUS DP Esclave

Bonjour,

Continuons notre série sur la mise en œuvre des cartes Hilscher cifX.

Les généralités, c’est fait.

La mise en œuvre de Modbus TCP Serveur aussi.

Aujourd’hui, un grand classique, nous allons procéder à la mise en œuvre de PROFIBUS DP dans sa version Esclave.

On se procure donc une carte Hilscher cifX 50-DP, celle qui va bien pour ma machine avec un port PCI.

Cette carte sait aussi bien être configurée en Maitre comme en Esclave, selon qu’elle dispose d’une licence Maitre ou pas. Dans la mienne il y a une licence Maitre, ce qui ne m’empêche pas de l’utiliser avec un firmware Esclave. Pour sûr, ça fait riche. Cette licence peut être achetée à posteriori et être affectée à la carte avec les outils fournis. Vous pouvez donc vous constituer un stock de cartes sans licence et approvisionner celle-ci à la demande si vous ne souhaitez pas conserver deux références.

Pour ce qui est de la configuration, je vais tâcher de faire plus concis que précédemment puisque j’ai déjà présenté les outils « cifXSetup » et « netX Configuration Tool ».

« netX Configuration Tool » fera très bien l’affaire pour configurer cette carte PROFIBUS DP Esclave.

Comme cette carte dispose d’une interface PROFIBUS DP, l’outil ne propose que les firmwares PROFIBUS DP Esclave et MPI/PROFIBUS, ce dernier firmware permettant la lecture / écriture des données d’un automate Siemens S7.

On choisit donc le firmware PROFIBUS DP Esclave et l’on configure les quelques paramètres nécessaires. Par rapport à la configuration par défaut, je n’ai modifié que les modules d’entrée et sortie. Il faut bien noter que les termes IN et OUT sont définis du point de vue du Maitre.

Les modules IN sont les sorties de l’application qui pilote la carte et les entrées de l’automate Maitre.
Bien évidemment, c’est le contraire pour les modules OUT.

Si l’interface graphique ne permet pas de réaliser la configuration souhaitée, par exemple si vous souhaitez configurer davantage de modules d’I/O que les quatres possibles, vous pouvez cocher l’option « Manual input » et saisir la configuration en Hexadécimal dans le champ « Configuration Data ».

Lorsque l’on en a terminé avec les réglages, on « Apply » les modifications et l’on répond « Yes » à la question posée.

Si ça se passe comme d’habitude, dans la vue de diagnostic on se retrouve dans cet état.

C’est normal, je n’ai pas encore configuré le Maitre, ce que je vais tenter ce tantôt.

Je configure donc ma vaillante CPU Siemens S7 315-2DP / 6ES7 315-2AG10-0AB0 en important le fichier GSD de la carte cifX DP/DPS et en configurant celle-ci à l’identique de ce qui a été fait au-dessus.

On transfère la configuration dans l’automate et avec un peu de chance ça tombe en marche…

Ça le fait !
Et si je joue avec « IO Monitor »…

Je pilote mes sorties et je visualise mes entrées.

Voilà, voilà… C’est Vendredi et je suis d’humeur badine. 😉

On ferme notre « netX Configuration Tool » et l’on s’aperçoit que la communication continue de fonctionner.

Encore un petit effort, je vais vous présenter l’application « cifXTest », une application de test pour les cartes cifX donc et qui s’installe en même temps que le pilote et « cifXSetup », et qui est accessible aussi depuis le panneau de configuration.

Cette application « cifXTest » est également disponible sous forme de code source sur le DVD, dans les exemples fournis.

Avec cette application, il est possible de tester toute l’interface applicative des cartes cifX sans écrire une ligne de code.

Dès que ça devient plus sérieux, une application de test en mode console, fournie sous forme de code source, permet de même de tester cette API.

On exécute donc « cifXTest » et l’on ouvre le canal 0 de notre carte.

Notre canal 0 est ouvert et l’on va utiliser l’accès aux données cycliques, l’image procédé.

Merci pour votre attention.

Cordialement,
Stéphane

cifX : Mise en œuvre – Modbus TCP Serveur

Bonjour,

Mon précédent article présentait la mise en œuvre des cartes Hilscher cifX de manière générale.

Dans celui-ci nous allons détailler la configuration d’une carte cifX au format PCI, disposant de deux ports Ethernet, la cifX 50-RE, avec un firmware Modbus TCP, ce firmware pouvant être configuré en Client ou en Serveur, (voire les deux simultanément mais c’est plus sportif ;-)).

J’ai déjà évoqué l’application cifXSetup qui est installée en même temps que le pilote cifX et qui est accessible depuis le panneau de configuration de Windows®. Lorsque l’on exécute cette application sans avoir procédé à une quelconque configuration, on trouve une carte non configurée évidemment :

On y voit notamment le numéro de produit et le numéro de série. Comme ma carte est un peu ancienne, elle ne dispose pas de la roue codeuse pour régler le numéro d’emplacement (ou slot). Comme il n’y en a qu’une dans cette machine de test elle est identifiée « cifX0 ».

L’on voit également qu’elle dispose de deux ports Ethernet et qu’aucun fichier de firmware ni de configuration n’est affecté à cette carte pour l’instant.

Comme on souhaite configurer la carte en tant que serveur Modbus TCP, il est possible de le faire avec « netX Configuration Tool », l’outil dédié à la configuration des versions esclaves.

L’outil détecte la carte cifX qui a le numéro de série 20951, qui ne dispose pas de firmware et encore moins de configuration. Comme la carte est équipée de ports Ethernet, l’outil ne propose que les protocoles Ethernet / Ethernet Temps Réel que sont PROFINET, EtherCAT, Ethernet/IP, Modbus TCP, Sercos III, POWERLINK et VARAN.

En cliquant sur le bouton Modbus TCP, on obtient la vue de configuration Modbus TCP comme de bien entendu, avec une configuration par défaut :

On y apporte les modifications que l’on souhaite, ici j’ai remplacé l’affectation des paramètres par serveur DHCP par une affectation statique et j’ai coché l’option « Map FC1 and FC3 ».

Voilà, voilà, ma configuration est terminée et je télécharge et le firmware et la configuration en cliquant sur « Apply ».

Le chargement s’est bien passé, c’est le cas en général, et le message dans la barre de status l’indique.

J’ai branché le câble Ethernet et la communication a démarré toute seule (l’option « Bus Startup » est sur « Automatic ») et l’on attend la connexion du Client Modbus TCP.

Comme client, je vais utiliser l’utilitaire « Modbus Poll » qui ne va pas mal :

Bien sûr, cela fonctionne aussi avec n’importe quel autre client Modbus TCP.
S’il y a de la demande, je veux bien vous établir un exemple avec un automate M340 de Schneider Electric.

Je définis donc une connexion avec ma carte cifX.

Et la communication démarre avec la FC3 qui est la fonction de lecture de registres définie par défaut.
On voit le compteur s’incrémenter, c’est plutôt bon signe…

ModbusPoll04

Côté « netX Configuration Tool », ça s’anime :

On peut jouer avec nos entrées et sorties depuis la vue « IO Monitor » :

Cette vue nous permet d’affecter des valeurs à nos sorties – qui sont donc les entrées pour Modbus Poll – et de visualiser l’état de nos entrées – les sorties de Modbus Poll.

Un, deux et trois :

Ça marche dans ce sens !

Je lis donc avec la fonction FC3 les entrées, ce qui est vrai car j’ai coché l’option « Map FC1 and FC3 » lors de la configuration. Sinon, je relirais les sorties, ce qui peut présenter un avantage s’il y a plusieurs clients Modbus TCP qui pilotent les sorties.

Je peux modifier mes définitions de fonctions pour les lectures / écritures :

Fonction FC3 ou Lecture de multiples registres internes :

Ou fonction FC4, Lecture de multiples registres d’entrées :

Fonction FC16 ou Écriture de multiples registres internes :

Testons l’écriture…

Onze, douze, treize… Envoi !

Et pendant ce temps sur « netX Configuration Tool » :

Donc cela fonctionne, mais personne n’en doutait.

Si l’on exécute à nouveau cifXSetup, on voit que maintenant les espaces firmware et configuration sont renseignés.

On trouve dans l’arborescence les dossiers et fichiers destinés au pilote cifX :

Et dans la base de registres les clés sont bien présentes :

Cordialement,
Stéphane

cifX : Mise en œuvre

Bonjour,

Dans l’article cifX, comX, netJACK : une petite synthèse j’ai décrit succinctement tout ce qui était commun aux différentes interfaces de communication que sont les cifX, les comX et les netJACK.

Nous allons voir maintenant la mise en œuvre d’une carte cifX, ce qui, moyennant des cartes d’adaptation disponibles pour les développeurs, est intégralement transposable pour les comX et netJACK.

La carte qui va nous servir de fil conducteur pour cet article est la cifX 50-RE, une carte au format PCI équipée de deux connecteurs RJ45 et qui peut donc recevoir tous les firmwares gérant les protocoles sur Ethernet / Ethernet Temps Réel, en version Maitre ou en version Esclave car la carte dont je dispose possède une licence Maitre.

Donc, vous avez reçu votre carte Hilscher dans son emballage antistatique et il y a un mini DVD avec. C’est bientôt Noël…

Comme Santa Klaus n’est pas encore passé, vous pouvez tout de même vous procurer ce DVD ici.

Vous laissez s’il vous plait la carte dans son emballage et vous insérez le DVD dans votre PC préféré.
On lit la documentation d’abord ! 😉

Il y a donc un dossier Documentation.

On y trouve :

  • 0. Installation and Overview : un guide qui présente grosso modo la même chose que ce que vous lisez, en Anglais…
  • 1. cifX Manuals\english : la documentation relative au matériel.
    Pour le cas présent, nous pouvons ouvrir avec profit le document « PC Cards CIFX 50 50E 70E 100EH UM 35 EN.pdf ».
    Outre les données techniques, les schémas des cartes, les schémas des interfaces électriques, etc… on trouve également un chapitre concernant l’installation des logiciels et pilotes.
  • 5. Device Driver Manuals\english : il y a lieu d’installer le pilote avant de mettre la carte dans le PC.
    Cela se fait le plus simplement du monde soit depuis le menu du Splash Screen, soit en démarrant l’installeur « Driver\cifX Device Driver\cifX Device Driver Setup.exe ».
    Le document « cifX Device Driver OI 07 EN.pdf » précise les versions de Windows supportées : Windows® 2000, Windows® XP, Windows® Vista and Windows® 7, en version 32 ou 64 bit.
    Il indique également la procédure à suivre selon le système d’exploitation. C’est un cliquodrome, je ne détaillerai pas.
    Comme vous n’avez pas suivi mes recommandations et avez installé le matériel avant le pilote, ce document vous indique comment vous en sortir quand même !
    Enfin, il évoque l’outil cifXSetup qui s’installe en même temps que le pilote et qui est accessible depuis le panneau de configuration. Cet outil permet de sélectionner un firmware et une configuration élaborée par ailleurs. Nous reviendrons sur ce point plus tard.
  • 4. Configuration Manuals\english : la documentation relative à la configuration de la carte. Selon le cas, on utilisera pour les cartes esclaves le « netX Configuration Tool » ou, pour les cartes maitres ou esclaves, l’outil universel qu’est « SYCON.net ».

Comme vous avez lu la documentation, vous savez qu’il existe deux méthodes d’identification des cartes au niveau du pilote, l’une avec le couple numéro de produit / numéro de série, l’autre avec le numéro d’emplacement au moyen de la roue codeuse qui équipe aujourd’hui l’immense majorité des cartes, et vous avez choisi la méthode qui vous convient et qui est disponible, celle de la roue codeuse facilitant la maintenance au cas où votre carte soit frappée par la foudre.

En fait, la première méthode est historique, c’était avant l’apparition de la roue codeuse sur les dernières versions matérielles. Dans ce cas, le remplacement d’une carte comportait un volet configuration du pilote car il était nécessaire d’importer pour la nouvelle carte firmware et configuration de l’ancienne, opération triviale pour un développeur, complexe pour un agent de maintenance qui rencontre la chose. Maintenant, il suffit de positionner la roue codeuse de la nouvelle carte comme sur celle détériorée et de remplacer celle-ci.

Je suis certain que vous avez déjà installé le pilote, arrêté le PC, installé la carte et redémarré le PC.

Et selon le cas, vous avez installé « netX Configuration Tool » ou « SYCON.net ». Je ne vous ferai pas l’offense de vous expliquer leur installation dans le détail.

La configuration de votre carte peut maintenant commencer.

Pour les cartes esclaves, une méthode de configuration préhistorique est encore intégrée dans le cifXSetup, la méthode des paramètres de « Warmstart ». Ce n’est plus la méthode préconisée mais elle est toujours là.

On lui préférera les outils consacrés « netX Configuration Tool » ou « SYCON.net ».

Lorsque vous utilisez cifXSetup, celui-ci va créer les répertoires nécessaires dans le répertoire où a été installé le pilote, y déposer vos fichiers de firmware et de configuration et enregistrer vos réglages dans la base de registres de Windows®.

Au démarrage, le pilote va aller chercher dans la base de registres vos paramètres et configurera la carte avec le firmware et la configuration ad hoc. Cela n’est vrai que pour les produits dépourvus de mémoire Flash. Cela ne s’applique pas par exemple aux comX et aux netJACKS.

Lorsque vous utilisez « netX Configuration Tool » ou « SYCON.net », il n’y a pas lieu d’utiliser cifXSetup car les outils permettent de sélectionner et télécharger le firmware et de créer et télécharger la configuration. Bien entendu, ils enregistrent également leurs modifications dans la base de registres.

Alors à quoi bon utiliser cifXSetup ?
Il y a encore quelques raisons :

  • Vous faites des essais en laboratoire et vous souhaitez changer de firmware ; par exemple, vous avez essayé votre carte avec Modbus TCP Serveur et vous voulez maintenant procéder de même avec PROFINET IO IRT Device.
    Avec cifXSetup, vous effacez firmware et configuration de la carte et vous recommencez une nouvelle configuration avec « netX Configuration Tool » ou « SYCON.net ». En fait, les outils sont un peu bridés de façon à éviter une manipulation erronée. Il est quand même possible d’en faire !
  • Vous avez 50 machines à configurer. Les outils sont installés sur une machine de test, vous générez une configuration sur celle-ci et pouvez récupérer les fichiers firmware et configuration sur votre clé USB ou via le réseau pour y installer sur les 50 machines avec cifXSetup qui de toute façon est installé avec le pilote.
  • Enfin, il est possible de configurer les cartes par programme et, pour les cartes esclaves, c’est la méthode que je préconise personnellement car elle est très souple et ne requiert pas l’installation d’outil.
    Vous installez votre firmware avec cifXSetup, sans fichier de configuration et votre application configure la pile de protocole en envoyant un message de configuration. Ainsi, vous pouvez par exemple offrir à l’utilisateur la possibilité d’adapter l’adresse de l’esclave depuis votre IHM sans qu’il ait besoin d’installer et d’apprendre à utiliser un outil dont il ne va se servir qu’une fois.

N’hésitez pas à nous solliciter si besoin.
Notez bien que nous sommes centre de formation agréé et pouvons vous dispenser une formation adaptée à votre besoin qui pourra être prise en charge dans le cadre du 1% formation.

Cordialement,
Stéphane