[aide] EEPROM AT93C46 protocole SPI

Non mais la y'a des gros soucis dans le code, pourquoi envoyer 01 avant ? Deja quelle organisation as-tu choisi : 8 ou 16 bit ?

Ensuite ton code devrait plus ressembler à ça (en mode 8 bits):

#include <SPI.h>

const int cs = 10;
int data=0;

void Read(int adresse)//lecture
{
long Command=0b110<<7;
Command&=adresse;
digitalWrite(cs,LOW);
delaymicroseconds(10);
 SPI.transfer(Command);
data=SPI.tranfer(0);
digitalWrite(cs,HIGH);
}

void Write(int adresse,int donnees)//écriture
{
long Command=0b101<<7;
Command&=adresse;
Command<<8;
Command&=donnees;
  digitalWrite(cs,LOW);
delaymicroseconds(10);
  SPI.transfer(Command);
  digitalWrite(cs,HIGH);
}

}

void setup()
{
  pinMode(cs,OUTPUT);
 digitalWrite(cs,HIGH);
   
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);// mode 0. Au repos l'horloge est à 0 (CPOL = 0). les données sont prises en compte sur un front montant de l'horloge (CPHA = 0).
  SPI.setClockDivider(SPI_CLOCK_DIV8);// sk 2mhz, 16 MHz diviser par 8.
  SPI.begin();
  Serial.begin(9600);
}

void loop()
{
  Write(50,100);
  Read(50);
  
  Serial.println(data);
  delay(1000);
}

J'ai indiquer dans le premier poste que je travaillais en 8 bit,

Sinon dans ton code ne donne pas plus de résultat, et tu a inverser l'état des broche cs vu que ses du wire 3,
J'ai découvert qu'il y avais une autre appelle a faire lors de wire

Write Operation:
Enable device via chip select high
Send write enable op code ******************************
Disable device via chip select low
Enable device via chip select high
Send write op code with address
Send data byte/word
Write cycle begins
Disable device via chip select low

La ligne que j'ai indiquer fait référence a

EWEN |1|00|11XXXXX|11XXXX| Write enable must precede all |
programming modes

dans le datasheet

Sinon grand merci a B@tto car tu ma fais découvrir l'utilisation de Bitwise Operators,
Je vais continuer de m'acharner pour faire fonctionner cette eeprom.

j'ai travailler sur la base de ton code, voici se que j'ai obtenu

void Read(int adresse)//lecture
{
long Command=0b110<<7;
Command|=adresse;
Serial.print("  ");
Serial.println(Command,BIN);
digitalWrite(cs,HIGH);
delay(10);
SPI.transfer(Command);
data=SPI.transfer(0);
digitalWrite(cs,LOW);
}

void Write(int adresse,int donnees)//écriture
{
long Command=0b010<<8;
 Command|=adresse;
 Serial.print(Command,BIN);
 Serial.print("  ");
 digitalWrite(cs,HIGH);
 delay(10);
  SPI.transfer(Command);
  SPI.transfer(donnees);
  digitalWrite(cs,LOW);
}

j'ai donc ceci qui s'affiche

1000110010 1100110010
247
247
247
...

théoriquement il devrais m'envoyer 100 comme valeur, donc si quelqu'un a une explication ?

A mon avis ça vient de la le problème

SPI.transfer(Command);
  SPI.transfer(donnees);

imagine du envoi la donnée 2 : ça va faire 10 au lieu de 00000010
Il faut faire comme je l'avais fait, décaler command et ajouter données et envoyer le tout

J'ai refait le code mais cette fois si en rajoutent Ewen qui est a mettre selon la documentation et toujours aucun changement.

void Write(int adresse,int donnees)//écriture
{
long Ewen = 0b0011000000;

long Command=0b010<<8;
 Command|=adresse;
 Command<<=8;
 Command|=donnees;
 Serial.print(Command,BIN);
 Serial.print("  ");
 digitalWrite(cs,HIGH);
 delay(10);
  SPI.transfer(Ewen);
  SPI.transfer(0x01);
  digitalWrite(cs,LOW);
 digitalWrite(cs,HIGH);
 delay(10);
  SPI.transfer(Command);
  digitalWrite(cs,LOW);
}

Voici ce que j'ai dans la console.

100011000101100100 1100110001
247
247
247
...

