PIC32MZ MODBUS TCP communication

[Jojo2504]

Bonjour,

Je suis à la recherche d'un tuto pour créer une communication modbus TCP simple entre mon PC et la carte STARTER KIT. Avec les fonctions de transmission ou bien de réception du maître/esclave.

J'utilise MPLABX IDE V3.55 avec harmony et compilateur XC32 V1.40.

Une fois que j'ai fais la configuration de l'harmony en TCP je ne sais pas comment écouter / transmettre ou même recevoir sur le port Ethernet...

Merci de votre aide, je suis nouveau en programmation surtout sur pic32mz.

Cordialement,

Jojo
-----

[JPL]

J'ai déplacé la demande parce qu'elle est peut-être mieux ici.

[RISC]

Salut,
tu n'as pas précisé quel modèle de PIC32MZ tu utilises. Il est recommandé d'utiliser le PIC32MZ...EF (pas la version PIC32MZ...EC).
Je te conseille d'utiliser Harmony v2.03b et le compilateur XC32 v1.42
Concernant Harmony, il est plus facile de partir des exemples tous faits qui se trouve dans le répertoire APPS.
Tu trouveras des exemples de communication à base de socket en TCP ou en UDP
a+

[Jojo2504]

J'utilise un PIC32MZ2048ECH144 ... L'entreprise a déjà acheté les pic pour la production du coup je n'ai pas le choix de composant sinon je n'aurai pas pris un pic.

Je vais télécharger le dernier harmony qui est sortie pour voir si il y a plus d'exemple parce que dans le miens il n'y a aucun exemple de communication modbus tcp seulement tcp client server!

Si quelqu'un à déjà réalisé ce genre de projet je serai intéresser pour plus d'explication.

Merci

Joris

[A voir en vidéo sur Futura]

[Bluedeep]

il n'y a aucun exemple de communication modbus tcp seulement tcp client server

Normal, Modbus TCP est toujours en mode client-serveur.

[Jojo2504]

Oui je viens de comprendre je cherchai en mode maître esclave mais client - server fonctionne aussi c'est seulement les mots qui changent !!

Du coup j'ai pris la demo berkeley_tcp_server qui utilise les sockets pour ouvrir une com pour écouter sur le port envoyer une requête etc.. mon problème est que je n'arrive pas à envoyer un caractère...

Je pense qu'il faut utiliser cette fonction mais je ne suis pas sûre: De plus quand j'avais essayé j'ai eu un problème avec le pointeur *buf car je mettais mon mot dans un tableaux qui devait être dans la case mémoire du buf et puisque je sais qu'on peut faire des tableaux de pointeurs mais pas des pointeurs de tableaux et bien je suis bloquer ... si quelqu'un peut m'aider svp

int send( SOCKET s, const char* buf, int len, int flags )
{
return sendto(s, buf, len, flags, NULL, 0);
}

Merci,
Jojo

PS: je pense que mon problème est plus claire maintenant

[Bluedeep]

Oui je viens de comprendre je cherchai en mode maître esclave

Maître esclave ne fonctionne pas avec Modbus TCP, uniquement en RTU(qui en revanche ne peut pas fonctionner en client-serveur).

c'est seulement les mots qui changent !!

Pas du tout, non. Maître-esclave c'est le mode exactement inverse de client serveur : en mode maître-esclave, le client est passif et le serveur "poll" les clients.

[Jojo2504]

D'accord merci beaucoup pour ta réponse cela m'éclaircie dans les différentes communications.

Si je veux réaliser une communication entre un pic et le pc et envoyer des infos du pc vers le pic quelle est le meilleur moyen de faire la communication ? RTU ou modbus TCP ?

Ou les 2 sont capables de réaliser la communication et l'envoie des données ?

Pour le moment je suis partit pour réaliser une communication modbus TCP je ne sais pas si c'est un bon choix.

[Bluedeep]

D'accord merci beaucoup pour ta réponse cela m'éclaircie dans les différentes communications.

Si je veux réaliser une communication entre un pic et le pc et envoyer des infos du pc vers le pic quelle est le meilleur moyen de faire la communication ? RTU ou modbus TCP ?

