Ok, découpage étonnant des tâches, mais faisons avec 
Donc si l'on veut passer au client, il faut que ton second arduino fasse l'équivalent du telnet, c'est aussi simple que cela (TelnetClient).
C'est le prof' qui a voulu ça... x)
J'ai fais un test avec la carte serveur ( ChatServer ) et la carte client ( TelnetClient ).
Mais le moniteur de la carte client marque : "connecting.... connection failed disconecting"
Je précise que les PC sur lesquels je fais ces test n'ont pas de connection Internet ! Cela influe-t-il en quelque chose ?
Nous n'avons toujours pas de boule de cristal donc sans ton code, on ne peut pas t'aider.
Autant pour moi il faut que je m'y habitue.
Voila le code serveur :
*/
created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = {
0x90, 0xA2, 0xDA, 0x0E, 0xD4, 0x03 };
IPAddress ip(192,168,0, 50);
EthernetServer server(23);
boolean alreadyConnected = false;
void setup() {
Ethernet.begin(mac, ip);
server.begin();
Serial.begin(9600);
while (!Serial) {
;
}
Serial.print("Chat server address:");
Serial.println(Ethernet.localIP());
}
void loop() {
EthernetClient client = server.available();
if (client) {
if (!alreadyConnected) {
client.flush();
Serial.println("We have a new client");
client.println("Hello, client!");
alreadyConnected = true;
}
if (client.available() > 0) {
int thisChar = client.read();
server.write(thisChar);
Serial.write(thisChar);
}
}
}
Et voilà le code client :
/*
created 14 Sep 2010
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = {
0x90, 0xA2, 0xDA, 0x0E, 0xD4, 0x05 };
IPAddress ip(192,168,0,55);
IPAddress server(192,168,0,50);
EthernetClient client;
void setup() {
Ethernet.begin(mac, ip);
Serial.begin(9600);
while (!Serial) {
;
}
delay(1000);
Serial.println("connecting...");
if (client.connect(server, 10002)) {
Serial.println("connected");
}
else {
Serial.println("connection failed");
}
}
void loop()
{
if (client.available()) {
char c = client.read();
Serial.print(c);
}
while (Serial.available() > 0) {
char inChar = Serial.read();
if (client.connected()) {
client.print(inChar);
}
}
if (!client.connected()) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
while(true);
}
}
Le programme fonctionne comme prévu, à toi de chercher un peu d'où vient le problème à partir des messages que tu as.
Message dans le moniteur du serveur : "Chat server address: 192.168.0.50"
Message dans le moniteur du client :
" connecting...
connection failed
disconnecting... "
Les deux fenêtres de cmd Telnet sont connectées au 192.168.0.50.
Merci, j'avais déjà bien vu les messages la première fois mais à toi de bosser un peu. Les messages sont suffisamment clairs pour que tu puisses trouver d'où vient le problème (surtout que tu n'es pas un demeuré et que tu comprends le code que tu utilises)
Le problème est que je n'ai pas 50heures dans le semaine pour avancer ( je ne peux pas avancer chez moi étant donné que je n'ai pas le matériel nécessaire pour faire ces tests ).
Je trouve ça donc dommage de buter sur un truc pareil.
J'ai beau bosser autant que je veux le prof je ne veut pas nous aider.
Aller, un petit coup de pouce 
Tu as RDV chez Toto qui habite 23 rue des réseaux. Tu arrives dans la rue des réseaux, et tu toques au 10002. Tu crois que Toto qui va te répondre ?
---- morale à 2 sous ---
Tu es en STI ? Ca sous-entend que tu apprécies un minimum certaines technologies. Si l'éléctronique ou l'informatique (programmation ou systèmes) te plaisent un minimum, je pense qu'investir dans 2-3 bricoles n'est pas la fin du monde. (Je dis ça en admettant que ton niveau financier se trouve dans la moyenne d'un étudiant actuel, si c'est pas le cas on oublie ce que j'ai dit)
Merci vohu !!!! C'était tout simple en fait... ^-^'
Oui j'adore la technologie notamment tout ce qui touche à l'hardware d'un PC ^^
J'aimerai beaucoup investir dans du matériel pour m'entraîner chez moi mais mes conditions avec ma famille ( financier et relationnel ) ne me le permette pas.
Kindabad:
qu'enlevé le gateway et le masque , ce qui est inutile sur un réseau local je pense ) :
Commence par remettre le masque... Le prorocole IP fait un & logique entre l'@ip de l'émetteur et le masque, puis un & logique entre l'@IP du destinataire et le masque pour déterminer s'ils sont sur le même réseau.
D'accord , je vais t'écouter , je vais remettre le masque réseau.
J'ai donc réussi à faire communiquer mes deux cartes avec une en serveur utilisant l'exemple ChatServer et l'autre en tant que client avec l'exemple TelnetClient.
Le prof me demande maintenant :
-
Primo , utiliser la carte client ( exemple TelnetClient , en modifiant celui-ci ) afin d'envoyer continuellement le caractère "a" puis "z" continuellement au moniteur du serveur avec un petit delay entre chaque lettre. Et je dois enlever le moniteur de la carte client ( Le programme s'exécute tout seul à l'infini après le téléversement ).
-
Secondo , faire la même chose en remplaçant le "a" par "86" et le "b" par "72" et les divisés par 2 à l'affichage sur le moniteur du serveur. Il m'a bien précisé d'indiquer que ces valeurs étaient des chiffres ( par rapport au code ASCII )
J'me lance de suite sur la première étape et je vous envoies le code dès que j'ai réussi où si je bloque VRAIMENT ( sois dit en passant pour bigben99 qui a tendance à mettre tous les STI2D dans le même sac )
Bonjour , après presque 2 mois d'absence me revoilà pour vous donner de gros résultats ^^
J'arrive à la fin du projet malgré la désertion de deux de nos partenaire sur le projet... --'
Donc je rappelle rapidement :
Une carte "reliée" aux capteurs du gants qui , en passant par un LAN , va communiquer avec une autre carte "reliée" aux servomoteurs du bras Dagu.
Voilà ce que mon collègue et moi avons pu trouver pour la partie emission ( carte du gant avec capteurs )
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <Wire.h>
#define CTRL_REG1 0x20
#define CTRL_REG2 0x21
#define CTRL_REG3 0x22
#define CTRL_REG4 0x23
#define CTRL_REG5 0x24
int L3G4200D_Address = 105;
int L3G4200D_Address2 = 104;
int x;
int x2;
int y;
int y2;
int z;
int z2;
int axe_x;
int axe_x2;
int axe_y;
int axe_y2;
int axe_z;
int axe_z2;
int flex = 0 ;
int flex2 = 0 ;
const int potentiometre = 0 ;
const int potentiometre2 = 1 ;
byte MAC[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xD4, 0x05 };
IPAddress IP (192,168,0,51);
unsigned int localPort = 8888;
IPAddress IP_recepteur (192, 168, 0, 50);
const int TABLEAU_DONNEE= 10;
byte AFFICHAGE_DONNEE[TABLEAU_DONNEE];
EthernetUDP Udp;
void setup()
{
Ethernet.begin(MAC, IP);
Udp.begin(localPort);
Serial.begin(9600);
Wire.begin();
setupL3G4200D(2000);
setupL3G4200D2(2000);
delay(1500);
}
void loop()
{
Val_Capteurs();
Conversion_Degres();
sendNTPpacket(IP_recepteur);
delay(2000);
}
unsigned long sendNTPpacket(IPAddress& address)
{
memset(AFFICHAGE_DONNEE,0, TABLEAU_DONNEE);
AFFICHAGE_DONNEE[0] = axe_x;
AFFICHAGE_DONNEE[1] = axe_z;
AFFICHAGE_DONNEE[2] = axe_x2;
AFFICHAGE_DONNEE[3] = axe_y2;
AFFICHAGE_DONNEE[4] = flex;
AFFICHAGE_DONNEE[5] = flex2;
Udp.beginPacket(address, localPort);
Udp.write(AFFICHAGE_DONNEE, TABLEAU_DONNEE);
Udp.endPacket();
}
void Val_Capteurs()
{
flex = analogRead(potentiometre);
flex2 = analogRead(potentiometre2);
getGyroValues();
getGyroValues2();
}
void Conversion_Degres()
{
axe_x = x * 0.18;
axe_y = y * 0.18;
axe_z = z * 0.18;
axe_x2 = x2 * 0.18;
axe_y2 = y2 * 0.18;
axe_z2 = z2 * 0.18;
Serial.println(axe_x);
Serial.println(axe_z);
Serial.println(axe_x2);
Serial.println(axe_y2);
Serial.println(flex);
Serial.println(flex2);
delay(2000);
}
void getGyroValues()
{
byte xMSB = readRegister(L3G4200D_Address, 0x29);
byte xLSB = readRegister(L3G4200D_Address, 0x28);
x = ((xMSB << 8) | xLSB);
byte yMSB = readRegister(L3G4200D_Address, 0x2B);
byte yLSB = readRegister(L3G4200D_Address, 0x2A);
y = ((yMSB << 8) | yLSB);
byte zMSB = readRegister(L3G4200D_Address, 0x2D);
byte zLSB = readRegister(L3G4200D_Address, 0x2C);
z = ((zMSB << 8) | zLSB);
}
void getGyroValues2()
{
byte x2MSB = readRegister(L3G4200D_Address2, 0x29);
byte x2LSB = readRegister(L3G4200D_Address2, 0x28);
x2 = ((x2MSB << 8) | x2LSB);
byte y2MSB = readRegister(L3G4200D_Address2, 0x2B);
byte y2LSB = readRegister(L3G4200D_Address2, 0x2A);
y2 = ((y2MSB << 8) | y2LSB);
byte z2MSB = readRegister(L3G4200D_Address2, 0x2D);
byte z2LSB = readRegister2(L3G4200D_Address2, 0x2C);
z2 = ((z2MSB << 8) | z2LSB);
}
int setupL3G4200D(int scale)
{
writeRegister(L3G4200D_Address, CTRL_REG1, 0b00001111);
writeRegister(L3G4200D_Address, CTRL_REG2, 0b00000000);
writeRegister(L3G4200D_Address, CTRL_REG3, 0b00001000);
if(scale == 250)
{
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00000000);
}
else if(scale == 500)
{
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00010000);
}
else
{
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00110000);
}
writeRegister(L3G4200D_Address, CTRL_REG5, 0b00000000);
}
int setupL3G4200D2(int scale2)
{
writeRegister(L3G4200D_Address2, CTRL_REG1, 0b00001111);
writeRegister(L3G4200D_Address2, CTRL_REG2, 0b00000000);
writeRegister(L3G4200D_Address2, CTRL_REG3, 0b00001000);
if(scale2 == 250)
{
writeRegister(L3G4200D_Address2, CTRL_REG4, 0b00000000);
}
else if(scale2 == 500)
{
writeRegister(L3G4200D_Address2, CTRL_REG4, 0b00110000);
}
writeRegister(L3G4200D_Address2, CTRL_REG5, 0b00000000);
}
void writeRegister(int deviceAddress2, byte address2, byte val)
{
Wire.beginTransmission(deviceAddress2);
Wire.write(address2);
Wire.write(val);
Wire.endTransmission();
}
void writeRegister2(int deviceAddress3, byte address3, byte val2)
{
Wire.beginTransmission(deviceAddress3);
Wire.write(address3);
Wire.write(val2);
Wire.endTransmission();
}
int readRegister(int deviceAddress2, byte address2)
{
int v;
Wire.beginTransmission(deviceAddress2);
Wire.write(address2);
Wire.endTransmission();
Wire.requestFrom(deviceAddress2, 1);
while(!Wire.available())
{
}
v = Wire.read();
return v;
}
int readRegister2(int deviceAddress3, byte address3)
{
int v2;
Wire.beginTransmission(deviceAddress3);
Wire.write(address3);
Wire.endTransmission();
Wire.requestFrom(deviceAddress3, 1);
while(!Wire.available())
{
}
v2 = Wire.read();
return v2;
}
En ce qui concerne l'autre partie , étant donné que le travail du maniement des servomoteurs était destiné à un des deux collègue qui s'est barré bah on dois se retaper le travail à 0... J'ai moi même fais les parties réseau des deux programmes des cartes , voilà pour la partie "réception" :
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
byte MAC[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xD4, 0x03 };
IPAddress IP (192,168,0,50);
unsigned int localPort = 8888;
const int TABLEAU_DONNEE =10;
byte AFFICHAGE_DONNEE [TABLEAU_DONNEE];
EthernetUDP Udp;
void setup()
{
Serial.begin(9600);
Ethernet.begin(MAC, IP);
Udp.begin(localPort);
}
void loop()
{
delay(2000);
if ( Udp.parsePacket() )
{
Udp.read(AFFICHAGE_DONNEE, TABLEAU_DONNEE);
Serial.println(AFFICHAGE_DONNEE[0]);
Serial.println(AFFICHAGE_DONNEE[1]);
Serial.println(AFFICHAGE_DONNEE[2]);
Serial.println(AFFICHAGE_DONNEE[3]);
Serial.println(AFFICHAGE_DONNEE[4]);
Serial.println(AFFICHAGE_DONNEE[5]);
}
}
Donc , après être si prêt du but , auriez vous des astuces pour pouvoir finir cette partie et donc pouvoir contrôler les 6 servomoteurs du bras ( Nous avons commencés à apprendre à contrôler un seul servomoteur pour le moment. )
Je tenais à vous remercier pour votre présence au début du projet qui m'a fort aidé.
En attendant vos réponses
Peux-tu nous dire exactement où tu coinces ? La lecture des capteurs et l'envoi des valeurs entre les 2 arduinos fonctionnent ?
Concernant ton émetteur, tu as énormément de code redondant, beaucoup de méthodes sont doublées alors que ce n'est pas nécessaire.
Je coince pas vraiment en fait, ça va prendre un peu de temps mais on va apprendre à se servir des servos , je voulais savoir s'il y avait des facilités par rapport à mon projet , je voulais aussi vous tenir informés de ma progression. ^^
Oui les deux programmes fonctionnent parfaitement entre eux. ( Le serial de la carte receptrice affiche les mêmes valeurs que celles de la carte emettrice )
Je précise qu'il y a deux capteurs gyroscopiques ainsi que deux flexomètres. J'ai sûrement oublié de le préciser.
Dans le cas contraire , comment réduire le code ?
Merci
Par exemple, tes methodes getGyroValues() et getGyroValues2() font exactement la même chose, la seule différence c'est l'adresse de lecture et les variables pour stocker les résultats de lecture. Donc tu pourrais passer en paramètre l'adresse et factoriser ton code.
void getGyroValues(int address, int& x, int& y, int& z) {
byte xMSB = readRegister(address, 0x29);
byte xLSB = readRegister(address, 0x28);
x = ((xMSB << 8) | xLSB);
byte yMSB = readRegister(address, 0x2B);
byte yLSB = readRegister(address, 0x2A);
y = ((yMSB << 8) | yLSB);
byte zMSB = readRegister(address, 0x2D);
byte zLSB = readRegister(address, 0x2C);
z = ((zMSB << 8) | zLSB);
}
La méthode peut maintenant être appelée pour lire les 2 gyro
getGyroValues(L3G4200D_Address, x, y, z);
getGyroValues(L3G4200D_Address2, x2, y2, z2);
Tu peux factoriser de la même façon les méthodes setupL3G4200D, writeRegister et readRegister