encode utf8 socket udp

Version imprimable

binjour,
Je souhaite communiqué avec un variateur de la marque elmo, pour cela j'utilise l'udp. Les instruction a transmettre sont simple (ex= "MO=1\r" "MO=1\r" "JV=50000\r""BG\r")
Il y a plusieurs mois j'avais écrit un programme en python qui communiqué avec en USB par contre, et sur les conseille d'une personne j'encodais ce message en utf-8 sinon ça ne fonctionnais pas ...
morceau du code en python:

Code:

1
2
 
ser.write("BG\r".encode('utf8'))   #Départ

l'idée serais de faire pareil en C mais j'ai pas tout compris la dessus...voici un morceau de mon code (oui il a beaucoup d'include pas forcement utile mais c'est ceux de mon programme principale ,là c'est juste un espace de test)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
// Pour sockets //
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKET -1   // def de la valeur de defaut qu une fonction peut me renvoyer // pour la comparaison
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
// Standard //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
#include <time.h>
#include <math.h>
//Port de communication output //
#define PORT 5001
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>
 
 
 
 
 
 
int main()
{
 
    SOCKET sock;   //nom de ma socket
    SOCKADDR_IN sin;  // adresse ip
    SOCKET csock;    
    SOCKADDR_IN csin;
    char buffer[20]; // taille du buffer dans lequel vas etre mes data
    socklen_t recsize = sizeof(csin);
    int sock_err;
    socklen_t fromlen = sizeof(sin);
 
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if(sock != INVALID_SOCKET)    // Configuration //
        {
            sin.sin_addr.s_addr = inet_addr("10.10.10.104");
           // sin.sin_addr.s_addr = htonl(INADDR_ANY);  
            sin.sin_family         = AF_INET;             // Protocole(TCP/IP)
            sin.sin_port           = htons(PORT);         // Listage du port    
            sock_err = bind(sock, (SOCKADDR*)&sin, sizeof(sin));
 
            if (sock_err==SOCKET_ERROR){return 0;} 
            else{printf("La socket est maintenant ouverte en mode UDP \n");}
        }
 
 
   wchar_t *chaine = L"MO=1\n";
 
    setlocale(LC_CTYPE, "utf-8");
 
    wprintf(L"%ls", chaine);
 
 
      //  char utf8[] = u8"MO=1\n";
        //char * message=utf8;
        int sock_errsend=sendto(sock,chaine, sizeof(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));
        printf("send= %d \n",sock_errsend);
 
 
            //Fermeture de la socket 
            printf("Fermeture de la socket...\n");
            closesocket(sock);
            printf("Fermeture du serveur terminee\n");
 
 
}

voici ce qu'il me retourne

Code:

1
2
3
4
5
6
7
 
$ gcc -o test test.c
$ ./test
La socket est maintenant ouverte en mode UDP 
send= 8 
Fermeture de la socket...
Fermeture du serveur terminee

quand je change mes paramètres ip ou port ma socket ne ce connecte pas ,donc la socket fonctionne!

si vous avez une idée du problème ou des pistes je suis preneur !

01/05/2020, 16h06
Sve@r

Citation:

Envoyé par leoleo34

binjour,

Oui, binjour aussi

Citation:

Envoyé par leoleo34

si vous avez une idée du problème ou des pistes je suis preneur !

Ben déjà immédiatement en ligne 70 le sizeof(chaine) ça ne le fait pas du tout. sizeof est ultra trivial. Tu lui demandes la taille d'un truc, il te donne la taille de ce truc. Or, la taille d'un pointeur c'est 4 sur un os 32 bits et 8 sur un os 64 bits. En aucun cas ça ne te donne la taille de la chaine car en C une chaine ce n'est qu'une adresse. Ici strlen() sera plus adapté.

le strlen() ne fonctionne pas: voici l'erreur:

Code:

1
2
3
4
5
6
7
8
9
 
test.c: In function ‘main’:
test.c:69:53: warning: passing argument 1 of ‘strlen’ from incompatible pointer type [-Wincompatible-pointer-types]
         int sock_errsend=sendto(sock,chaine, strlen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));
                                                     ^~~~~~
In file included from test.c:16:0:
/usr/include/string.h:384:15: note: expected ‘const char *’ but argument is of type ‘wchar_t * {aka int *}’
 extern size_t strlen (const char *__s)
               ^~~~~~

Code:

int sock_errsend=sendto(sock,chaine, strlen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));

j ai essayer avec strlen(*chaine) ou strlen(* chaine) mais pareil..

01/05/2020, 17h26
Bousk

Il est pourtant écrit noir sur blanc que strlen attend un char* et que tu utilises un wchar_t*.
Après est-ce pertinent d'utiliser UDP dans ce cas ? Avec les pertes inhérentes au protocole.. bof.
Est-ce probant d'utiliser de l'utf8 pour des chaînes ASCII ? J'en doute.
01/05/2020, 17h32
leoleo34

