Question sur la mémoire EEprom.

dje8269 · Jan 3, 2015

Bonjour à tous ,

Je souhaite enregistrer un byte dans la mémoire EEprom d'un 20X2 . Mais j'ai un doute sur le fonctionnement de la commande write, après lecture du manuel en Français .

Il parle de faire

Code:

Debut:
For b3=0 to 10 ;début d'une boucle for/next
Serin C.6,N2400,b4 ;serin reçoit une donnée dans le byte b1
write b3,b4 ;la valeur de b4 est enregistrée dans la mémoire b3 de ;l'EEPROM (mémoire 0 au premier passage)
next b3 ;boucle pour l'écriture de la mémoire suivant, jusqu'à 10

Le but final est d'enregistrer a chaque changement de vitesse , la valeur de la vitesse en cours , ainsi a chaque mise sous tension du VHL , je sais ou en sont mes vitesses ; et je pourrais agir en conséquence . car il est beaucoup plus improbable que le servo se déplace tout seul pour changer une vitesse, plutôt que l'interrutpeur que qqun touche par inadvertence quand la télécommande est eteinte .

Puis je ecrire ceci :

Code:

write 0,flag_Vitesse
write 1,flag_diff

et en début de programme

Code:

 read 0,mem_Vitesse,mem_Diff

MGU · Jan 3, 2015

Bonjour,

Oui, c'est bon, si les variables sont des bytes.
Si ce sont des "word", il faut placer le mot clé WORD devant pour quelle soit enregistrée sur deux bytes, et idem à la lecture.

MM

dje8269 · Jan 3, 2015

Merci Michel .

