[PIC18] - Liaison SPI entre 2 PIC

[jorg1n]

Bonjour,

je sais que ce sujet a été traité maintes et maintes fois, mais je ne trouve rien!!

le principe:
-J'ai un PIC18F6722 configuré en maitre:

 SSP1CON1 = 0b00100001;
 SSP1STAT = 0b10000000;

-J'ai un PIC18F14K22 configuré en esclave:

 SSPCON1 = 0b00100100;
 SSPSTAT = 0b00000000;

Voila une ma transmission coté maitre:

SS_COMPIC = 1;													// Désactivation Communication SPI -> µC Communication
for(us=0; us<=1; us++);											// Temporisation
SS_COMPIC = 0;													// Activation Communication SPI -> µC Communication
for(us=0; us<=1; us++);											// Temporisation 

ClearRegister = SSP1BUF;										// Clear du bit BF / Vidage du Registe
SSP1BUF = TypeDefaut;											// Chargement dans le registre de la donnée a transmettre
while (!SSP1STATbits.BF); 										// Attente de fin de transmission
ClearRegister = SSP1BUF;										// Clear du bit BF / Vidage du Registe

for(us=0; us<=1; us++);											// Temporisation 
SS_COMPIC = 1;													// Désactivation Communication SPI -> µC Communication

Et voila ma partie réception, qui ce trouve dans mon main():

if (SS_COMPIC == 0) // Si sélection du µC de Communication pour liaison SPI
{
ClearRegister = SSPBUF; // Clear du bit BF / Vidage du Registe
while (!SSPSTATbits.BF); // Attente de fin de transmission
TypeDefautRegister = SSPBUF; // Récupération de la donnée

}

J'ai visualisé a l'oscillo, j'ai bien mon SCK qui part de mon maitre, avec les données qui arrive sur SDI de mon µC Esclave...

Mais ensuite... rien ne se passe!

Alors, ma routine de réception vous parait elle correcte?

Merci d'avance
-----

[RISC]

Salut,

Le port SPI est multiplexé avec pas mal d'autres signaux. As-tu initialisé les registres ANSEL et ANSELH ainsi que le registre TRIS pour permettre aux broches du port SPI d'être en digital ?

a+

[jorg1n]

Bonjour RISC,

merci pour ton aide, en fait, j'ai trouvé mon erreur, je gérais ma transmission au niveau du maitre. Sans la temporisation de fin, ça marche parfaitement:

SS_COMPIC = 1; // Désactivation Communication SPI -> µC Communication
for(us=0; us<=1; us++); // Temporisation
SS_COMPIC = 0; // Activation Communication SPI -> µC Communication
for(us=0; us<=1; us++); // Temporisation

ClearRegister = SSP1BUF; // Clear du bit BF / Vidage du Registe
SSP1BUF = TypeDefaut; // Chargement dans le registre de la donnée a transmettre
while (!SSP1STATbits.BF); // Attente de fin de transmission
ClearRegister = SSP1BUF; // Clear du bit BF / Vidage du Registe

for(us=0; us<=1; us++); // Temporisation --> A SUPPRIMER
SS_COMPIC = 1;

Maintenant, tout marche parfaitement...

[jorg1n]

Bonjour à tous,

bon, je reviens avec ma liaison série SPI...
j'ai un microcontroleur qui est configuré en maitre, et un autre en esclave.
Ce que je souhaite faire, c'est envoyer des informations du maitre vers l'esclave : j'arrive a faire cela avec le code si dessous:

-Programme coté Maitre:

SS_COM = 0;														// Activation Communication SPI -> µC SERIAL LINK
for(us=0; us<=1; us++);											// Temporisation 

ClearRegister = SSPBUF;											// Clear du bit BF / Vidage du Registe
SSPBUF = ReadRegister_1;										// Chargement dans le registre de la donnée a transmettre
while (!SSPSTATbits.BF); 										// Attente de fin de transmission
SS_COM = 1;

-Programme coté Esclave:

	ClearRegister = SSPBUF;							// Clear du bit BF / Vidage du Registe
	while (!SSPSTATbits.BF); 						// Attente de fin de transmission
	ReadRegister_1  = SSPBUF;						// Récupération de la donnée

