Pilier du forum
Posté 18 février 2018 - 03:46
Coucou les maker's, petit résumé du moment, j'arrive maintenant à envoyer plusieurs valeurs d'une structure via un union depuis arduino envoyé à pi, et pi avec la rs232 récupère tous se petit monde pour le redistribuer dans une structure 
Pleins de tests encore à faire
...et c'est pas fini...
Pilier du forum
Posté 19 février 2018 - 04:39
Plop all, j'avais une tite question, le convertisseur logique est il sensible aux ondes ??
Mon portable est à quelques cm du convertisseur et par moment, pas tous le temps j'ai comme des parasites sur mes données, et ça revient aussitôt.
Vais tester avec le portable bien loin et faire tourner le programme
Staff Robot Maker
Posté 19 février 2018 - 06:57
je pense pas que ça soit le convertisseur mais les fils ... Un long fil c'est une antenne ...
Si mon commentaire vous a plus laissez nous un avis ! 
Nouveau sur Robot Maker ?
Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope aux articles, à la boutique et aux différents services disponible !
En attendant qu'une bibliothèque de fichiers 3D soit mise en place n'hésitez pas à demander si vous avez besoin du fichier 3D d'un des produits de la boutique... On l'a peut être !
Si vous souhaitez un robot pilotable par internet n'hésitez pas à visiter www.vigibot.com et à lire le sous forum dédié à vigibot!
Pilier du forum
Posté 20 février 2018 - 09:49
Plop
Bon j'en conclue qu'il me faut du câble blindé
J'ai tout de même plusieurs questions :
- J'aimerais pouvoir gérer le temps en millis() et non avec delay() coté arduino, mais je n'ai pas vraiment réussi je dois m'embrouiller dans les ms et seconde.
- Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?
- Est il possible d'établir un canal pour l'envoie et un pour la réception, car actuellement si les deux se croisent ça merdouille.
- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??
Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?
Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??
J'aurais surement d'autres questions, là je post au plus vite
Petite avancé quand même :
Gcom.cpp
#include <iostream> //Permet d'utiliser In et Out du moniteur série
#include "rs232.h" //Librairie de communication RS232
using namespace std;
//Conseil : placez vos types du plus gros au plus petit selon les bytes
//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM
{
//Structure pour l'émission
struct SEN
{
int intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
short int shortintform ;//2 octet/bytes (16 bits) : -32 768 / +32 767
char charform ; //1 octet/bytes (8 bits) : -128 / +127
char charform2 ; //1 octet/bytes (8 bits) : -128 / +127
} dataSen;
//Structure pour la récepetion
struct REC
{
int intard; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float floatard; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
short int shortintard; //2 octet/bytes (16 bits) : -32 768 / +32 767
char charard; //1 octet/bytes (8 bits) : -128 / +127
} dataRec;
//L'envoie et la réception sont dans des tableaux
//(sizeof) permet de récupérer la taille en byte de nos structures
unsigned char dataSend[sizeof (dataSen)];
unsigned char dataReceive[sizeof (dataRec)];
}piSend, piReceive;
int BUF_SIZE = sizeof (piSend.dataSend);
int BUF_SIZEREC = sizeof (piReceive.dataReceive);
int main()
{
//initisialisation de notre structure pour l'émission - dataSen
piSend.dataSen.intform = 123;
piSend.dataSen.floatform = 3.14;
piSend.dataSen.shortintform = 15210;
piSend.dataSen.charform = 70; //Code ascii 70 vaut F
piSend.dataSen.charform2 = 73; //Code ascii 73 vaut I
int cport_nr(0); // 0 = ttyS0
int bdrate(115200); // Baud
char mode []={'8','N','1',0}; // 8 data bits, no parity, 1 stop bit
//Si toutes les conditions recquises sont bonnes, on ouvre le port de communication
if (RS232_OpenComport(cport_nr, bdrate, mode))
{
cout <<"Ne peut pas ouvrir le port com. \n";
return 0;
}
cout << "----- \n";
cout << "Raspberry connecté : \n";
cout << "----- \n";
while(1)
{
//Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
//Via la RS232
RS232_SendBuf(cport_nr, piSend.dataSend, BUF_SIZE);
cout << "----- \n";
//Récupére un tableau de données de la pi dans le buffer envoyé d'Arduino
//Via la RS232
int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZEREC);
if (n > 0)
{
piReceive.dataReceive[n] = 0;
cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n";
}
//On regarde ce qu'Arduino nous envoit
cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.intard <<" \n";
cout << "Pi reçoit d'Arduino le float : " << piReceive.dataRec.floatard <<" \n";
cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.shortintard <<" \n";
cout << "Pi reçoit d'Arduino le char : " << piReceive.dataRec.charard <<" \n";
cout << "Taille sizeof piReceive.dataReceive : " << sizeof(piReceive.dataRec) << " octets/bytes. \n";
cout << "\n";
usleep(100000); //usleep est en ms 100000 pause pour 100 milliSeconds
}
return 0;
}
Arduino envoit :
//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{
//Structure pour l'émission
struct SEN
{
//taille de notre structure 11 bytes
long ardlong ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float ardfloat; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
int ardint; //2 octet/bytes (16 bits) : -32 768 / +32 767
byte ardchar; //1 octet/bytes (8 bits) : -128 / +127
}dataSen;
//Structure pour la récepetion
struct REC
{
//taille de notre structure 12 bytes
long intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
int shortintform ; //2 octet/bytes (16 bits) : -32 768 / +32 767
byte charform ; //1 octet/bytes (8 bits) : -128 / +127
byte charform2 ; //1 octet/bytes (8 bits) : -128 / +127
}dataRec;
//L'envoie et la réception sont dans des tableaux
//(sizeof) permet de récupérer la taille en byte de nos structures
unsigned char dataSend[sizeof dataSen];
unsigned char dataRece[sizeof dataRec];
}ardSend, ardRec;
void setup(){
Serial.begin (115200);
//Initisalisation de notre structure dataSen
ardSend.dataSen.ardlong = 1234567891;
ardSend.dataSen.ardfloat = 128.354;
ardSend.dataSen.ardint = 16569;
ardSend.dataSen.ardchar = 120;
}
void loop() {
//Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
Serial.write (ardSend.dataSend, sizeof ardSend.dataSend);
delay(100);
}
Pi reçoit :
----- Raspberry connecté : ----- ----- Pi reçoit d'Arduino : 7 bytes. Pi reçoit d'Arduino le short int : 1124096672 Pi reçoit d'Arduino le float : 1.10435e-38 Pi reçoit d'Arduino le short int : 0 Pi reçoit d'Arduino le char : Taille sizeof piReceive.dataReceive : 12 octets/bytes.
Pour l'envoi le Gcom.cpp ne change pas, vous retrouverez les valeurs initialisés dans le code :
//initisialisation de notre structure pour l'émission - dataSen piSend.dataSen.intform = 123; piSend.dataSen.floatform = 3.14; piSend.dataSen.shortintform = 15210; piSend.dataSen.charform = 70; //Code ascii 70 vaut F piSend.dataSen.charform2 = 73; //Code ascii 73 vaut I
Arduino reçoit :
//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{
//Structure pour l'émission
struct SEN
{
//taille de notre structure 11 bytes
long ardlong ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float ardfloat; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
int ardint; //2 octet/bytes (16 bits) : -32 768 / +32 767
byte ardchar; //1 octet/bytes (8 bits) : -128 / +127
}dataSen;
//Structure pour la récepetion
struct REC
{
//taille de notre structure 12 bytes
long intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
int shortintform ; //2 octet/bytes (16 bits) : -32 768 / +32 767
byte charform ; //1 octet/bytes (8 bits) : -128 / +127
byte charform2 ; //1 octet/bytes (8 bits) : -128 / +127
}dataRec;
//L'envoie et la réception sont dans des tableaux
//(sizeof) permet de récupérer la taille en byte de nos structures
unsigned char dataSend[sizeof dataSen];
unsigned char dataRece[sizeof dataRec];
}ardSend, ardRec;
void setup(){
Serial.begin (115200);
//Initisalisation de notre structure dataSen
ardSend.dataSen.ardlong = 1234567891;
ardSend.dataSen.ardfloat = 128.354;
ardSend.dataSen.ardint = 16569;
ardSend.dataSen.ardchar = 120;
}
void loop() {
//Récupére un tableau de données de la pi dans le buffer que l'on initialise dans dataRec
while (Serial.available() > 0) { //if any data available
Serial.readBytes (ardRec.dataRece, sizeof ardRec.dataRec);
Serial.println ("Arduino reçoit Pi ");
Serial.print ("Intform : ");
Serial.println (ardRec.dataRec.intform);
Serial.print ("Floatform : ");
Serial.println (ardRec.dataRec.floatform);
Serial.print ("Shortintform : ");
Serial.println (ardRec.dataRec.shortintform);
Serial.print ("Charform : ");
Serial.println (ardRec.dataRec.charform);
Serial.print ("Charform2 : ");
Serial.println (ardRec.dataRec.charform2);
Serial.print ("-----");
}
delay(100);
}
Arduino reçoit (console) :
-----Arduino reçoit Pi Intform : 123 Floatform : 3.14 Shortintform : 15210 Charform : 70 Charform2 : 73
Made By Humans
Posté 20 février 2018 - 10:05
Staff Robot Maker
Posté 20 février 2018 - 11:01
Plop
Bon j'en conclue qu'il me faut du câble blindé
J'ai tout de même plusieurs questions :
- J'aimerais pouvoir gérer le temps en millis() et non avec delay() coté arduino, mais je n'ai pas vraiment réussi je dois m'embrouiller dans les ms et seconde.
- Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?
- Est il possible d'établir un canal pour l'envoie et un pour la réception, car actuellement si les deux se croisent ça merdouille.
- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??
Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?
Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??
J'aurais surement d'autres questions, là je post au plus vite
Petite avancé quand même :
Gcom.cpp
#include <iostream> //Permet d'utiliser In et Out du moniteur série #include "rs232.h" //Librairie de communication RS232 using namespace std; //Conseil : placez vos types du plus gros au plus petit selon les bytes //Union pour envoyer nos types struct dans un tableau unsigned char union COMM { //Structure pour l'émission struct SEN { int intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 short int shortintform ;//2 octet/bytes (16 bits) : -32 768 / +32 767 char charform ; //1 octet/bytes (8 bits) : -128 / +127 char charform2 ; //1 octet/bytes (8 bits) : -128 / +127 } dataSen; //Structure pour la récepetion struct REC { int intard; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float floatard; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 short int shortintard; //2 octet/bytes (16 bits) : -32 768 / +32 767 char charard; //1 octet/bytes (8 bits) : -128 / +127 } dataRec; //L'envoie et la réception sont dans des tableaux //(sizeof) permet de récupérer la taille en byte de nos structures unsigned char dataSend[sizeof (dataSen)]; unsigned char dataReceive[sizeof (dataRec)]; }piSend, piReceive; int BUF_SIZE = sizeof (piSend.dataSend); int BUF_SIZEREC = sizeof (piReceive.dataReceive); int main() { //initisialisation de notre structure pour l'émission - dataSen piSend.dataSen.intform = 123; piSend.dataSen.floatform = 3.14; piSend.dataSen.shortintform = 15210; piSend.dataSen.charform = 70; //Code ascii 70 vaut F piSend.dataSen.charform2 = 73; //Code ascii 73 vaut I int cport_nr(0); // 0 = ttyS0 int bdrate(115200); // Baud char mode []={'8','N','1',0}; // 8 data bits, no parity, 1 stop bit //Si toutes les conditions recquises sont bonnes, on ouvre le port de communication if (RS232_OpenComport(cport_nr, bdrate, mode)) { cout <<"Ne peut pas ouvrir le port com. \n"; return 0; } cout << "----- \n"; cout << "Raspberry connecté : \n"; cout << "----- \n"; while(1) { //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi //Via la RS232 RS232_SendBuf(cport_nr, piSend.dataSend, BUF_SIZE); cout << "----- \n"; //Récupére un tableau de données de la pi dans le buffer envoyé d'Arduino //Via la RS232 int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZEREC); if (n > 0) { piReceive.dataReceive[n] = 0; cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n"; } //On regarde ce qu'Arduino nous envoit cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.intard <<" \n"; cout << "Pi reçoit d'Arduino le float : " << piReceive.dataRec.floatard <<" \n"; cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.shortintard <<" \n"; cout << "Pi reçoit d'Arduino le char : " << piReceive.dataRec.charard <<" \n"; cout << "Taille sizeof piReceive.dataReceive : " << sizeof(piReceive.dataRec) << " octets/bytes. \n"; cout << "\n"; usleep(100000); //usleep est en ms 100000 pause pour 100 milliSeconds } return 0; }Arduino envoit :
//Union pour envoyer nos types struct dans un tableau unsigned char union COMM{ //Structure pour l'émission struct SEN { //taille de notre structure 11 bytes long ardlong ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float ardfloat; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 int ardint; //2 octet/bytes (16 bits) : -32 768 / +32 767 byte ardchar; //1 octet/bytes (8 bits) : -128 / +127 }dataSen; //Structure pour la récepetion struct REC { //taille de notre structure 12 bytes long intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 int shortintform ; //2 octet/bytes (16 bits) : -32 768 / +32 767 byte charform ; //1 octet/bytes (8 bits) : -128 / +127 byte charform2 ; //1 octet/bytes (8 bits) : -128 / +127 }dataRec; //L'envoie et la réception sont dans des tableaux //(sizeof) permet de récupérer la taille en byte de nos structures unsigned char dataSend[sizeof dataSen]; unsigned char dataRece[sizeof dataRec]; }ardSend, ardRec; void setup(){ Serial.begin (115200); //Initisalisation de notre structure dataSen ardSend.dataSen.ardlong = 1234567891; ardSend.dataSen.ardfloat = 128.354; ardSend.dataSen.ardint = 16569; ardSend.dataSen.ardchar = 120; } void loop() { //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi Serial.write (ardSend.dataSend, sizeof ardSend.dataSend); delay(100); }Pi reçoit :
----- Raspberry connecté : ----- ----- Pi reçoit d'Arduino : 7 bytes. Pi reçoit d'Arduino le short int : 1124096672 Pi reçoit d'Arduino le float : 1.10435e-38 Pi reçoit d'Arduino le short int : 0 Pi reçoit d'Arduino le char : Taille sizeof piReceive.dataReceive : 12 octets/bytes.Pour l'envoi le Gcom.cpp ne change pas, vous retrouverez les valeurs initialisés dans le code :
//initisialisation de notre structure pour l'émission - dataSen piSend.dataSen.intform = 123; piSend.dataSen.floatform = 3.14; piSend.dataSen.shortintform = 15210; piSend.dataSen.charform = 70; //Code ascii 70 vaut F piSend.dataSen.charform2 = 73; //Code ascii 73 vaut IArduino reçoit :
//Union pour envoyer nos types struct dans un tableau unsigned char union COMM{ //Structure pour l'émission struct SEN { //taille de notre structure 11 bytes long ardlong ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float ardfloat; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 int ardint; //2 octet/bytes (16 bits) : -32 768 / +32 767 byte ardchar; //1 octet/bytes (8 bits) : -128 / +127 }dataSen; //Structure pour la récepetion struct REC { //taille de notre structure 12 bytes long intform ; //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647 float floatform ; //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38 int shortintform ; //2 octet/bytes (16 bits) : -32 768 / +32 767 byte charform ; //1 octet/bytes (8 bits) : -128 / +127 byte charform2 ; //1 octet/bytes (8 bits) : -128 / +127 }dataRec; //L'envoie et la réception sont dans des tableaux //(sizeof) permet de récupérer la taille en byte de nos structures unsigned char dataSend[sizeof dataSen]; unsigned char dataRece[sizeof dataRec]; }ardSend, ardRec; void setup(){ Serial.begin (115200); //Initisalisation de notre structure dataSen ardSend.dataSen.ardlong = 1234567891; ardSend.dataSen.ardfloat = 128.354; ardSend.dataSen.ardint = 16569; ardSend.dataSen.ardchar = 120; } void loop() { //Récupére un tableau de données de la pi dans le buffer que l'on initialise dans dataRec while (Serial.available() > 0) { //if any data available Serial.readBytes (ardRec.dataRece, sizeof ardRec.dataRec); Serial.println ("Arduino reçoit Pi "); Serial.print ("Intform : "); Serial.println (ardRec.dataRec.intform); Serial.print ("Floatform : "); Serial.println (ardRec.dataRec.floatform); Serial.print ("Shortintform : "); Serial.println (ardRec.dataRec.shortintform); Serial.print ("Charform : "); Serial.println (ardRec.dataRec.charform); Serial.print ("Charform2 : "); Serial.println (ardRec.dataRec.charform2); Serial.print ("-----"); } delay(100); }Arduino reçoit (console) :
-----Arduino reçoit Pi Intform : 123 Floatform : 3.14 Shortintform : 15210 Charform : 70 Charform2 : 73
alors attendre avec millis :
uint32_t refTime = millis();
uint16_t waitingTime = 10000; // 10 secondes
// début de l'attente :
while((millis()-refTime)<waitingTime){
//Attendre
}
//Fin de l'attente
pour ce qui est de la case mémoire oui perso c'est le genre de truc que je fais mais il y a un désavantage avec ce que je fais ... Je suis contrain d'avoir les même types pour toutes mes variables...
Si mon commentaire vous a plus laissez nous un avis !
Nouveau sur Robot Maker ?
Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope aux articles, à la boutique et aux différents services disponible !
En attendant qu'une bibliothèque de fichiers 3D soit mise en place n'hésitez pas à demander si vous avez besoin du fichier 3D d'un des produits de la boutique... On l'a peut être !
Si vous souhaitez un robot pilotable par internet n'hésitez pas à visiter www.vigibot.com et à lire le sous forum dédié à vigibot!
Pilier du forum
Posté 20 février 2018 - 11:07
Cool merci pour millis(), j'avais fais un truc du genre mais sans succès me suis planté quelque part
"pour ce qui est de la case mémoire oui perso c'est le genre de truc que je fais mais il y a un désavantage avec ce que je fais ... Je suis contrain d'avoir les même types pour toutes mes variables..."
Ben si je comprend bien, ma structure à l'envoie comportant un int, char, float, arduino en réception devra avoir les mêmes ??
C'est ce que je fais déjà, il y a mieux j'imagine, mais quoi ??
Je trouvais la solution de récupérer l'adresse mémoire sympa et d'en récupérer sont contenu sur arduino, du moins l'adresse est égal à la structure correspondante sur arduino.
Staff Robot Maker
Posté 20 février 2018 - 11:57
Il y a énormément de moyen différent de faire ...
Je ne les connais pas tous et ce que moi je fais n'est peut être pas optimal .
En gros je cré un tableau côté arduino, et je cré un tableau côté raspberry pi.
Et quand l'un demande des information à l'autre elle envoi la case du tableau souhaité et le nombre n de case souhaité après.
La réponse sera alors les n cases demandées.
Si mon commentaire vous a plus laissez nous un avis !
Nouveau sur Robot Maker ?
Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope aux articles, à la boutique et aux différents services disponible !
En attendant qu'une bibliothèque de fichiers 3D soit mise en place n'hésitez pas à demander si vous avez besoin du fichier 3D d'un des produits de la boutique... On l'a peut être !
Si vous souhaitez un robot pilotable par internet n'hésitez pas à visiter www.vigibot.com et à lire le sous forum dédié à vigibot!
Pilier du forum
Posté 20 février 2018 - 12:39
Si d'autres ont des idées, je suis curieux de voir de quelles autres façons peut on procéder.
En fait je fais comme toi apparemment, ma structure se retrouve dans un tableau de l'union et est envoyé dans le buff, arduino lui à un tableau (unon et structure) de réception correspondant au type prés de celui de Pi.
Ce qu'il va falloir que je test c'est que le tableau pi de telle adresse est envoyé, et qu'arduino reçoit cette adresse et l'attribue au tableau correspondant, ça peut être une idée, non ?
Comme ça, chaque adresse qui circule dans le buffer se voient attribuer une réception automatiquement.
Modérateur et Membre passionné
Posté 20 février 2018 - 05:59
Penses-tu que tu gagneras quelque chose à organiser ton code avec des classes et des méthodes, ou un ensemble de fonctions ? Si oui, lance-toi. Si non, garde ton code tel qu'il te convient, petit Padawan.(...)
- Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?
Soit j'ai pas compris la question, soit j'ai failli hurler(...)
- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??
Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?
Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??
!
Pilier du forum
Posté 20 février 2018 - 06:18
Ouais t'a pas compris ^^, je me doute bien que je ne peux pas me servir du pointeur de pi et être appelé par arduino
Je recommence, en fait j'ai mes deux boites noir et mon tuyau pour le flux, on est d'accord que les infos qui transit dans un sens comme dans l'autre peuvent se mélanger, genre j'envoie et reçois de pi et j'envoie et reçois d'arduino, donc pas très bon je trouve. (après je ne suis qu'un Padawan, mon raisonnement n'est peut être pas bon), et donc.
Dans la boite noir PI (je fais simple) je créer un pointeur pour un tableau (%02x on va dire que c'est l'adresse mémoire), donc, c'est adresse comporte bien mon tableau et tous se qui va dedans, maintenant je veux juste faire transiter cette adresse, l'info et donc confiner et circule dans le tuyau, ensuite ARDUINO lui à aussi un pointeur vers une case en mémoire que l'on va nommer volontairement du même nom avec le même tableau et les infos qui vont bien.
En gros, j'ai un tableau sur PI qui se nomme TABSERVO (adresse mémoire %02x), qui circule dans le tuyau pour atteindre une case en mémoire avec un tableau identique et du même nom sur ARDUINO, ce qui fait, que l'info TABSERVO qui circule ira toujours au même endroit sur ARDUINO, je pense à ça pour éviter le mélange d'infos dans le flux.
Et pareil dans l'autre sens avec les capteurs par exemple, j'envoie un tableau avec toutes les données des capteurs, qui une fois arriver sur PI seront attribuées directement aux cases mémoires prévu pour.
Je parlais d'adresse mémoire c'était juste pour éviter de créer une variable de plus pour donner un nom au tableau, car un ça va, plusieurs pour les dégâts lol, non mais de la mémoire prise en plus et éviter le mélange dans le flux.
PS : j'espère être clair, car là je ne connais pas le jargon pour la suite des événements ^^ lol
Bien entendu il doit bien y avoir une meilleur solution, j'y réfléchis, R1D1 si tu as de meilleurs façons de faire je suis preneur
Pilier du forum
Posté 23 février 2018 - 07:27
Bon, bon, bon, avez vous une idée pour envoyer et recevoir en même temps, j'ai beau chercher...
J'explique, j'arrive donc à, pi envoie à arduino nickel (faut peaufiner certaines choses), mais en même temps j'aimerais que pi reçoit arduino.
Le truc, c'est que ça ne veut pas, pourtant lorsque pi n'envoie rien, arduino envoie très bien à pi.
En gros comment distinguer les deux flux si je puis dire, émission, réception.
Données (exemple infos des servos moteurs) : Pi ---> Arduino
Données (exemple tous les capteurs arduino) : Pi <--- Arduino
Staff Robot Maker
Posté 23 février 2018 - 08:03
Il n'y a pas besoin de distinguer les deux flux puisqu'ils passent sur deux fils différents ...
Je pense que j'ai pas compris ta question perso ...
Si mon commentaire vous a plus laissez nous un avis !
Nouveau sur Robot Maker ?
Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope aux articles, à la boutique et aux différents services disponible !
En attendant qu'une bibliothèque de fichiers 3D soit mise en place n'hésitez pas à demander si vous avez besoin du fichier 3D d'un des produits de la boutique... On l'a peut être !
Si vous souhaitez un robot pilotable par internet n'hésitez pas à visiter www.vigibot.com et à lire le sous forum dédié à vigibot!
Pilier du forum
Posté 23 février 2018 - 08:44
Ok, Tx et Rx, si si tu as bien compris, mais le hic si j'envoie pi vers arduino ça reçoit et que arduino envoie vers pi perso moi ça passe pas.
Si je fais pi vers arduino seulement ça passe.
Si je fais arduino vers pi seulement ça passe.
Les deux en même temps ça passe pas.
Je dois surement faire une boulette quelque part, ou j'ai oublié un truc, j'ai bien essayé de vider le buffer entre l'envoie de pi et ça réception, mais il n'y a rien de bien folichon, je recommencerai sur cette piste.
Made By Humans
Posté 24 février 2018 - 12:27
Qu'est ce qui te fait dire que ça marche pas ?
Staff Robot Maker
Posté 24 février 2018 - 01:05
Où est le code qui va avec ce que tu dis ? Et comme le dit Path : qu'est ce que tu observes en testant ton code qui te dit que ça marche pas?
Si mon commentaire vous a plus laissez nous un avis !
Nouveau sur Robot Maker ?
Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope aux articles, à la boutique et aux différents services disponible !
En attendant qu'une bibliothèque de fichiers 3D soit mise en place n'hésitez pas à demander si vous avez besoin du fichier 3D d'un des produits de la boutique... On l'a peut être !
Si vous souhaitez un robot pilotable par internet n'hésitez pas à visiter www.vigibot.com et à lire le sous forum dédié à vigibot!
Pilier du forum
Pilier du forum
Posté 24 février 2018 - 02:41
Quel bordel, se prendre autant la tête, bon je crois que j'ai trouvé, dans arduino vu que j'utilisais pas mal serial.print pour voir ce qu'il se passe dans le moniteur série et bien ça me renvoyé des infos sur le flux, maintenant que j'ai viré tous les serial.print, pi reçoit bien, en revanche je n'ai aucune idée si arduino reçoit toujours aussi bien 
j'ai pas de visuel lol
0 members, 1 guests, 0 anonymous users