Aucune idée. Je ne connais pas Modbus. Mais pour moi ça dépend du média physique que tu as choisis.
RTU n'est dispo qu'en RS 232
TCP n'est dispo qu'en ethernet.

[Jojo2504]

Ce sera modbus TCP du coup
merci !

Je continue de chercher je reviens demain ou lundi pour plus d'info ou pour vous annoncer des bonnes nouvelles j'espère !

[Jojo2504]

D'ailleurs j'avais une dernière question !

dans une communication serveur client si je veux envoyer un caractère et l'observer sur hyperterminal faut-il bien connecter le serveur au client et c'est le client qui envoie le caractère souhaité ?
ou au contraire, c'est le serveur qui envoie le caractère au client qui le lis ?

[Jack]

Je ne vois pas comment tu pourrais observer quelques chose dans hyperterminal. Il faut que tu utilises des logiciels d'émulation modbus.

Tu peux toujours essayer avec cette version de demo pour commencer:

[Johnplayer]

Juste pour info, le modbus TCP ce n'est rien d'autre qu'une trame modbus RTU (sans le CRC16) encapsulée dans une trame TCP. Le CRC de la trame RTU n'est plus utile puisque le protocole TCP se charge de tester la validité du paquet.

On fonctionne en mode maitre/esclave en RTU (serial) et sur un système serveur/client en TCP donc le principe reste le même, 1 maître à la fois communicant en unicast ou en broadcast. La grosse différence réside dans la gestion de la collision en modbus RTU où un maitre doit attendre un silence d'au moins 3,5 chars avant de pouvoir prendre la main sur le bus.

Le modbus TCP a aussi une particularité généralement inutilisé : celle de pouvoir avoir 247 esclaves avec la même adresse IP. en effet, la trame RTU possède l'adresse modbus de l'esclave donc si l'adresse IP correspond l'esclave décode la trame est regarde l'adresse modbus. Les adresses IP étant généralement unique, l'adresse modbus d'un périphérique cablé en Ethernet sera 1 par défaut.

[RISC]

Salut,

Au niveau HW, si tu utilises le PIC32MZ2048ECH144, il faut absolument utiliser un oscillateur externe (TCXO) et pas un quartz car il y a un bug au niveau de l'oscillateur (voir erratasheet).
Il y a plein d'exemples de communication avec des sockets TCP. Je te recommande de partir des exemples tous faits.
As-tu un PIC32MZ EC starter kit ? cela pourrait te servir de référence. Commence par faire fonctionner les exemples sans modifier quoi que ce soit pour être sûr d'avoir une plateforme hardware stable.
Ensuite, je te conseille d'utiliser le service de console en ligne (UART ou USB). C'est très puissant car tu peux voir comment la stack fonctionne dynamiquement.

A+

[Jojo2504]

Au niveau HW, si tu utilises le PIC32MZ2048ECH144, il faut absolument utiliser un oscillateur externe (TCXO) et pas un quartz car il y a un bug au niveau de l'oscillateur

Merci je ne savais pas !

Il y a plein d'exemples de communication avec des sockets TCP. Je te recommande de partir des exemples tous faits.
As-tu un PIC32MZ EC starter kit ? cela pourrait te servir de référence.

Oui, j'ai la carte d'évaluation starter kit et j'ai déjà compilé les programmes d'exemples mais je ne sais pas comment envoyer une trame qui va activer la led de ma carte starter kit par exemple ou le bouton poussoir.

Je ne vois pas comment tu pourrais observer quelques chose dans hyperterminal. Il faut que tu utilises des logiciels d'émulation modbus.

Euh j'ai pas tout compris aprés je pensais que hyperterminal ne faisait pas que du série ! avec wireshark j'observe des trames mais je n'arrive pas à afficher la data.

Merci à tous,

Jojo

[Jack]

Euh j'ai pas tout compris aprés je pensais que hyperterminal ne faisait pas que du série ! avec wireshark j'observe des trames mais je n'arrive pas à afficher la data

Je ne vois pas comment tu vas pouvoir capturer du traffic entre 2 dispositifs avec hyperterminal.
Comme son nom l'évoque, hyperterminal est un émulateur de terminal, sous-entendu en MODE TEXTE. Tu pourrais éventuellement communiquer en MODBUS ASCII, mais ce n'est vraisemblablement pas le cas ici.