Mais maintenant, je souhaite pouvoir aussi récupérer des données issues de l'esclave, et je n'y arrive pas...

J'imagine que je dois faire envoyer une trame "vide" du maitre afin de faire transmettre la donnée souhaitée de l'esclave au maitre... mais je n'y arrive pas...
voila comment je pensais faire:

-Programme coté Maitre:

	ClearRegister = SSPBUF;							// Clear du bit BF / Vidage du Registe
	SSPBUF = FrameDummy;							// Chargement dans le registre de la donnée a transmettre
	while (!SSPSTATbits.BF); 						// Attente de fin de transmission
	WriteCmdRegister_1  = SSPBUF;					// Récupération de la donnée

-Programme coté Esclave:

SSPBUF = WriteCmdRegister_1;									// Chargement dans le registre de la donnée a transmettre
while (!SSPSTATbits.BF);

Mais ça ne marche pas...

Auriez vous une idée...

Merci d'avance...

Et Bonne Année 2011 à tous!!!

[A voir en vidéo sur Futura]

[jorg1n]

Ou alors, dès que le maitre a terminé sa transmission, je le configure en esclave et inversement pour l'autre?

Un petit coup de pouce serait le bienvenue!!

Merci d'avance

[jorg1n]

Bonjour,

je suis un peu perdu, ... j'essaie plein de chose, et rien ne marche correctement!

Parfois je reçois de la part de l'esclave, le dernier mot de 8 bits que je lui avait précédemment envoyé...

J'imagine que je dois mal faire mon envoi...

Pourriez vous m'aiguiller...

Merci d'avance

[jorg1n]

Bonjour à tous...

une petite aide serait la bienvenue !! UP!

Bonne journée à tous ...

[jorg1n]

Bonjour à tous,

je reviens toujours avec le même soucis...
j'ai pensé un moment avoir réussi ce que je voulais faire, mais il y avait par moment des erreurs de transmission... alors je me suis lancé dans un driver "maison" pour faire communiqué les 2 PICs, ça a marché, mais ça plante parfois...

Alors je vais revenir sur l'utilisation du Module SPI et j'ai une question:

L'apparition d'une interruption dû au Timer ou au module EUSART (RS422) peut il provoquer une erreur dans la transmission ?

Merci d'avance, Bonne fin de journée à tous

[jorg1n]

Bonjour,

je reviens vers vous encore une fois, je suis désespéré... je n'y arrive pas!

Un envoi ça marche, j'en fais une douzaine à suivre, ça "déconne". les valeurs arrivent décalées,... ou erronées dans le pire des cas.

J'utilise les fonctions de la librairie spi.c du compilateur C18 de Microchip:

unsigned char WriteSPI( unsigned char data_out )
{
  PIR1bits.SSPIF = 0;
  SSPBUF = data_out;           // write byte to SSPBUF register
  if ( SSPCON1 & 0x80 )        // test if write collision occurred
   return ( -1 );              // if WCOL bit is set return negative #
  else
  {
    while( !PIR1bits.SSPIF );  // wait until bus cycle complete 
  }
  return ( 0 );                // if WCOL bit is not set return non-negative#
}

et

unsigned char ReadSPI( void )
{
  SSPBUF = 0x00;                  // initiate bus cycle
  while ( !SSPSTATbits.BF );      // wait until cycle complete
  return ( SSPBUF );              // return with byte read 
}

Voila le déroulement:

Coté maitre:
WriteSPI ( a );
WriteSPI ( b );
WriteSPI ( c );
WriteSPI ( d );
...

Coté esclave :
a = ReadSPI();
b = ReadSPI();
c = ReadSPI();
d = ReadSPI();
...

Auriez vous une idée, une piste pour m'aider...
Merci d'avance,

[RISC]

Salut,