Une lecture attentive de la doc de l'EEPROM et de la doc de la librairie SPI montre que les deux ne peuvent pas coucher ensemble.
L'EEPROM attend des paramètres sur 10bits en entrée alors que la méthode transfer() de la librairie SPI manipule des octets
Il va falloir que tu écrives ta propre librairie pour supporter ta mémoire. C'est pas super compliqué mais par contre tu ne pourras pas utiliser le SPI matériel. Du coup cela te permets de connecter la mémoire sur n'importe quelle IO.
En fait, il faut bien voir, que le SPI n'est pas du tout standardisé comme l'I²C ou le RS232 par exemple. Et du coup chaque fabricant l'implémente comme il l'entend. Utiliser le SPI c'est un peu partir à l'aventure. Alors laisse s'exprimer l'explorateur qui dort en toi.....

Pour ce qui est d'une lecture attentive de la doc de l'eeprom, je n'arrête pas de la lire je la connais par cœur pratiquement,
Pour ce qui est du spi,
Je savais déjà que d'un matériel a l'autre sa variait, mais j'ai lu aussi que l'arduino n'étais pas limitée a 8 bit pour le protocole spi,
Donc avant de prendre ce dernier poste pour argent contant j'espère que j'aurais confirmation ou pas dans les prochain poste.

Donc avant de prendre ce dernier poste pour argent contant j'espère que j'aurais confirmation ou pas dans les prochain poste.

La bonne démarche c'est d'ouvrir la doc de l'atmega, pas d'attendre que quelqu'un le fasse pour toi.
Mais bon un extrait:
8-bit Microcontroller with 4/8/16/32K Bytes In-System Programmable Flash
ATmega48PA, ATmega88PA, ATmega168PA, ATmega328P
chapitre 18. SPI – Serial Peripheral Interface

When configured as a Master, the SPI interface has no automatic control of the SS line. This
must be handled by user software before communication can start. When this is done, [b]writing a
byte to the SPI Data Register starts the SPI clock generator, and the hardware shifts the eight
bits into the Slave[/b]. After shifting one byte, the SPI clock generator stops, setting the end of
Transmission Flag (SPIF). If the SPI Interrupt Enable bit (SPIE) in the SPCR Register is set, an
interrupt is requested. [b]The Master may continue to shift the next byte by writing it into SPDR, or
signal the end of packet by pulling high the Slave Select, SS line. The last incoming byte will be
kept in the Buffer Register for later use.[/b]

Jusqu'à preuve du contraire la doc Atmel ne parle que de byte. Libre à toi de croire ce que tu veux.
Si tu veux, tu peux aller voir les illustration de la doc. Les registres font 8 bits et il n'y a pas d'option pour changer ça.

Si je comprend bien alors on ne peu envoyer que des packet de 8 bit donc un octet,
La documentation ATMega ne mets pas venu a l'esprit car je pensais que c'était la libraire SPI faite pour le projet Arduino qui gérais le protocole,

Si je comprend bien la situation dans la quelle je suis si je veux utiliser c'est eeprom de marque Atmel je vais devoirs émuler mon propre signal SPI,

Sa métone quand même car le Microcontroleur et les eeproms sont tout deux produite par Atmel, et pourtant si peu de compatibilité .

Bonjour

Sa métone quand même car le Microcontroleur et les eeproms sont tout deux produite par Atmel, et pourtant si peu de compatibilité

Les 93C46 sont des composants anciens qui se vendent encore pour la maintenance.
Atmel produit son '93C46' en 'seconde source' de Microchip qui l'a introduit (avant 1995) comme EEPROM au bus Microwire, lequel bus est un SPI simplifé 'maison' de Microchip....

Demander aux micros actuels la rétro-compatibilité avec les puces (plus ou moins SPI) d'il y 20 ans est sans toute excessif !
Pas étonnant donc qu'il soit nécessaire de faire du 'sur mesure'

Certains (AVR mais pas Arduino) s'y sont déjà frottés avec semble t-il , finalement, succès :
http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=93203&postdays=0&postorder=asc&start=20&sid=41c2fc377e0f3fe678cdc9233759f51f

je vais devoirs émuler mon propre signal SPI,

Je te suggères de partir de wiring_shift.c qui se trouve dans les fichiers sources de l'arduino, hardware/arduino/cores/arduino.
La librairie fonctionne avec des uint8_t (des byte) et peut facilement être adaptée. Il faut modifier shiftOut pour avoir en entrée un unsigned int en ne décalant que 10 bits évidemment. Pour la lecture il faut reprendre la fonctionne shiftIn et lui faire lire un bit supplémentaire que l'on rejette car il y a un 0 bidon en début de cycle de lecture de cette mémoire.