Bref, tu ne pourras pas intercepter le traffic entre maitre et esclave ou client et serveur, et tu ne pourras pas visualiser les octets au cas ou ton terminal jouerait un des rôles cités précédemment.

[Jojo2504]

D'accord merci

Le lien que tu as mis tout à l'heure c'est un émulateur modbus ? sinon tu en connais un ?

[Jack]

Le lien que tu as mis tout à l'heure c'est un émulateur modbus ?

???

C'est écrit sur le site: modbus slave simulator et modbus master simulator.
Je l'utilise de temps en temps et ça fonctionne très bien en RTU / ASCII / TCP

[paulfjujo]

bonjour,

... je pensais que hyperterminal ne faisait pas que du série ! avec wireshark j'observe des trames mais je n'arrive pas à afficher la data.

avec REalterm on peut afficher en Hexadecimal .. au lieu de ascii

[Jojo2504]

J'ai télécharger modbus tools et j'ai lancé mon programme.
Et je n'obtiens rien je ne sais pas ou ce trouve la fonction d'écriture dans le code demo de harmony tcpip_tcp_client_server
Je pense que la data passe par la fonction buffer[MAX_URL_SIZE];

[Jack]

Je rappelle que modbuspoll joue le rôle de maitre (ou client en TCP).

Si tu veux envoyer des données, il faut les écrire dans des registres, donc la fonction modbus write multiple registers. Configure la valeur de F pour cette fonctionnalité.

Il doit y avoir un menu qui te permet de visualiser le trafic

[Jojo2504]

d'accord je regarde ça après manger

[Johnplayer]

Quand j'ai fait mes essais modbus TCP avec node-red, j'avais utilisé modbusPal Il peut émuler 247 esclaves modbus, tu peux créer des sorties (registres 00xxxx) et des holding registers (registres 40xxxx) pour chaque esclave.

[Jojo2504]

oui mais moi j'ai 1 client et 1 serveur du coup j'ai trouvé comment observer le trafic mais je ne sais toujours pas envoyer un caractère !


Je pense avoir trouvé la fonction qui permet l'envoie du message ou du caractère mais je n'ai pas compris le code entièrement:

int sendto( SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen )
{
    struct BSDSocket *socket;
    int size = SOCKET_ERROR;
    IPV4_ADDR remoteIp;
    uint16_t wRemotePort;
    struct sockaddr_in local;
#if defined(TCPIP_STACK_USE_IPV6)
    IPV6_ADDR remoteIp6;
    struct sockaddr_in6 local6;
#endif


    if (s >= BSD_SOCKET_COUNT)
    {
        errno = EBADF;
        return SOCKET_ERROR;
    }

    socket = &BSDSocketArray[s];

    if (socket->bsdState == SKT_CLOSED)
    {
        errno = EBADF;
        return SOCKET_ERROR;
    }

    // Handle special case were 0 return value is okay
    if (len == 0)
    {
        return 0;
    }

    if (socket->SocketType == SOCK_DGRAM) //UDP
    {
        // Decide the destination IP address and port
#if defined(TCPIP_STACK_USE_IPV6)
        if (socket->addressFamily == AF_INET)
        {
#endif
            remoteIp.Val = socket->remoteIP;
#if defined(TCPIP_STACK_USE_IPV6)
        }
        else
        {
            remoteIp6.d[0] = socket->remoteIP;
            remoteIp6.d[1] = socket->remoteIPv6[0];
            remoteIp6.d[2] = socket->remoteIPv6[1];
            remoteIp6.d[3] = socket->remoteIPv6[2];
        }
#endif
        wRemotePort = socket->remotePort;
        if (to)
        {
#if defined(TCPIP_STACK_USE_IPV6)
            if (socket->addressFamily == AF_INET)
            {
#endif
                if ((unsigned int) tolen < sizeof (struct sockaddr_in))
                {
                    errno = EFAULT;
                    return SOCKET_ERROR;
                }
                wRemotePort = ((struct sockaddr_in*) to)->sin_port;
                remoteIp.Val = ((struct sockaddr_in*) to)->sin_addr.s_addr;
#if defined(TCPIP_STACK_USE_IPV6)
            }
            else
            {
                if ((unsigned int) tolen < sizeof (struct sockaddr_in6))
                {
                    errno = EFAULT;
                    return SOCKET_ERROR;
                }
                wRemotePort = ((struct sockaddr_in6*) to)->sin6_port;
                memcpy(remoteIp6.d, ((struct sockaddr_in6*) to)->sin6_addr.in6_u.u6_addr32, sizeof(IPV6_ADDR));
            }
#endif

            // Implicitly bind the socket if it isn't already
            if (socket->bsdState == SKT_CREATED)
            {
#if defined(TCPIP_STACK_USE_IPV6)
                if (socket->addressFamily == AF_INET)
                {
#endif
                    memset(&local, 0, sizeof (local));
                    local.sin_addr.s_addr = IP_ADDR_ANY;
                    if (bind(s, (struct sockaddr*) &local, sizeof (local)) == SOCKET_ERROR)
                        return SOCKET_ERROR;
#if defined(TCPIP_STACK_USE_IPV6)
                }
                else
                {
                    memset(&local6, 0x00, sizeof(local6));
                    if (bind(s, (struct sockaddr*) &local6, sizeof (local6)) == SOCKET_ERROR)
                        return SOCKET_ERROR;
                }
#endif
            }
        }

        UDP_SOCKET_INFO udpSockInfo;
        TCPIP_UDP_SocketInfoGet(socket->SocketID, &udpSockInfo);

#if defined(TCPIP_STACK_USE_IPV6)
        if (socket->addressFamily == AF_INET)
        {
#endif
            if (remoteIp.Val == IP_ADDR_ANY)
            {
                TCPIP_UDP_BcastIPV4AddressSet(socket->SocketID, UDP_BCAST_NETWORK_LIMITED, 0);
            }
            else
            { // Set the remote IP and MAC address if it is different from what we already have stored in the UDP socket
                if (udpSockInfo.remoteIPaddress.v4Add.Val != remoteIp.Val)
                {
                    TCPIP_UDP_DestinationIPAddressSet(socket->SocketID, IP_ADDRESS_TYPE_IPV4, (IP_MULTI_ADDRESS*) & remoteIp.Val);
                }
            }
            // Set the proper remote port
            TCPIP_UDP_DestinationPortSet(socket->SocketID, wRemotePort);
#if defined(TCPIP_STACK_USE_IPV6)
        }
        else
        {
            if ((udpSockInfo.remoteIPaddress.v6Add.d[0] != remoteIp6.d[0]) ||
                (udpSockInfo.remoteIPaddress.v6Add.d[1] != remoteIp6.d[1]) ||
                (udpSockInfo.remoteIPaddress.v6Add.d[2] != remoteIp6.d[2]) ||
                (udpSockInfo.remoteIPaddress.v6Add.d[3] != remoteIp6.d[3]))
            {
                    TCPIP_UDP_DestinationIPAddressSet(socket->SocketID, IP_ADDRESS_TYPE_IPV6, (IP_MULTI_ADDRESS*) & remoteIp6.d);

            }
            // Set the proper remote port
            TCPIP_UDP_DestinationPortSet(socket->SocketID, wRemotePort);
        }
#endif
        // Select the UDP socket and see if we can write to it
        if (TCPIP_UDP_TxPutIsReady(socket->SocketID, len))
        {
            // Write data and send UDP datagram
            size = TCPIP_UDP_ArrayPut(socket->SocketID, (uint8_t*) buf, len);
            TCPIP_UDP_Flush(socket->SocketID);
            return size;
        }
        // just in case there's some old data already in there...
        TCPIP_UDP_Flush(socket->SocketID);
    }
    else if (socket->SocketType == SOCK_STREAM) //TCP will only send to the already established socket.
    {
        if (socket->bsdState != SKT_EST)
        {
            errno = ENOTCONN;
            return SOCKET_ERROR;
        }

        if (HandlePossibleTCPDisconnection(s))
        {
            errno = ECONNRESET;
            return SOCKET_ERROR;
        }

        // Write data to the socket. If one or more bytes were written, then
        // return this value.  Otherwise, fail and return SOCKET_ERROR.
        size = TCPIP_TCP_ArrayPut(socket->SocketID, (uint8_t*) buf, len);
        if (size)
        {
            return size;
        }
    }
    errno = EWOULDBLOCK;
    return SOCKET_ERROR;
}