dans tout les cas pour le strlen() je peut mettre une valeur fixe ex=300 , et j'utilise de l'udp car mon variateur fonctionne avec de l'udp :roll:
et je suis d'accord avec toi mais sans être en utf8 il ne reconnais pas mes instruction ....
01/05/2020, 17h59
Bousk

Ou en 1/100s sur Google http://man7.org/linux/man-pages/man3/wcslen.3.html http://www.cplusplus.com/reference/cwchar/wcslen/
Il est possible que le variateur traite les données reçues comme wchar_t*, c'est juste étrange.
Par contre, l'UDP ? C'est obligatoire sur leur documentation ? Et le bind devrait utiliser ANY et non une ip spécifique.
01/05/2020, 18h11
leoleo34

merci,
et ducoup la "fonction" wchar_t* permet l'encodage c'est bien ça et je ne comprend pas comment il sais que je veut encodé en utf8 ou autre chose..
et oui UDP le support technique me la spécifie, et tout mes systèmes sont en UDP (Robot fanuc(en acquisition) et ce variateur) donc à terme je vais utiliser un select pour gérer les deux.

et pour le bind l'ip fonctionne comme ça aussi mais je vais passer en anny ça m’évitera de re-fixer mon ip a chaque redémarrage pour être en accord avec mon programme (si j'ai bien compris)
02/05/2020, 01h02
dalfab
wchar_t ça n'est pas une fonction c'est un type de stockage de caractère qui peut stocker l'ensembles des graphies mondiales donc plus de 100000 caractères différents. utf-8 est un moyen de transmettre ces caractères différents. On peut donc utiliser des fonctions de conversion d'une chaîne de wchar_t en une chaîne d'utf-8, et ça n'a rien à voir avec la locale.
On peut aussi voir que les caractères transmis sont les caractères de base (il y en a que 96 = les lettres les chiffres et quelques symboles), et là plus besoin de conversion en écrivant simplement :
Code:

1 2 const wchar_t *chaine = L"MO=1\r"; // c'est directement compatible avec ce qui est attendu. int sock_errsend=sendto(sock,chaine, wcslen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));
Et ne pas confondre \n qui est le line feed avec \r qui est le carriage return.
02/05/2020, 18h23
Sve@r

Citation:

Envoyé par dalfab

Code:

int sock_errsend=sendto(sock,chaine, strlen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));

Perso je conseillerais strlen(chaine) + 1 pour que le '\0' soit lui-aussi transmis. Ce n'est pas obligatoire de le faire mais sinon il faut alors que le destinataire pense à le mettre manuellement.

Citation:
Envoyé par dalfab
Code:

1 2 const char *chaine = L"MO=1\r"; // c'est directement compatible avec ce qui est attendu. int sock_errsend=sendto(sock,chaine, strlen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));
Et ne pas confondre \n qui est le line feed avec \r qui est le carriage return.
Déso pour l’absence j’étais sur autre choses!

du-coup j'ai suivit vos conseils, et toujours une erreur ...
Code:

1 2 3 test1.c: In function ‘main’: test1.c:60:22: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types] const char *chaine = L"MO=1\r"; // c'est directement compatible avec ce qui est attendu.
de plus je pense que mon probleme viens que j'arrive pas a envoyer le message sur l'adresse de mon var , car tout les tuto / code qu on trouve sont fait pour fonctionner en serveur/client et au final ils ce connecte car le client envoie une acceptation (donc sont ip) au serveur,je pense que j'ai rater quelque chose a ce niveau là,, en gros il me vaudrais un send avec en argument direct l ip visé ou le port :roll:

05/05/2020, 22h06
Bousk

Le préfixe L indique une chaîne de wchar_t. strlen est pour char*, pour wchar_t il faut utiliser wcslen.
Tu es libre de créer ta propre fonction.
Tu as tout ce qu'il te faut disponible ici https://bousk.developpez.com/cours/r...iers-pas/#LV-A
Tu n'as aucune connexion à établir en UDP.
Mais tu ne veux certainement pas recréer un socket à chaque fois.

ok ok ,
donc là actuellement j'ai ça qui envoi bien mon message mais aucune action sur mon variateur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
// Pour sockets //
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKET -1   // def de la valeur de defaut qu une fonction peut me renvoyer // pour la comparaison
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
// Standard //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
#include <time.h>
#include <math.h>
//Port de communication output //
#define PORT 5001
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>
 