C'est nickel! . J'avais un doute sur la mémoire EEprom , comme dans l'exemple ils écrivent, b3 et b4 , j'avais peur que cela écrivais directement sur mes variables ( même si cela n'as aucun sens).

Pas de soucis se sont des bytes, se sont même des bit plutôt lol .

Ca fonctionne impeccable .

alainav1 · Jan 3, 2015

bonjour,
juste pour info
n'y a til pas un nombre d'ecriture maxi apres lequel le picaxe ne surporte pas ?
c'est le cas dans les pic 16f
extrait datasheet 16f88
• 100,000 erase/write cycles Enhanced Flash
program memory typical
• 1,000,000 typical erase/write cycles EEPROM
data memory typical

bien sur quelques centaines d'ecritures ne pose pas de probleme mais une ecriture repetée (suite à une erreur dans une boucle pendant la mise au point par exemple ) risque de poser probleme

mais des specialistes completeront surement cette observation.

cordialement
Alain

dje8269 · Jan 9, 2015

Bonjour a tous ,

J'en suis rendu à enregistrer des valeurs dans ma mémoire Eeprom 24LC256 . Pour le moment il s'agit de savoir le temps que cela me prendrait et de voir si ça ne perturbe rien niveau de mon soft .... car la liaison est en I2C , donc je dois changer d'esclave .

Je n'ai aucune expérience la dessus , et la DS reste peu compréhensible vu mon niveau d'anglais. Si un expert pouvait m'expliquer en quelques lignes le fonctionnement global. comment communiquer écrire et lire dessus par exemple , et comment la configurer ? a quoi servent les broches A0,A1 et A2

Je pense avoir compris que l'adresse I2C sur le bus , est 1010XXXX , est ce que c'est bon ? avec le bit de poids faible a 0 ou 1 pour lire et écrire (page 10)
Donc avec un Picaxe je dois écrire dessus avec un hi2cout a partir de zéro au démarrage , et je suppose incrémenter le pointeur a chaque fois pour mettre les valeurs les une a la suite des autres ?
Pour lire , je pense qu'il faut faire un hi2cIn , en partant du dernier pointer et en décrémentant a chaque fois , pour lire a l'envers ?

Merci a toute personne , ayant des infos sur ce genre de mémoire

PieM · Jan 9, 2015

A0, A1, A2 définissent les adresses de la mémoire.
Si tu n'en a qu'une, mets ces entrées à GND
l'adresse de l'eeprom est alors %10100000. Ne jamais mettre le bit0 à 1 !
attention qu'il faut 5ms au moins entre chaque écriture.
l'écriture d'un byte rafraichit toute une page (64 bytes)
donc bien réfléchir à la fréquence des écritures pour la durée de vie de l'eeprom.

dje8269 · Jan 9, 2015

Merci beaucoup PieM ppour ces indications et conseils .

Si tu n'en a qu'une, mets ces entrées à GND

je n'en ai qu'une, donc tout à la masse pas de problème, je fila a mon fer a souder

attention qu'il faut 5ms au moins entre chaque écriture.

D'accord ! C'est toujours bon de la savoir ; Même si dans mon cas y'a aucun risque ( 40ms environ) .

l'écriture d'un byte rafraichit toute une page (64 bytes)

Ça j'ai pas compris ! qu'entends tu par "rafraichis tout une page" ?

donc bien réfléchir à la fréquence des écritures pour la durée de vie de l'eeprom.

Dans mon cas je comptais pour le moment enregistrer 3 bytes ( vitesse , direction , et TOR) toutes les 40 ms grosso modo ; crois tu que c'est judicieux ?

PieM · Jan 10, 2015

dje8269 said:
Dans mon cas je comptais pour le moment enregistrer 3 bytes ( vitesse , direction , et TOR) toutes les 40 ms grosso modo ; crois tu que c'est judicieux ?

Le problème est de savoir quelle durée de parcours tu veux enregistrer.
attention que tu vas enregistrer toutes les 3 adresses. A 63 il faut passer à la page suivante (64) sinon tu vas réécrire sur 0 et 1
Quand on écrit un byte dans une page, toute la page (ici 64 bytes) est réécrite avec les valeurs existantes.
tu as une écriture de page toutes les 40ms et tu change de page au bout de 40 x21 soit 840 ms.

dje8269 · Jan 10, 2015

Le problème est de savoir quelle durée de parcours tu veux enregistrer.

Je me l'a suis posée aussi ! .

Pour répondre précisément à ta question . Je souhaite enregistrer tout le parcours , a savoir environ une heure de déplacement . Car on ne peux pas savoir quand la coupure aura lieu . l'enregistrement se fera seulement quand on recevra une valeur, donc un mouvement . pendant les arrêts pas d'enregistrement ! car le VHL doit pouvoir rester en stand by pendant un moment.

Si je reste dans l'optique ( suivant les opérateurs) du perdu pour perdu , on pourrait revenir pendant longtemps, autant essayer !

Je pensais définir une action "humaine" . si le VHL ne revient pas , il faudra émettre en permanence , par exemple, pour détecter une éventuelle reprise et ainsi arrêter le back-up.

Je suis en train de faire un programme test pour la mémoire .

dje8269 · Jan 10, 2015

Bon ben je n' y arrive pas . Une idée sur mes erreurs ?

J'ai bien mis A0, A1 et A2 à GND .

voici mon programme test :

- j'enregistre en incrémentant 3 valeurs b1,b2 et b3 , dans le mémoire en i2C
- au bout de 3 secondes, je sors .
- et je vais récupérer mes valeurs pour les afficher .

le résultat n'est pas la hauteur de mes espérance ! voir bizarre, j'ai du louper un épisode . j'avoue que cete histoire de page de 64 bytes j'ai pas trop compris. je vais aller lire sur gogole se que je trouve la dessus .

On peut voir a ligne 48 que b3 vaut 10 ? sinon les valeurs restent a 255 .

Code:

Symbol Memoire = %10100000
'###########################    Initialisation    ############################

setfreq m8

hi2csetup i2cmaster, SD_20, i2cslow_8, i2cbyte	' On passe en maitre avec le SD20 en esclave

settimer t1s_8			' On active le timer

pause 200
'#################################################################################
'##########################    Programme Principal    ############################	
'#################################################################################
do
	do
		high orange
		pause 15
		low orange
		pause 15
		b1 = b1 + 1
		b2 = b2 + 2
		b3 = b3 + 3

		' Ecriture dans l'Eeprom
		hi2cout [Memoire], pointeur, (b1,b2,b3)	' On ecrit dans l'Eeprom
		Pointeur = pointeur + 3				' On incremente le pointeur
		sertxd ("pointeur=",#pointeur," ","b1=",#b1," ","b2=",#b2," ","b3=",#b3,13,10)
	loop while timer < 3
	
	pause 5000
	timer = 0
	gosub backup

loop
'#########################################################################################################
'######################################    Programme Secondaire    #######################################	
'#########################################################################################################
Backup:

do
high rouge
pause 15

hi2cin [memoire], pointeur , (b1,b2,b3)	' Recuperation des valeurs en memoire
pointeur = pointeur - 3				' On fait marche arriere


low rouge

pause 15	' Simule l'attente du RFin

sertxd ("### pointeur=",#pointeur," ","b1=",#b1," ","b2=",#b2," ","b3=",#b3,13,10)

loop while timer < 3

b1 = 0
b2 = 0
b3 = 0
timer = 0
pause 5000
return

PieM · Jan 10, 2015

dje8269 said:
Pour répondre précisément à ta question . Je souhaite enregistrer tout le parcours , a savoir environ une heure de déplacement . Car on ne peux pas savoir quand la coupure aura lieu .

prévois une remorque avec un disque dur !

dje8269 · Jan 10, 2015

Houlaa ! tu m'as perdus !

Avec 256K , j'ai donc 256K / 64 = 4000 pages ?

donc 4000 pages x 840 ms = 3 360 000 . divisé par mille : 3360 secondes ? divisé par 60 : 56 minutes ? non ?

PieM · Jan 10, 2015

dje8269 said:
Avec 256K , j'ai donc 256K / 64 = 4000 pages ?

Quand on confond les bits et les bytes oui ...

dje8269 · Jan 10, 2015

Autant pour moi la memoire fait 256Kbit et non 256Kbytes .

donc il faut diviser le temps par 8 . 56 /8 = 7 minutes !!!!!!

Damned !! ca fais trés peu . il faudrait donc que j'enregistre une valeur sur 10 pour obtenir 70 minute

dje8269 · Jan 10, 2015

Hum.... j'ai dis une grosse connerie ! . Il ne faut pas enregistrer une heure de route .... .

En fait il faut enregistrer en boucle . et on revient en arrière tant qu'on as pas reçu de signal . Donc au max je pourrais revenir 7 minutes en arrière . autant dire que le véhicule sera dans les choux en 7 minutes ; si je vais marche arrière 10 secondes c'est déjà bien ! . juste de quoi retrouver le signal ;

Donc en fait , je souhaite enregistrer en boucle , sans question de temps !

dje8269 · Jan 10, 2015

Impossible d efaire plus simple et pourtant ca ne fonctionne pas . la valeur affichée reste inexorablement a 255 .

Code:

#PICAXE 20X2


Symbol Memoire = %10100000

'###########################    Initialisation    ############################

setfreq m8

hi2csetup i2cmaster, Memoire, i2cslow_8, i2cbyte	' On passe en maitre avec le SD20 en esclave

pause 200
'#################################################################################
'##########################    Programme Principal    ############################	
'#################################################################################

	hi2cout [Memoire], 0, (32)	' On ecrit dans l'Eeprom
					
pause 500
	

	hi2cin [memoire], 0 , (b1)	
	sertxd (#b1,13,10)

end

dje8269 · Jan 10, 2015

Ok j'ai enfin réussis a trouver l'erreur !!!! .

Il s'agit de la fréquence qui n'était pas bonne ; je dois passer a 2 Mhz pour que ça fonctionne !

n'y aurait-il pas une façon de contourner ce problème pour laisser la fréquence a 8 Mhz !

PieM · Jan 10, 2015

Il s'agit de la fréquence qui n'était pas bonne ; je dois passer a 2 Mhz pour que ça fonctionne !

vérifie plutôt ta commande ...
et la broche WP de ton eeprom est reliée à quoi ?

dje8269 · Jan 10, 2015

Ma commande ?

La commande WP est relié à la GND , pour désactiver le verrou, j'ai cru comprendre ça sur la DS.

Sans toucher au programme, en mettant setfreq m2, ça a fonctionner du premier coup. Mais j'avoue je préférerais rester à 8mhz durant tout le programme

dje8269 · Jan 10, 2015

Grrgrggrrr , comme toujours tu as raison !!! grgrgr .

En faite j'incrémente ma valeur avant lecture sur la mémoire, donc j'enregistrais a chaque fois ce que je lisais , donc toujours la même valeur !

dje8269 · Jan 11, 2015

Bonjour ,

Lors de mes test sur la mémoire Eeprom , je me rends compte de quelques petits bugs , assez contrariant ! .

Voici un screen de mon programme test et des valeurs lues par un sertxd .

Vous pouvez vous rendre compte, à la ligne 25, que les valeurs de b2 et b3 sont erronées . Et cela même apres re-programmation en changeant les valeurs . Est ce "normal" que des fois des valeurs ne s'effacent pas ? ou se mettent a 255 ?

PieM · Jan 11, 2015

dje8269 said:
Est ce "normal" que des fois des valeurs ne s'effacent pas ? ou se mettent a 255 ?

Tout a fait normal quand tu ne lis pas ce qu'on te dit de faire!

dje8269 · Jan 11, 2015

Ok !! .

Rolalala ! mais quelle usine a gaz pour sauter la valeur 64 et aller à 65 !!! et ce a chaque tour de page , et surtout dans l'autre sens ! Je galére

dje8269 · Jan 11, 2015

Bon voila mon programme test qui fonctionne . mais je suppose qu'il doit y avoir plus simple, mais j'ai pas réussis a trouver mieux .

Pour ceux qui prennent le train en marche , j'essaye d'ecrire dans mon Eeprom. l'Eeprom fonctionne avec des pages, comme me l'a expliqué PieM . il y à 64 bytes par page .

Comme j'enregistre 3 bytes par tour , je peux donc ecrire 21 paquets de 3 bytes . et il me reste 1 byte que je dois "sauter" pour ecrire le paquet suivant sur une nouvelle page .

Donc depuis le début j'écris de l'adresse 0 a 62 . je dois sauter 63 et écrire a nouveau a partir de 64 .

Mais je dois aussi faire marche arrière pour lire mes valeurs a l'envers .

Je serais curieux de connaitre une autre solution, car j'apercois quelques chose avec des modulos mais j'ai pas reussis .

Voici mon programme test qui fonctionne sur 3 secondes pour les tests .

Code:

#PICAXE 20X2

Symbol Memoire = %10100000
Symbol pointeur = w2
Symbol saut_page = b20
setfreq m8

hi2csetup i2cmaster, Memoire, i2cslow, i2cword	

settimer t1s_8
pause 200
'##########################    Programme Principal    ############################	

do
	b1 = b1 + 1
	b2 = b2 + 2
	b3 = b3 + 3
	
	hi2cout [Memoire], pointeur, (b1,b2,b3)	' On ecrit dans l'Eeprom
	sertxd ("     pointeur=",#pointeur,"     ","b1=",#b1," ","b2=",#b2," ","b3=",#b3,13,10)
	
pointeur = pointeur + 3
inc saut_page
if saut_page = 21 then
	inc pointeur
	saut_page = 0
end if

loop while timer < 3

pause 2000
timer = 0	
do
	pointeur = pointeur - 3
	dec saut_page
	
	

	hi2cin [memoire], pointeur , (b1,b2,b3)	
	sertxd ("#####pointeur=",#pointeur,"     ","b1=",#b1," ","b2=",#b2," ","b3=",#b3,13,10)

if saut_page = 0 then
		pointeur = pointeur - 1
		saut_page = 21
	end if
pause 10

loop while timer < 3
end

dje8269 · Jan 11, 2015

Hihihiiiiii . pas de volontaire ?!!!

pas grave , je pense avoir réussis, mais j'aurais aimé une petite précision . Je suis obligé d'utiliser le hi2csetup en mode word ??? savez l'impact que cela créer ? car j'ai lu le manuel , mais les explications ne sont pas très clair , et je ne vois pas ou il veulent en venir en fait !

PieM · Jan 12, 2015

Tu sais adresser 32k bytes avec un simple octet ?

dje8269 · Jan 12, 2015

PieM said:
Tu sais adresser 32k bytes avec un simple octet ?

Non je sais pas faire. Merci bien !

dje8269 · Jan 12, 2015

En tout cas ca me fou le bazar dans le programme principal .

dje8269 · Jan 12, 2015

Il n'existe pas de commande particulière à part un nouveau hi2csetup, pour changer de mode , je suppose ?
Est-ce gênant de passer à chaque fois d’un mode byte en mode word ?

Ou sinon comment pourrais - je modifier mon programme principal pour qu'il fonctionne avec un i2C en word ? Je n'en ai aucune idée.

Une Eeprom peut elle être effacé par soft ?

dje8269 · Jan 14, 2015

je me permet un petit up ! . après j'arrête .

est ce qu'une Eeprom est "resetable" ? dans le sens ou on remet tout les valeurs a zero ?

BESQUEUT · Jan 14, 2015

dje8269 said:
je me permet un petit up ! . après j'arrête .

est ce qu'une Eeprom est "resetable" ? dans le sens ou on remet tout les valeurs a zero ?

A priori, pas autrement qu'en écrivant des zéros partout...

dje8269 · Jan 14, 2015

D'accord , c'est ce que je craignais. Merci bien

PieM · Jan 15, 2015

En principe on écrase une EEPROM avec des $FF

dje8269 · Jan 15, 2015

En principe on écrase une EEPROM avec des $FF

D'accord , y'a-t-il une raison particulière ?

Quand on parle de 1 million d'écriture , on parle sur chaque variable ou en totalité ? Je pense sur chaque variable car sinon ca ferait short .

Mon système fonctionne bien , mais je sais que c'est "améliorable" . Je vous met la partie du code qui est intéressant.

Le but est d'ecrire 3 bytes successivement . les une a la suite des autres ; l'Eeprom fonctionne par page , qui fait 64 bytes . donc j'ai 21 paquets de 3 bytes qui rentre dans une page ; au 21 imee paquet je dois changer de page .
je souhaiterais avoir vos commentaires en tant qu'expert si vous avez le temps et l'envie .

Code:

'##################################       Ecriture dans l'Eeprom        ##################################
hi2csetup i2cmaster, Memoire, i2cslow_8, i2cword	' On passe en maitre avec l'Eeprom en esclave en mode Word
	
hi2cout [Memoire], pointeur, (b0,b3,b5)			' On ecrit dans l'Eeprom

Pointeur = pointeur + 3						' On incremente le pointeur
inc saut_page							' On incremente pour connaitre le ssaut de page de l'Eeprom
	if saut_page = 21 then					' Si on arrive a 21 blocs ( 21x3= 63) il faut changer de page
		inc pointeur 					' pour "sauter" le 64
		saut_page = 0					' On remet le compteur de page a 0
	end if

Code:

read 3,saut_page,word pointeur	' recuperation de la valeur du pointeur et du saut de page

'#####  Recuperation des valeurs en memoire   #####
do	

	pointeur = pointeur - 3
	dec saut_page

		if saut_page > 22 then ' donc = 255
			dec pointeur
			saut_page = 20
		end if

	hi2csetup i2cmaster, Memoire, i2cslow_8, i2cword	' On passe en maitre avec l'Eeprom en mode word
	hi2cin [memoire], pointeur , (b0,b3,b5)			' Recuperation des valeurs en memoire
loop

PieM · Jan 15, 2015

Une opération d'écriture entraîne la réécriture de la page. En résumé, il vaut mieux envoyer 64 bytes d'un coup que 64 fois 1 byte.

la première page va de 0 à 63 !
quand le pointeur est à un multiple de 63 tu l'incrémentes de 1 dans le sens de l'écriture et tu décrémentes de 4 quand tu es en lecture descendante.

dje8269 · Jan 15, 2015

En résumé, il vaut mieux envoyer 64 bytes d'un coup que 64 fois 1 byte.

D'accord, je comprends mieux . bon dans mon cas j'ecrit 3 bytes par 3 bytes . Ca me compliquerais vachement les choses , de sauvegarder par exemple les 21 paquets de 3 bytes dans le scratchpad, et de les transmettes a l'Eeprom par 63 .

quand le pointeur est à un multiple de 63 tu l'incrémente de 1

??? avec un modulo non ? quand le modulo 63 = 0 ?

PieM · Jan 15, 2015

dje8269 said:
??? avec un modulo non ? quand le modulo 63 = 0 ?

ben oui ! c'est fait pour ça.

dje8269 · Jan 15, 2015

Bon ben , mes recherches et mes differents essais se sont averés infructueux !

En fait le modulo focntionne bien lors de la premiere boucle , mais pas des suivantes ?? j'ai du loupé un épisode ;

Code:

symbol pointeur = b1
Symbol modulo = b2
pointeur = 121

do
	
Pointeur = pointeur + 3	
modulo = pointeur % 63
if modulo = 0 then
	inc pointeur
endif

b5 = pointeur

loop

PieM · Jan 16, 2015

si on incrémente le pointeur de 3 et qu'à un moment donné on incrémente de 1 il est évident qu'après il n'est plus un multiple de 3!

dje8269 · Jan 16, 2015

C'etait ma déduction aussi ! donc du coup le modulo tombe a l'eau ! qu'est ce qui reste ? une solution alambiqué de Jérémy ! . Du coup difficile de faire mieux non?

PS : coté positif, je gère le modulo maintenant avec tout ce que j'ai lus hier soir !

Question sur la mémoire EEprom.

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member