[Jojo2504]

Par contre le fait de créer des sorties pourra me servir plus tard pour tester mon code sur les différentes fonctions qu'il faudra que je réalise

[Johnplayer]

Ce qui serait bien c'est de faire le client que tu testes avec modbuspal. Ensuite tu t'occuperas de la partie serveur...

int sendto( SOCKET s, const char* buf, int len, int flags, const struct sockaddr* to, int tolen )

SOCKET s : c'est la socket initialisé lors de la connexion au serveur
const char* buf : c'est le pointeur sur ton message modbus RTU
int len : la taille du message RTU en octet
int flags : mets 0
const struct sockaddr* to : structure qui contient l'adresse du serveur et le port utilisé pour la connexion (port modbus standard : 502)
int tolen : sizeof( const struct sockaddr* to )

La fonction retourne le nombre d'octets envoyés ou -1 s'il y a eu une erreur.

Un peu de code en vrac, avec des erreurs sans doute. Je n'ai jamais utilisé le stack TCP mais ça doit être un truc dans le genre :

// Socket cliente
SOCKET SClient;
struct sockaddr_in addr;
// Propriétés de connexion au serveur
int addrlen = sizeof(struct sockaddr_in);
// Trame Modbus RTU
char TrameRTU[252];
int TrameRTU_len;

// Création de la socket cliente
if( (SClient = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP )) == SOCKET_ERROR )
    return -1;

// Création de la connexion au serveur
addr.sin_port = 502;
addr.sin_addr.S_un.S_addr = IP_ADDR_ANY;
if( bind( SClient, (struct sockaddr*)&addr, addrlen ) == SOCKET_ERROR )
    return -1;

// Envoi d'une donnée
int send_result = sendto( SClient, TrameRTU, TrameRTU_len, 0, (struct sockaddr*)&addr, addrlen );

Tiens il y a un exemple de client TCP dans cette DOC.

[Jojo2504]

Merci de ton aide je vais suivre tes conseils voir ce que je peux faire !!

je vais tester avec le client dans un premier temps

merci,

je reviens mettre les news dés que j'en ai

Cordialement

Jojo

[Jojo2504]

Salut les gars,

je n'arrive toujours pas à envoyer un caractère en modbus tcp client server...

C'est au client d'envoyer un caractère lorsque la connexion est réaliser ! Je pense que ce doit être dans la partie client qu'il faut envoyer une info mais je ne sais pas du tout ou ? Si quelqu'un pouvais m'aider pour trouver quelle fonction appeler et où la placer dans mon programme.