A tout hasard, vérifie si ton PIC18F6722 est récent (datecode sur le boitier ?). La vieille version du silicium ( 3 à 4 ans ?) de ce PIC avait un nombre important de bugs dont certains sur le module SPI (voir les erratasheets.

a+

[jorg1n]

Merci RISC,

je vais regarder ça... mais maintenant j'essaye de le faire avec un PIC18F4520 et un PIC18F2520.

Merci d'avance pour votre aide

[ftorama]

Le bus SPI est un bus full-duplex, c'est à dire que tu reçois en même temps que tu émets.

De plus, ça fonctionne comme un système de deux registres à décalage qui échangent leur contenu. Pour échanger une donnée, tu places une donnée dans le registre du maître (appelons le SPIDATA, je sais pas son nom sur PIC) et tu lances la transmission de l'octet.

A la fin de la transmission, le SPIDATA du maître a été transféré dans le SPIDATA de l'esclave et réciproquement.

Si effectivement, tu veux recevoir des données plus longues que la commande, il faut ajouter des octets sans signification à la fin de la trame, qui seront échangés avec les données valides, ou octets de padding.

Prenons un exemple. Tu as une commande pour lire cette donnée de 16 bits qui est 0x40, et la donnée dans l'esclave est 0x1234.

La trame maître pourrait être 0x40 0xFF 0xFF.

0x40 est la commande, les 0xFF, le padding. On aurait pu mettre des 0x00 ou n'importe quoi d'autre, vu qu'ils sont là pour du remplissage.

L'esclave répondra: xx 0x12 0x34

Le premier octet ne veut rien dire (puisque l'esclave l'a émis en même temps qu'il recevait la commande, donc ne la connaissait pas encore). Cet octet peut être un résidu de la transmission précédente, ou tu peux très bien l'avoir initialisée comme bon te semble.

Ensuite seulement, la transmission utile a lieu. En aucun cas, tu n'as besoin de changer les rôles de maître et d'esclave, et d'ailleurs, ce serait quasi-impossible à gérer.

Pour faire simple, il n'y a pas de fonctions d'envoi ou d'émission en SPI, mais une seule fonction de transmission, faisant office d'émission et de réception.

Fais également attention à la configuration de l'horloge de ton bus SPI, symbolisée par les signaux CPOL et CPHA ou parfois appelé simple mode. Tu trouveras de bonnes infos sur Wikipedia:
http://en.wikipedia.org/wiki/Serial_..._Interface_Bus

Une chose à savoir aussi est que le SPI n'est pas un standard comme les autres, et qu'il n'est pas régi par des règles aussi strictes. On pourra trouver des transmissions sur n bits, des signaux de validation de polarités variables mais aussi de la transmission sur un seul fil. Bref, dans ton cas, tu as juste à déterminer tes réglages et les implémenter dans le maître et l'esclave. Quand tu utilises des circuits autres, il faut te coller aux specs de ces derniers, et parfois changer la config du bus pour chaque esclave.

[jorg1n]

Merci Ftorama,

je vais regarder en détail ce que tu m'as dit...

Merci d'avance à ceux qui pourront aussi m'aider

Bonne journée à tous

[jorg1n]

Bon jour,

j'ai une petite question:

quelle est la différence entre le bit PIR1.SSPIF et le bit SSPSTAT.BF?

A priori on peut utiliser les 2 a conditions d'avoir activé le bit PIE.SSPIE si on veut utiliser le bit PIR1.SSPIF ?

C'est ça?

Merci d'avance,

[jorg1n]

Bonjour,

je reviens, car je n'arrive toujours pas a faire ce que je souhaite...
L'échange entre le maitre et l'esclave ce passe parfaitement, pas de décalage, les données sont correctement transmises...
Par contre dès que je souhaite récupérer des données de l'esclave, ça marche moins bien.
J'arrive quelques fois a récupérer les 2 mots de 8bits que je souhaite, mais c'est plus souvent la "fausse trame" (DumRegister) qu'envoi le maitre que je reçois.

Pour information:
Maitre : PIC18F4520 / datecode : 1030J9G / Device ID Revision = 00000007
Esclave : PIC18F2520 / datecode : 1033633 / Device ID Revision = 00000007

Voila mon code coté maitre :

	SS_SLINK = 0;												
	ActivateDELAY ();												// Temporisation
	
//****************************ENVOI ReadRegister_1 
	SSPBUF = ReadRegister_1;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe
	
//****************************ENVOI ReadRegister_2 
	SSPBUF = ReadRegister_2;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI ReadRegister_3 
	SSPBUF = ReadRegister_3;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI ReadRegister_4 
	SSPBUF = ReadRegister_4;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe	

////****************************ENVOI ReadRegister_5 
	SSPBUF = ReadRegister_5;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI ReadRegister_6 
	SSPBUF = ReadRegister_6;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI ReadRegister_7 
	SSPBUF = ReadRegister_7;										// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI UBatSystRegister_MSB 
	SSPBUF = UBatSystRegister_MSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI UBatSystRegister_LSB 
	SSPBUF = UBatSystRegister_LSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI IBatSystRegister_MSB
	SSPBUF = IBatSystRegister_MSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI IBatSystRegister_LSB
	SSPBUF = IBatSystRegister_LSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI TCoffretRegister_MSB 
	SSPBUF = TCoffretRegister_MSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************ENVOI TCoffretRegister_LSB 
	SSPBUF = TCoffretRegister_LSB;									// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	ClearRegister =	SSPBUF;											// Clear du bit BF / Vidage du Registe

////****************************RECEPTION WriteCmdRegister_1
	SSPBUF = DumRegister;											// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	WriteCmdRegister_1 = SSPBUF;									// Clear du bit BF / Vidage du Registe	
	
////****************************RECEPTION WriteCmdRegister_2 
	SSPBUF = DumRegister2;											// Chargement dans le registre de la donnée a transmettre
	while (SSPSTATbits.BF == 0); 									// Attente de fin de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	TransmitDELAY();												// Temporisation - Attente de transmission
	WriteCmdRegister_2 = SSPBUF;									// Clear du bit BF / Vidage du Registe	

// Arrêt d'échange SPI
	ActivateDELAY ();												// Temporisation
	SS_SLINK = 1;													// Désactivation Communication SPI

Et mon code coté Esclave:

  ClearRegister = SSPBUF;							// Clear du bit BF / Vidage du Registe

//****************************RECEPTION ReadRegister_1
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_1  = SSPBUF;							// Récupération de la donnée

//****************************RECEPTION ReadRegister_2
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_2  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION ReadRegister_3
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_3  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION ReadRegister_4
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_4  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION ReadRegister_5 
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_5  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION ReadRegister_6 
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_6  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION ReadRegister_7 
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ReadRegister_7  = SSPBUF;							// Récupération de la donnée

////****************************RECEPTION UBatSystRegister_MSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  UBatSystRegister_MSB  = SSPBUF;					// Récupération de la donnée

////****************************RECEPTION UBatSystRegister_LSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  UBatSystRegister_LSB  = SSPBUF;					// Récupération de la donnée

////****************************RECEPTION IBatSystRegister_MSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  IBatSystRegister_MSB  = SSPBUF;					// Récupération de la donnée

////****************************RECEPTION IBatSystRegister_LSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  IBatSystRegister_LSB  = SSPBUF;					// Récupération de la donnée

////****************************RECEPTION TCoffretRegister_MSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  TCoffretRegister_MSB  = SSPBUF;					// Récupération de la donnée

////****************************RECEPTION TCoffretRegister_LSB
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  TCoffretRegister_LSB  = SSPBUF;					// Récupération de la donnée

////****************************ENVOI WriteCmdRegister_1
  SSPBUF  = WriteCmdRegister_1;						// Modification de la donnée pour renvoi
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ClearRegister = SSPBUF;							// Clear du bit BF / Vidage du Registe

////****************************ENVOI WriteCmdRegister_2
  SSPBUF  = WriteCmdRegister_2;						// Modification de la donnée pour renvoi
  while (!SSPSTATbits.BF); 							// Attente de fin de transmission
  ClearRegister = SSPBUF;							// Clear du bit BF / Vidage du Registe

Et voici les configurations:
Maitre:

 OpenSPI (SPI_FOSC_64, MODE_11, SMPMID);

Esclave:

 OpenSPI (SLV_SSON, MODE_11, SMPMID);

Désolé pour ce long message mais, vous avez toutes les informations par contre...

Merci d'avance pour votre aide