Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.

Messages - VinceLaTaupe

Pages: [1]

Réseau / Re: Réception de données non complètes : Comment contrôler ?

« le: Juillet 11, 2017, 02:28:09 pm »

Héhé, j'étais pas sûr de ça, du coup dans le doute ...
Après c'est toujours plus simple d'expliquer et comprendre dans une langue natale

Réseau / Réception de données non complètes : Comment contrôler ?

« le: Juillet 11, 2017, 01:24:04 pm »

Bonjour à tous.

J'ai un problème dont je n'arrive pas à identifier tout à fais la cause. Avant tout je précise que je ne peux pas utiliser la classe sf::Packet, car je ne gère pas le "coté serveur".

Je suis censé recevoir un message générique d'une 60aine d'octets.

Du coup je me suis créé un buffer de taille 64. Le problème est qu'au moment de la réception je ne reçois pas les 61octets, du moins pas tout le temps et c'est ça que je comprends pas...
Parfois je reçois l'intégralité du message, parfois non.

Le problème, c'est que lorsque je ne reçois pas l'intégralité de mon message, le statut renvoyé est quand même sf::Socket::Done, du coup, aucun moyen pour moi d'analyser si mon message est complet ou non pour refaire appel à la fonction receive() ...

Je précise que je ne peux pas travailler avec sf::Packet car je ne controle pas le serveur.

Voici mon code "abrégé" et les réponses associées :

int main()
{
        sf::TcpSocket socket;
        std::cout << "Connexion" << std::endl;
        
        sf::Socket::Status status = socket.connect("192.168.127.254", 9001);
        std::cout << status << std::endl;

        size_t received(1);
        char data[64] = { 0 };
        std::string str{ "" };

        str =  "#1Z1|\r" ;

        if (socket.send(&str[0], str.size()) != sf::Socket::Done)
                std::cout << "Erreur envoi" << std::endl;
        else
                std::cout << "Message envoye : " << str << std::endl;

        status = socket.receive(data, 64, received);

        if ( status != sf::Socket::Done)
                std::cout << "erreur reception. Statut : " << status << std::endl; // La c'est juste pour illustrer si le message n'est pas reçu en intégralité.
        else
        {
                data[received - 1] = '\0';
                str = data;
                std::cout << "Message recu : " << str << " (" << received << ")" << std::endl;
                std::cout << "Statut : " << status << std::endl;
        }

        // Pour Prouver qu'il en reste éventuellement : 
        if (received != 61)
        {
                status = socket.receive(data, 64, received);

                if (status != sf::Socket::Done)
                        std::cout << "erreur reception. Statut : " << status << std::endl; // La c'est juste pour illustrer si le message n'est pas reçu en intégralité.
                else
                {
                        data[received - 1] = '\0';
                        str = data;
                        std::cout << "Message recu : " << str << " (" << received << ")" << std::endl;
                        std::cout << "Statut : " << status << std::endl;
                }
        }
}
 

Du coup quand tout se passe bien, j'ai mis en PJ une capture du résultat et de même quand ça marche pas bien...

Et voilà le résultat par écrit :

(click to show/hide)

Le statut 0 correspond à sf::Socket::Done.

On voit bien ainsi que parfois je ne reçois pas tout, et pourtant le programme me renvoie un statut "Done" ...

Une idée du problème et de comment le régler ?

Merci d'avance.
Vincent.

PS : Je suis débutant, ne m'en voulez pas trop si j'ai fais des fautes graves svp :p

Réseau / Connexion à des cartes de commande de moteurs

« le: Juin 14, 2017, 05:36:36 pm »

Bonjour à tous !
Je vais tâcher d'être le plus succin et précis possible mais c'est un projet sur lequel j'ai un peu réfléchis, et je ne voulais pas partir tête baissée.

Stagiaire, je travaille actuellement sur l'élaboration d'un petit programme qui communique avec des cartes de contrôle de moteurs pas-à-pas.
Pour communiquer avec elles, j'utilise un convertisseur ethernet/RS485 (plus de détails)

Pour résumer et que vous ayez une idée claire, voici ce que mon programme doit faire :
Globalement, la communication se fera très peu souvent (les cartes sont assez autonomes) et les commandes et leurs retours (echo) sont très succins. Par exemple pour faire tourner le moteur 2 selon le programme prédéfini N°1 cela se passe en 2 lignes de commande :

#2y1 *ENTREE* Selection du programme pré-enregistré dans la carte
echo venant de la carte : 2y1
#1A *ENTREE*
echo venant de la carte : 1A

Et là, magie, le moteur tourne ! Dans ce cas là, l'echo est pas vraiment nécéssaire (si ce n'est vérifier que la carte comprend bien ce que je lui dis)
Un autre exemple serait la lecture des entrée/sorties de la carte (où là l'echo est important) :

#2Y *ENTREE* Lecture des toutes les entrée sorties de la carte 2
Echo : 2Y+<une succession de chiffres représentants les bits de la carte à interpréter>

Jusque là, je travaillais un peu avec PuTTY pour voir le fonctionnement des cartes, mais faut maintenant que je passe au niveau supérieur : La programmation.

J'y ai déjà un peu réfléchis, mais j'aurais besoin d'un peu d'aide pour établir la structure de la com à établir :

LA TYPOLOGIE UTILISEE
C'est le gros truc sur lequel je doute. Qui doit être client ou serveur ?
Je me disais que les cartes joueraient le rôle de serveur et l'ordinateur (via mon programme) serait le client.
Ainsi, je crée ma socket, et j'envoie mes commande avec la fonction send(...) et lis les echos avec la fonction receive. Ainsi je n'aurais pas de serveur à programmer.

LES SOCKETS
Au début je pensais n'utiliser que du TCP, j'ai pas vraiment besoin de vitesse, mes commandes sont relativement simples, et je préfère être sûr qu'elle arrivent.
Mais pour certains cas (par exemple la lecture constante d'un capteur de position) je pensais utiliser de l'UDP pour avoir une position actuelle la plus précise possible. Et puis aussi par rapport à la façon d'envoyer mes paquets (partie juste après)

L'ENVOI DES PAQUETS : ENVOIS BRUT ou HAUT NIVEAU ??
J'ai vu aussi dans les tutos de SFML qu'il y avait 2 manières d'envoyer mes donnes : en bas niveau ou haut niveau.
Tout content qu'une fonction toute faite existe, je me suis dis que j'allais l'utiliser. Deception quand j'ai vu qu'il fallait que pour que les données soient reçues, il fallait aussi utiliser cette fonction toute faites d'envoie des paquets. Impossible donc pour communiquer avec mes cartes, SAUF si je communique en UDP. (D'après cette page, le paragraphe juste avant "Etendre les paquets pour qu'ils gèrent vos types persos")

Du coup je pensais utiliser que de l'UDP, et utiliser la "Fonction Haut niveau". Est-ce que vous pensez que cela devrait marcher ainsi ?

VOILA !
Merci de m'avoir lu pour ceux qui l'ont fait.
Si vous pouvez m'éclairer, je vous en serais très reconnaissant !

Vincent.

EDIT : Désolé pour la taille, j'ai essayé de faire au plus court.

Pages: [1]