Répondre à la discussion
Page 1 sur 3 12 DernièreDernière
Affichage des résultats 1 à 30 sur 67

PIC32MZ MODBUS TCP communication



  1. #1
    Jojo2504

    PIC32MZ MODBUS TCP communication

    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

    -----


  2. Publicité
  3. #2
    JPL

    Re : PIC32MZ MODBUS TCP communication

    J'ai déplacé la demande parce qu'elle est peut-être mieux ici.
    Rien ne sert de penser, il faut réfléchir avant - Pierre Dac

  4. #3
    RISC

    Re : PIC32MZ MODBUS TCP communication

    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+
    Ma marotte ? les microcontrôleurs ;=)

  5. #4
    Jojo2504

    Wink Re : PIC32MZ MODBUS TCP communication

    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

  6. #5
    Bluedeep

    Re : PIC32MZ MODBUS TCP communication

    Citation Envoyé par Jojo2504 Voir le message
    il n'y a aucun exemple de communication modbus tcp seulement tcp client server
    Normal, Modbus TCP est toujours en mode client-serveur.

  7. A voir en vidéo sur Futura
  8. #6
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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

  9. Publicité
  10. #7
    Bluedeep

    Re : PIC32MZ MODBUS TCP communication

    Citation Envoyé par Jojo2504 Voir le message
    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.

  11. #8
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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.

  12. #9
    Bluedeep

    Re : PIC32MZ MODBUS TCP communication

    Citation Envoyé par Jojo2504 Voir le message
    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.

  13. #10
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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 !

  14. #11
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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 ?

  15. #12
    Jack

    Re : PIC32MZ MODBUS TCP communication

    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:

  16. Publicité
  17. #13
    Johnplayer

    Re : PIC32MZ MODBUS TCP communication

    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.
    Dernière modification par Johnplayer ; 18/05/2017 à 23h10.

  18. #14
    RISC

    Re : PIC32MZ MODBUS TCP communication

    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+
    Ma marotte ? les microcontrôleurs ;=)

  19. #15
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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

  20. #16
    Jack

    Re : PIC32MZ MODBUS TCP communication

    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.

  21. #17
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    D'accord merci

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

  22. #18
    Jack

    Re : PIC32MZ MODBUS TCP communication

    Citation Envoyé par Jojo2504 Voir le message
    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

  23. Publicité
  24. #19
    paulfjujo

    Re : PIC32MZ MODBUS TCP communication

    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

    realterm.jpg

  25. #20
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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];
    Captuuuuure.JPG
    Dernière modification par Jojo2504 ; 19/05/2017 à 10h55.

  26. #21
    Jack

    Re : PIC32MZ MODBUS TCP communication

    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
    Dernière modification par Jack ; 19/05/2017 à 11h36.

  27. #22
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    d'accord je regarde ça après manger

  28. #23
    Johnplayer

    Re : PIC32MZ MODBUS TCP communication

    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.

  29. #24
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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:

    Code:
    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;
    }
    Dernière modification par Jack ; 19/05/2017 à 16h48. Motif: Ajout balises code

  30. Publicité
  31. #25
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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

  32. #26
    Johnplayer

    Re : PIC32MZ MODBUS TCP communication

    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 :

    Code:
    // 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.
    Dernière modification par Johnplayer ; 19/05/2017 à 14h45. Motif: Ajout d'infos

  33. #27
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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

  34. #28
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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.

    Code:
    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;
        }
    }
    Dernière modification par Antoane ; 22/05/2017 à 08h44. Motif: Remplacement balises quote par code

  35. #29
    Jojo2504

    Re : PIC32MZ MODBUS TCP communication

    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

  36. #30
    Jack

    Re : PIC32MZ MODBUS TCP communication

    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?
    Dernière modification par Jack ; 22/05/2017 à 09h03.

Sur le même thème :

Page 1 sur 3 12 DernièreDernière

Discussions similaires

  1. communication MODBUS RTU
    Par Samikerc dans le forum Électronique
    Réponses: 0
    Dernier message: 05/08/2014, 14h18
  2. communication modbus PIC16F877
    Par ikbel dans le forum Électronique
    Réponses: 19
    Dernier message: 28/11/2012, 22h44
  3. la communication via Modbus
    Par azizAVR dans le forum Électronique
    Réponses: 37
    Dernier message: 02/04/2012, 16h39
  4. Communication modbus sur Ethernet
    Par mayonaise dans le forum Internet - Réseau - Sécurité générale
    Réponses: 6
    Dernier message: 24/11/2011, 19h00
  5. Modbus Protocol Communication
    Par triviaux dans le forum Électronique
    Réponses: 1
    Dernier message: 27/02/2008, 19h40