next topic »

[Reply #15 on:]

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.

[Reply #16 on:]

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

Code:

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 ?

[Reply #17 on:]

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

Code:

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

[Reply #18 on:]

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

Code:

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
...

[Reply #19 on:]

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.....

[Reply #20 on:]

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.

[Reply #21 on:]

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, writing a
byte to the SPI Data Register starts the SPI clock generator, and the hardware shifts the eight
bits into the Slave. 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. 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.

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.

[Reply #22 on:]

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é .

[Reply #23 on:]

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

[Reply #24 on:]

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.

[Reply #25 on:]

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.

[Reply #26 on:]

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

Code:

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.

[Reply #27 on:]

Salut,

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

++

[Reply #28 on:]

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.

[Reply #29 on:]

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 ?

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

Code:

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);