void _APP_ClientTasks() {
    switch (appData.clientState) {
        case APP_TCPIP_WAITING_FOR_COMMAND:
        {
            SYS_CMD_READY_TO_READ();
          if (APP_URL_Buffer[0] != '\0') {
                TCPIP_DNS_RESULT result;
                appData.port = TCPIP_HTTP_SERVER_PORT;
                if (_APP_ParseUrl(APP_URL_Buffer, &appData.host, &appData.path, &appData.port)) {
                    SYS_CONSOLE_PRINT("Could not parse URL '%s'\r\n", APP_URL_Buffer);
                    APP_URL_Buffer[0] = '\0';
                    break;
                }
                result = TCPIP_DNS_Resolve(appData.host, DNS_TYPE_A);
                if (result == DNS_RES_NAME_IS_IPADDRESS) {
                    IPV4_ADDR addr;
                    TCPIP_Helper_StringToIPAddress(appData.host, &addr);
                    appData.clientSocket = TCPIP_TCP_ClientOpen(IP_ADDRESS_TYPE_IPV4,
                            appData.port,
                            (IP_MULTI_ADDRESS*) & addr);
                    if (appData.clientSocket == INVALID_SOCKET) 
                    {
                        SYS_CONSOLE_MESSAGE("Could not start connection\r\n");
                        appData.clientState = APP_TCPIP_WAITING_FOR_COMMAND;
                    }
                    SYS_CONSOLE_MESSAGE("Starting connection\r\n");
                    appData.clientState = SYS_CONSOLE_EVENT_WRITE_COMPLETE;
                    appData.clientState = APP_TCPIP_WAIT_FOR_CONNECTION;
                    break;
                }
                if (result != DNS_RES_OK) {
                    SYS_CONSOLE_MESSAGE("Error in DNS aborting\r\n");
                    APP_URL_Buffer[0] = '\0';
                    break;
                }
                appData.clientState = APP_TCPIP_WAIT_ON_DNS;
                APP_URL_Buffer[0] = '\0';
            }
        }
            break;

        case APP_TCPIP_WAIT_ON_DNS:
        {
            IPV4_ADDR addr;
            switch (_APP_PumpDNS(appData.host, &addr)) {
                case -1:
                {
                    // Some sort of error, already reported
                    appData.clientState = APP_TCPIP_WAITING_FOR_COMMAND;
                }
                    break;
                case 0:
                {
                    // Still waiting
                }
                    break;
                case 1:
                {
                    appData.clientSocket = TCPIP_TCP_ClientOpen(IP_ADDRESS_TYPE_IPV4,
                            appData.port,
                            (IP_MULTI_ADDRESS*) & addr);
                    if (appData.clientSocket == INVALID_SOCKET) {
                        SYS_CONSOLE_MESSAGE("Could not start connection\r\n");
                        appData.clientState = APP_TCPIP_WAITING_FOR_COMMAND;
                    }
                    SYS_CONSOLE_MESSAGE("Starting connection\r\n");
                    appData.clientState = APP_TCPIP_WAIT_FOR_CONNECTION;
                }
                    break;
            }
        }
            break;

        case APP_TCPIP_WAIT_FOR_CONNECTION:
        {
            char buffer[MAX_URL_SIZE];
            if (!TCPIP_TCP_IsConnected(appData.clientSocket)) 
            {
                break;
            }
            
            if (TCPIP_TCP_PutIsReady(appData.clientSocket) == 0) {
                break;
            }
            sprintf(buffer, "GET /%s HTTP/1.1\r\n"
                    "Host: %s\r\n"
                    "Connection: close\r\n\r\n", appData.path, appData.host);
            SYS_CONSOLE_PRINT("Bonjour %s\r\n", buffer);
            TCPIP_TCP_ArrayPut(appData.clientSocket, (uint8_t*) buffer, strlen(buffer) + 1);
            appData.clientState = APP_TCPIP_WAIT_FOR_RESPONSE;
        }
            break;

        case APP_TCPIP_WAIT_FOR_RESPONSE:           // for me: envoye des données
        {
            char buffer[80];
            memset(buffer, 0, sizeof (buffer));
            if (!TCPIP_TCP_IsConnected(appData.clientSocket)) {
                SYS_CONSOLE_MESSAGE("\r\nConnection Closed\r\n");
                appData.clientState = APP_TCPIP_WAITING_FOR_COMMAND;
                break;
            }
            if (TCPIP_TCP_GetIsReady(appData.clientSocket)) {
                TCPIP_TCP_ArrayGet(appData.clientSocket, (uint8_t*) buffer, sizeof (buffer) - 1);
                SYS_CONSOLE_PRINT("%s", buffer);
            }
        }
            break;
        default:
            break;
    }
}

[Jojo2504]

Pour le moment, j'envoie une trame qui est toujours la même: (relevé avec modbus poll)

5A 00 00 00 06 01 03 00 00 00 0A ==> j'en conclut que je me connecte bien au pic mais je n'arrive pas à envoyer la bonne infos

[Jack]

Tu peux expliquer le contenu de ta trame parce que je ne vois pas très bien ce que tu fais:
- l'identificateur de transaction vaut 5A 00 (pourquoi, vu qu'il ne sert à rien dans ton appli)
- 0601 pour la longueur de ta trame ?????
- etc.

j'en conclut que je me connecte bien au pic mais je n'arrive pas à envoyer la bonne infos

Comment peux-tu conclure quoi que ce soit puisque c'est la trame que tu as envoyée que tu nous montres?