Bonsoir à tous,
cela fais quelque jours que je bricole sur le protocole SPI actuellement j'arrive à communiquer dans un sens mais dans l'autre.
Voici dans la théorie ce qu'il doit se passer.
Un logiciel via envoyé sur le port série des informations à un arduino maître qui celui-ci selon des paramètres définis envoie en SPI des informations à un second arduino esclave.
Cet esclave fait réagir un servo moteur. Jusque là tout vas très bien.
on obtient quelque chose du genre:
Logiciel envoie à l'arduino maître"<Y100"
Arduino maître interprète et envoie à l'arduino esclave "01:04:FF:01:00:00:00:00"
l'arduino esclave interprète et agis sur le servo "Rpm_1_Servo.write(100);"
maintenant je suis à l'étape:
s'il y a un creux dans la transmition logiciel, le maitre envoie "01:FF:FF:FF"
l'esclave répond par exemple "01:02:<B:04"
mais je m'y prend mal pour communiquer dans l'autre sens et les 2 arduinos se plante.
A priorie l'esclave commence à répondre mais n'envoie pas les données d'un coup il est entrecoupé par une autre boucle, et le maitre doit attendre la fin de transmition. Mais là je suppose.
Code du maitre
#include <SPI.h>
String Data_R="";//Donnée reçu de l2fs
char buf [100];//tampon de réception
volatile byte pos;//position dans le tampon
volatile boolean process_it;//information récupérée
int Priority = 9;
int Com_Avaible=10;
void setup (void)
{
Serial.begin(115200);
Serial.println("Communication Carte 1 OK");
SPI.begin ();
SPI.setClockDivider(SPI_CLOCK_DIV8);
pinMode(Priority, INPUT);
}
ISR (SPI_STC_vect)
{
if(digitalRead(Com_Avaible) == LOW)
{
byte c = SPDR; // grab byte from SPI Data Register
if (pos < sizeof (buf))
{
buf [pos++] = c;
if (c == '\n')
process_it = true;
}
}
}
void SPI_callback()
{
if (process_it)
{
buf [pos] = 0;
pos = 0;
String Buffer = buf;
Serial.print("data:");
Serial.println(Buffer);
}
process_it=false;
}
void spi_send(int com_b,int role,long info)
{
String data;
if(digitalRead(Priority) == LOW)
{
int count;
int sep=0;
int modulo=0;
//indication de l'instrument visé sur la carte réceptrice
String S_role=String(role, HEX);
if (S_role.length()<2){for(int i=0; i<2-S_role.length(); i++){data+="0";}}
data+=S_role;
data+=":";
String S_info=String(info);
//Serial.print(S_info);
if(S_info.length()%2!=0){count=int((S_info.length()/2)+1);modulo=0;}
else{count=S_info.length()/2;modulo=1;}
if(count>15){data+=String(count, HEX);}
else{data+="0";data+=String(count, HEX);}
data+=":";
if(info>=0)
{
data+="FF:";
}
else
{
data+="AA:";
info=info*-1;
}
if(modulo==1)
{
for (int i=0; i< S_info.length(); i++)
{
if(i%2!=0)
{
data+=S_info.charAt(i);
if(i+1!=S_info.length()){data+=":";}
}
else{data+=S_info.charAt(i);}
//Serial.print(data.charAt(i));
}
}
else
{
data+="0";
//Serial.print("0");
for (int i=0; i< S_info.length(); i++)
{
if((i+1)%2!=0)
{
data+=S_info.charAt(i);
if(i+1!=S_info.length()){data+=":";}
}
else{data+=S_info.charAt(i);}
//Serial.print(data.charAt(i));
}
}
//cloture des data
data+="\n";
pinMode(Com_Avaible, OUTPUT);//indicateur de donnée à réceptionné
digitalWrite(Com_Avaible, LOW);//réveil électrique de la carte réceptrice
delayMicroseconds(20);
for (int i=0; i< data.length(); i++)
{
SPI.transfer (data.charAt(i));delayMicroseconds(20);
Serial.print(data.charAt(i));
}
digitalWrite(Com_Avaible, HIGH);
pinMode(Com_Avaible, INPUT);//indicateur de donnée à réceptionné
}
}
void LESSTHAN(String& Tampon)
{
long info;
//Serial.println(Tampon); // Used for testing
if(Tampon[0]=='A'||Tampon[0]=='B'||Tampon[0]=='C' ||Tampon[0]=='Y')
{
switch(Tampon[0])
{
case 'Y'://Train avant
{
char floatbuf[32]; // make this at least big enough for the whole string
Tampon.substring(1).toCharArray(floatbuf, sizeof(floatbuf));
float Info_F = atof(floatbuf);
info=Info_F*1000000;
spi_send(10,1,info);
}
break;
case 'B'://Train gauche
break;
case 'C'://Train droit
break;
}
}
}
//....////
void Traitement (String& Commande)
{
//Serial.println(Commande);
String Tampon;
if (Commande.length() < 3) return; // Il s'agit d'un commande invalide en longueur
Tampon = Commande.substring (1); // on copie le reste de la commande dans un tampon
switch (Commande[0])
{
case '=':
EQUALS(Tampon);
break;
case '#':
DIESE(Tampon);
break;
case '<':
LESSTHAN(Tampon);
break;
case '?':
QUESTION(Tampon);
break;
case '/':
SLASH(Tampon);
break;
default:
break;
}
}
void loop()
{
unsigned int td = millis();
char Bloc; //Donnée extraite
//!!début!!récupération des donnéees envoyés par l2fs
while (Serial.available()) //Tant qu'il y a des données sur le port série
{
Bloc=Serial.read(); //on stock le caractére
if((Bloc == '=') || (Bloc == '#') || (Bloc == '<') || (Bloc == '?') || (Bloc == '/') || (Bloc == '\r') || (Bloc == '\n')) //Si on a affaire à un char de fin de commande
{
// Si on a une chaine déjà entamée il s'agit d'une fin de commande
if (Data_R.length()>1)
{
Traitement (Data_R);// La commande est complète alors on l'analyse
Data_R="";//On réinitialise Le tampon d'entrée avec le premier char de commande
}
}
if ((Bloc!='\n') && (Bloc!='\r'))
{
Data_R+= Bloc;
}
}
//SPI_callback();
}