Edit : J'oubliais, il faut renommer les fonctions sinon il va y avoir un conflit avec la librairie originale.

Oui je vais partir de la modification de shiftin et out,
Le problème c'est que je ne sais pas ou ses deux fonctions sont appeler, donc je vais plutôt faire une copie de l'ide et le modifier directement.

voici les modification que j'ai faite la compilation fonctionne, mais j'ai exactement le même résultat que j'avais avant .

unsigned int shiftIn(unsigned int dataPin, unsigned int clockPin, unsigned int bitOrder) {
	unsigned int value = 0;
	uint8_t i;

	for (i = 0; i < 10; ++i) {
		digitalWrite(clockPin, HIGH);
		if (bitOrder == LSBFIRST)
			value |= digitalRead(dataPin) << i;
		else
			value |= digitalRead(dataPin) << (9 - i);
		digitalWrite(clockPin, LOW);
	}
	return value;
}

void shiftOut(unsigned int dataPin, unsigned int clockPin, unsigned int bitOrder, unsigned int val)
{
	uint8_t i;

	for (i = 0; i < 10; i++)  {
		if (bitOrder == LSBFIRST)
			digitalWrite(dataPin, !!(val & (1 << i)));
		else	
			digitalWrite(dataPin, !!(val & (1 << (7 - i))));
			
		digitalWrite(clockPin, HIGH);
		digitalWrite(clockPin, LOW);		
	}
}

Je commence a perdre espoirs a l'idée de pouvoir utiliser cet eeprom.

Salut,

Je n'ai pas de quoi tester, mais une petite recherche chez l'ami Google donne quelques résultats, dont celui-ci.

++

voici les modification que j'ai faite la compilation fonctionne, mais j'ai exactement le même résultat que j'avais avant .

Sans le bout de programme qui appelle ces fonctions on ne peut pas trop t'aider.

Ce lien est très intéressent, par contre le code a été coder pour quoi ? car l'ide de l'Arduino indique des erreurs a la compilation.

 #include <avr/io.h>

Pour quelle architecture de développement a été fais ce programme ?

Sinon pour répondre au dernier poste je ne sais pas ou sont faite les appelles de ses fonction je sais juste que elle est déclarée dans wiring.h et quelle sont utiliser pour la libraire spi mais a par sa j'ai rien trouver, j'ai juste suivi le conseille d'adapter le type de variable et la nombre de bit envoyer pour ses deux fonctions.

wiring.h

void shiftOut(unsigned int dataPin, unsigned int clockPin, unsigned int bitOrder, unsigned int val);
unsigned int shiftIn(unsigned int dataPin, unsigned int clockPin, unsigned int bitOrder);

Il faut créer ta propre librairie avec shiftIn et shiftOut en leur donnant un autre nom par exemple shiftOut10 et shiftIn9 (pour ne pas avoir de conflit avec la lib wiring_shift.c) à la place de la lib SPI. Ou alors les intégrer directement dans ton programme si tu ne veux pas faire une librairie.
Dans ton programme il faut ensuite remplacer SPI.transfert par shiftOut10 par exemple pour envoyer des valeurs dans ta mémoire.

Bonsoir

Ce lien est très intéressent, par contre le code a été coder pour quoi ? car l'ide de l'Arduino indique des erreurs a la compilation.
Code:
#include <avr/io.h>
Pour quelle architecture de développement a été fais ce programme ?

C'est bien pour Arduino mais une version assez ancienne ...
Les PB0, PB1... sont maintenant dépréciés dans le Winavr plus récent qu'utilise Arduino (depuis quelle version??)
Remplacer PB0 part PORTB0 ... le code signalé par SesechXP passe la compilation avec Arduino 1.02
par contre dans mes antiquités j'ai des 93C56 , pas des 93C46 pour tester.

#define SK PORTB1 //SCK - Digital 52
#define DO PORTB3 //MISO - Digital 50
#define DI PORTB2 //MOSI - Digital 51
#define CS PORTB0 //SS - Digital 53

EEPROM_93C46N.ino (5.23 KB)

J'ai changer les pb par portb et la compilation fonctionne mais une fois dans l'Arduino il m'affiche EEPROM writing/reading et puis plus rien,
Je pense que je vais mettre de coter ce projet, sa fait une semaine si pas plus, et je suis a bout de nerf.