int main()
{
 
    SOCKET sock;   //nom de ma socket
    SOCKADDR_IN sin;  // adresse ip
  //  SOCKET csock;    
  //  SOCKADDR_IN csin;
    char buffer[350]; // taille du buffer dans lequel vas etre mes data
    socklen_t recsize = sizeof(sin);
    int sock_err;
    socklen_t fromlen = sizeof(sin);
 
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if(sock != INVALID_SOCKET)    // Configuration //
        {
           // sin.sin_addr.s_addr = inet_addr("192.168.1.4");
            sin.sin_addr.s_addr = INADDR_ANY;  
            sin.sin_family         = AF_INET;             // Protocole(TCP/IP)
            sin.sin_port           = htons(PORT);         // Listage du port    
            sock_err = bind(sock, (SOCKADDR*)&sin, sizeof(sin));
 
            if (sock_err==SOCKET_ERROR){printf("La socket PAS ouverte en mode UDP \n");return 0;} 
            else{printf("La socket est maintenant ouverte en mode UDP \n");}
        }
 
    SOCKADDR_IN dst;
	inet_pton(AF_INET, "192.168.1.2", &dst.sin_addr.s_addr);
	dst.sin_family = AF_INET;
	dst.sin_port = htons(PORT);
 
    const wchar_t *chaine = L"MO=1\r"; // c'est directement compatible avec ce qui est attendu.
    int sock_errsend=sendto(sock,chaine, wcslen(chaine), 0, (SOCKADDR *)&sin, sizeof(sin));
        printf("send= %d \n",sock_errsend);
 
 
            //Fermeture de la socket 
            printf("Fermeture de la socket...\n");
            closesocket(sock);
            printf("Fermeture du serveur terminee\n");
 
 
}

Code:

1
2
3
4
La socket est maintenant ouverte en mode UDP 
send= 5 
Fermeture de la socket...
Fermeture du serveur terminee

alors que en python et serial port j'ai ça qui fonctionne parfaitement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon May 11 11:27:12 2020
 
@author: xxxxxxxxxx
"""
 
from serial import Serial   #dialogue avec variateur
ser = Serial('/dev/ttyACM0',9600)
MO="MO=0\r"
ser.write(MO.encode('utf8'))    #Moteur actif

pour moi le probleme viens uniquement de l'encodage :? :(

11/05/2020, 15h56
Bousk

T'es tellement focalisé sur une erreur d'encodage pour je ne sais quelle raison que tu ne vois même pas que tu envoies ton truc à toi-même et non à ton variateur.

je crois je viens de voir mon erreur
Code:

1 2 const wchar_t *chaine = L"MO=1\r"; // c'est directement compatible avec ce qui est attendu. int sock_errsend=sendto(sock,chaine, wcslen(chaine), 0, (SOCKADDR *)&dst, sizeof(dst));
mais toujours pareil, y'a t il une autre erreur ?(ça fait pas longtemps que je programme et encore moins des sockets 8O )

11/05/2020, 16h18
Bousk

Ton script Python utilise une lib de Serial qui fait sûrement tout un tas de trucs.
Comment tu choisis sur quel port envoyer pour ton socket ? 5001 sort d'où ?
11/05/2020, 16h19
leoleo34

je vais regardé de plus prés cette lib , et le 5001 est celui que j'ai configuré dans mon variateur

déjà es que mon programme est correct pour la gestion des sockets? j'envoie bien mon message sur le port 5001 sur l'ip 192.168.1.2?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// Pour sockets //
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define INVALID_SOCKET -1 // def de la valeur de defaut qu une fonction peut me renvoyer // pour la comparaison
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
// Standard //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
#include <time.h>
#include <math.h>
//Port de communication output //
#define PORT 5001
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>
 
 
int main()
{
 
    SOCKET sock;      //nom de ma socket
    SOCKADDR_IN sin;  // adresse ip
                      //  SOCKET csock;
                      //  SOCKADDR_IN csin;
    char buffer[350]; // taille du buffer dans lequel vas etre mes data
    socklen_t recsize = sizeof(sin);
    int sock_err;
    socklen_t fromlen = sizeof(sin);
 
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sock != INVALID_SOCKET) // Configuration //     // ma machine
    {
        // sin.sin_addr.s_addr = inet_addr("192.168.1.4");
        sin.sin_addr.s_addr = INADDR_ANY;
        sin.sin_family = AF_INET;   // Protocole(TCP/IP)
        sin.sin_port = htons(PORT); // Listage du port
        sock_err = bind(sock, (SOCKADDR *)&sin, sizeof(sin));
 
        if (sock_err == SOCKET_ERROR)
        {
            printf("La socket PAS ouverte en mode UDP \n");
            return 0;
        }
        else
        {
            printf("La socket est maintenant ouverte en mode UDP \n");
        }
    }
 
    SOCKADDR_IN dst;    // mon variateur
    inet_pton(AF_INET, "192.168.1.2", &dst.sin_addr.s_addr);
    //sin.sin_addr.s_addr = INADDR_ANY;
    dst.sin_family = AF_INET;
    dst.sin_port = htons(PORT);
 
    const wchar_t *chaine = L"MO=1\n"; // c'est directement compatible avec ce qui est attendu.
    int sock_errsend = sendto(sock, chaine, wcslen(chaine)+1, 0, (SOCKADDR *)&dst, sizeof(dst));
    printf("send= %d \n", sock_errsend);
 
    //Fermeture de la socket
    printf("Fermeture de la socket...\n");
    closesocket(sock);
    printf("Fermeture du serveur terminée\n");
}