mettre en mémoire flash pic32MX795

[davidif]

Bonjour,

j'ai une fonction qui me permet, je crois ! d'écrire en mémoire flash de mon micro, je dis je crois par ce que j'ai une autre fonction qui me permet de lire dans cette même mémoire pour voir si mes deux fonction fonctionne bien.

Le problème comme vous pouvez vous en douter, est que je ne sais pas laquelle des deux fonctions ne remplissent pas leur rôle, pour ça il me faudrait regarder dans ma mémoire flash si la fonction d'écriture fonctionne déjà, seulement sur MPLAB je ne sais pas ou regarder, dans view/mémory je ne vois rien qui ressemblerai à la valeur enregistrer.

Ma fonction d'écriture est

void NVMWriteWord (void* address, unsigned int data)
{
unsigned int res;
unsigned int intStatus;

// Load data into NVMDATA register
NVMDATA = data;

// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;

NVMCON = 0x4001;
    

intStatus = INTDisableInterrupts();

NVMKEY = 0xAA996655;
NVMKEY = 0x556699AA;

// Start the operation using the Set Register
NVMCONSET = 0x8000;


NVMCONCLR = 0x0004000;
INTRestoreInterrupts(intStatus);

}

Puis celle qui a priori devrait lire, je suis encore moins sûr d'elle

void NVMReadWord (void* address, unsigned int data)
{
unsigned int res;

// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;

data = NVMDATA;

}

Déjà il me faudrait s'avoir si ma valeur est bien en mémoire, seulement je ne sais pas ou doit-elle être ? à quelle adresse ?

Merci de me faire profiter de votre expérience
-----

[davidif]

quelqu'un sait comment savoir si j'écrit bien dans ma flash avec mplab, pour ça j'ai plusieurs interrogation.

Je ne sais pas si mes deux fonctions sont fonctionnel (write et read), comment ce baser sur les adresses de début de mémoire, la mémoire virtuel ou la memoire physique ?

[RISC]

Salut,

Je te conseille de partir de la librarie d'emulation d'E2PROM pour PIC32

MPLAB X permet je crois de voir simultanément la mémoire virtuelle et la mémoire physique.

a+

[davidif]

Merci RISC je vais regarder ça demain matin, sinon pour enregistrer une données que prend on comme référence d'adressage ? La mémoire virtuel ou physique ? Je comprend pas trop par quel adresse commencer.
Pour mplabx, il faut que j'approfondisse ça par que jusqu'à présent je n'arrive pas à l'utiliser en mode débug, il ne fonctionne pas avec les breakpoints qui sont signalé comme cassé

[A voir en vidéo sur Futura]

[RISC]

Salut,

Je pense que la librairie indique les adresses utilisées.
Quelle version de MPLAB X utilises-tu ? quelle version de XC32 ?
Nettoyes tous les breakpoints dans la fenêtre (cliques droit, delete all)
J'espère que tu n'es pas en mode optimisé au-dessus de 1 car on ne peut pas déboguer.
Si tu as un pb pour mettre un breakpoint à un endroit précis, insère un "Nop();"

a+

[davidif]

Ma version Mplab est V1.9 et celle de xc32 V1.21, mais a priori je vais continuer sur Mplab IDE par ce que je n'y arrive pas sur l'autre , un projet qui est fonctionnel sous Mplab IDE ne compile pas sous X, celui-ci ne trouve pas les librairies comme

#include <plib.h>
#include <math.h>

J'ai essayé de lui indiquer dans RUN set/projet/configuration/custumize/librarie mais quelque choses m'échappe surement j'ai passé 2 heure à essayer de compiler mon projet.

J'ai ces erreur là

Le chemin d'acces specifie est introuvable.
make[2]: *** [build/default/production/_ext/812168374/main.o] Error 1
make[1]: *** [.build-conf] Error 2
make: *** [.build-impl] Error 2

[davidif]

J'ai essayé d'utiliser le projet que tu m 'as mis en lien 'librarie d'emulation d'EEPROM', celui-ci fonctionne correctement à lui seul,seulement quand j'essai de l'adapter à mon projet ça ne fonctionne pas;

sur le projet d'origine

    int value;
	int i;
    int DEEdata=4566,DEEdata1=0;
	int DEEdata2=236,DEEdata3=0;
    unsigned short DEEaddr=0,DEEaddr1=1;
	unsigned char writeArray[5]={15,16,17,18,19};
	unsigned char readArray[5];




int main(void)
{



 
DataEEInit();


 DataEEWrite(DEEdata,DEEaddr);   
 DataEEWrite(DEEdata2,DEEaddr1);



DataEERead(&DEEdata1, DEEaddr);
DataEERead(&DEEdata3, DEEaddr1);


	while(1);
    return(0);
}

j'ai bien ma valeur DEEdata1 qui prend celle de DEEdata et
ma valeur DEEdata3 qui prend celle de DEEdata2

Par contre quand je fais la même chose dans mon main,

		
DataEEInit();


 		valeur1=DataEEWrite(DEEdata,DEEaddr);   
 		//DataEEWrite(DEEdata2,DEEaddr1);

		valeur2=DataEERead(&DEEdata1, DEEaddr);
		//DataEERead(&DEEdata3, DEEaddr1);

Les valeur lu reste toujours à zero et les fonctions de lecture et d'écriture me retourne du 6

[davidif]

Bon je patauge dans semoule comme on dit, je n'arrive pas à enregistrer des datas dans la flash, j'ai repris la méthode du document

http://ww1.microchip.com/downloads/e...Doc/61121F.pdf

dans un exemple avec les fonctions

unsigned int NVMUnlock (unsigned int nvmop)

unsigned int NVMUnlock (unsigned int nvmop)
{
unsigned int status;
unsigned int intStatus;

// Suspend or Disable all Interrupts
intStatus = INTDisableInterrupts();
// Enable Flash Write/Erase Operations and Select
// Flash operation to perform
NVMCON = nvmop;
// Write Keys
NVMKEY = 0xAA996655;
NVMKEY = 0x556699AA;
// Start the operation using the Set Register
NVMCONSET = 0x8000;
// Wait for operation to complete
while (NVMCON & 0x8000);
// Restore Interrupts
INTRestoreInterrupts(intStatus);
// Disable NVM write enable
NVMCONCLR = 0x0004000;
// Return WRERR and LVDERR Error Status Bits
return (NVMCON & 0x3000);
}

unsigned int NVMWriteWord (void* address, unsigned int data)

unsigned int NVMWriteWord (void* address, unsigned int data)
{
unsigned int res;

// Load data into NVMDATA register
NVMDATA = data;
// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;
// Unlock and Write Word
res = NVMUnlock (0x4001);
// Return Result
return res;
}

Seulement ils ne donne rien au sujet de la lecture des données, j'ai donc repris celle en écriture en la modifiant évidement

void NVMReadWord (void* address, unsigned int data)
{
unsigned int res;

// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;
data=NVMDATA;

// Unlock and Write Word
res = NVMUnlock (0x0000);
// Return Result
return res;
}

Dans mon main, je fais

int DEEdata=4566,DEEdata1;


NVMWriteWord (&DEEdata,0);
NVMReadWord (&DEEdata1,0);

Je sais pas si c'est correct, notamment pour la lecture, seul fonction que j'ai fait

[davidif]

Quelqu'un pourrait me dire si ma fonction de lecture est correct, je comprend pas dans la doc, il donne les fonctions d'écriture mais pas la lecture, j'ai donc repris la fonction d'écriture en la modifiant, ça me paraissait pas trop compliqué à la base, s'agissait d'aller à l'adresse et de récupérer la valeur à cette adresse.

Les deux autres fonction , écriture et unlock ont été repris de la docs, je suspect donc pas trop celles-ci, je ne comprend pas quand je regarde d'autres programme pour d'autre pic j'ai aussi un RD dans le registre nvmcon, seulement là rien n'est à configurer pour mon micro.

Bon par contre je viens de me rendre compte d'avoir inversé les arguments des fonction, ce que j'ai corrigé tout de suite mais le problème ne venait pas de là malheureusement

		DEEdata2=NVMWriteWord (0,DEEdata);
		DEEdata3=NVMReadWord (0,DEEdata);

#include "p32mx795f512l.h"
//#include "ppic32mx.h"
#define extern
#include "EEPROM.h"
#undef extern


unsigned int NVMUnlock (unsigned int nvmop)
{
unsigned int status;
unsigned int intStatus;

// Suspend or Disable all Interrupts
intStatus = INTDisableInterrupts();
// Enable Flash Write/Erase Operations and Select
// Flash operation to perform
NVMCON = nvmop;
// Write Keys
NVMKEY = 0xAA996655;
NVMKEY = 0x556699AA;
// Start the operation using the Set Register
NVMCONSET = 0x8000;
// Wait for operation to complete
while (NVMCON & 0x8000);
// Restore Interrupts
INTRestoreInterrupts(intStatus);
// Disable NVM write enable
NVMCONCLR = 0x0004000;
// Return WRERR and LVDERR Error Status Bits
return (NVMCON & 0x3000);
}



unsigned int NVMWriteWord (void* address, unsigned int data)
{
unsigned int res;

// Load data into NVMDATA register
NVMDATA = data;
// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;
// Unlock and Write Word
res = NVMUnlock (0x4001);
// Return Result
return res;
}


//unsigned int NVMReadWord (void* address, unsigned int data)
void NVMReadWord (void* address, unsigned int data)
{
unsigned int res;

// Load address to program into NVMADDR register
NVMADDR = (unsigned int) address;
data=NVMDATA;

while (NVMCON & 0x8000);
// Unlock and Write Word
//res = NVMUnlock (0x0000);
// Return Result
//return res;
}

ce qu'est bizzard, c'est que dans cette conf là, j'ai DEEdata=DEEdata3 alors que la fonction de lecture est censé rien ne retourner ?

S'il vous plait, j'en appel au cador du pic
Merci

[bisou10]

Tu devrais lire la DS.

Sur PIC16/18 il n'y a pas besoin de clé pour LIRE, juste pour ECRIRE. Et l'écriture est simple, tu mets EEADR à jour, puis un front sur EECON.RD, et tu as le résultat dans EEDATA (je résume, mais c'est les phases).

Ensuite pour lire depuis MPLABX, faut faire l'icone à cote de programmer qui est l'inverse (fleche depuis IC)

[davidif]

Bah oui effectivement pour la lecture je fait pas les clé(le les laissé en texte seulement), je lie directement dans NVMDATA ma données une fois après avoir chargé l'adresse dans NVMADDR, la différence entre les autre soft est que je n'est pas de EEcon.RD ou plutot pour mon micro c'est nvmcon.RD.

Et pour l'écriture j'ai repris mots pour mots ce qui a dans la docs.

[bisou10]

Aucune idée pour un 32. Par contre sur 16/18 tu as 2 registres, EECON1 et EECON2. le front sur RD est dans EECON1, EECON2 sert pour la clé d'écriture. Cherche l'équivalent sur ton modèle.

[davidif]

J'ai vu que pour les 16/18 il y avait ces deux registres et qu'un simple Front sur RD permettait de lire la données.
Je pense avoir un peu avancé, dans le sens ou j'arrive a mettre en mémoire mais ou exactement ? par ce que quand je met en mémoire une donné avec la fonction

void WriteFlash(int address,int data)
{
int res,check;

res=NVMWriteWord(((void*)(0xBD000000))+address,data);
check=*((int*)( 0xBD000000)+address);

if (res && (check==data)) LED3=1; else LED3=0;

}

appartenant au fichier NVM.h

/*********************************************************************
 *
 *                  NVM Library definitions
 *
 *********************************************************************
 * FileName:        NVM.h
 * Dependencies:
 * Processor:       PIC32
 *
 * Compiler:        MPLAB C32
 *                  MPLAB IDE
 * Company:         Microchip Technology Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the “Company”) for its PIC32 Microcontroller is intended
 * and supplied to you, the Company’s customer, for use solely and
 * exclusively on Microchip PIC32 Microcontroller products.
 * The software is owned by the Company and/or its supplier, and is
 * protected under applicable copyright laws. All rights are reserved.
 * Any use in violation of the foregoing restrictions may subject the
 * user to criminal sanctions under applicable laws, as well as to
 * civil liability for the breach of the terms and conditions of this
 * license.
 *
 * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 *
 * $Id: NVM.h,v 1.1 2006/10/16 20:30:29 C10737 Exp $
 * $Name: $
 *
 ********************************************************************/
#ifndef _NVM_H_
#define _NVM_H_

#include <p32xxxx.h>
#include <peripheral/int.h>
#include <sys/kmem.h>

#define PAGE_SIZE               1024        // # of 32-bit Instructions per Page
#define BYTE_PAGE_SIZE          (4 * PAGE_SIZE) // Page size in Bytes
#define ROW_SIZE                128         // # of 32-bit Instructions per Row
#define BYTE_ROW_SIZE           (4 * ROW_SIZE) // # Row size in Bytes
#define NUM_ROWS_PAGE           8              //Number of Rows per Page 

/*********************************************************************
 * Function:        unsigned int NVMProgram(void* address, const void* data, unsigned int size void * pagebuff)
 *
 * Description:     Programs size characters from the source buffer to
 *                  Flash memory starting at the destination address.
 *
 * PreCondition:    None
 *
 * Inputs:			address:  Destination address to start writing from.
 *                  data:  Location of data to write.
 *                  size:  Number of bytes to write.
 *                  pagebuff:   Ram buffer to preserve 1 page worth of data
 *
 * Output:          '0' if operation completed successfully.
 *
 * Example:			NVMProgram((void*) 0xBD000000, (const void*) 0xA0000000, 1024, (void *) 0xA0002000)
 ********************************************************************/
unsigned int NVMProgram(void * address, const void * data, unsigned int size, void* pagebuff);

/*********************************************************************
 * Function:        unsigned int NVMWriteWord(void* address, unsigned int data)
 *
 * Description:     The smallest block of data that can be programmed in
 *                  a single operation is 1 instruction word (4 Bytes).  The word at
 *                  the location pointed to by NVMADDR is programmed.
 *
 * PreCondition:    None
 *
 * Inputs:          address:   Destination address to write.
 *                  data:      Word to write.
 *
 * Output:          '0' if operation completed successfully.
 *
 * Example:         NVMWriteWord((void*) 0xBD000000, 0x12345678)
 ********************************************************************/
unsigned int NVMWriteWord(void* address, unsigned int data);

/*********************************************************************
 * Function:        unsigned int NVMWriteRow(void* address, void* data)
 *
 * Description:		The largest block of data that can be programmed in
 *                  a single operation is 1 row 128 instructions (512 Bytes).  The row at
 *                  the location pointed to by NVMADDR is programmed with the data buffer
 *                  pointed to by NVMSRCADDR.
 *
 * PreCondition:    The row of data must be pre-loaded into a buffer in RAM.
 *
 * Inputs:			address:  Destination Row address to write.
 *                  data:  Location of data to write.
 *
 * Output:          '0' if operation completed successfully.
 *
 * Example:			NVMWriteRow((void*) 0xBD000000, (void*) 0xA0000000)
 ********************************************************************/
unsigned int NVMWriteRow(void* address, void* data);

/*********************************************************************
 * Function:        unsigned int NVMErasePage(void* address)
 *
 * Description:		A page erase will erase a single page of program flash,
 *                  which equates to 1k instructions (4KBytes). The page to
 *                  be erased is selected using NVMADDR. The lower bytes of
 *                  the address given by NVMADDR are ignored in page selection.
 *
 * PreCondition:    None
 *
 * Inputs:			address:  Destination page address to Erase.
 *
 * Output:          '0' if operation completed successfully.
 *
 * Example:			NVMErasePage((void*) 0xBD000000)
 ********************************************************************/
unsigned int NVMErasePage(void* address);

/*********************************************************************
 * Function:        unsigned int NVMClearError(void)
 *
 * Description:     If the NVMCON error flag is set, it can only be cleared
 *                  by performing an NVM NOP opertion.
 *
 * PreCondition:    None
 *
 * Inputs:          None
 *
 * Output:          '0' if operation completed successfully.
 *
 * Example:         NMVClearError()
 ********************************************************************/
unsigned int NVMClearError(void);

/*********************************************************************
 * Function:        NVMI®®sError()
 *
 * Description:     Reads the NVMCON Error flags.
 *
 * PreCondition:    None
 *
 * Inputs:          None
 *
 * Output:          '0' if error flag is not set.
 *
 * Example:         if(NVMI®®sError())
 *                      NVMClearError();
 ********************************************************************/
#define NVMI®®sError()    (NVMCON & (_NVMCON_WRERR_MASK | _NVMCON_LVDERR_MASK))


#endif /*_NVM_H_*/

http://www.johnloomis.org/microchip/...rary-Guide.pdf

puis j'enregistre ma données
WriteFlash(0,out1_usb);

et je la relit
out1_usb=*(int*)( 0xBD000000);


quand j’éteins ma maquette, puis la rallume, celle-ci me garde bien la valeur mais après un redémarrage celle-ci à changé, comme si l'adresse que j'utilisai était utilisé a nouveau par le chargement du programme

bizzarement quand je veux lire plusieurs données enregistré, mon programme saute, il ne démarre plus

WriteFlash(0,out1_usb);
WriteFlash(1,out2_usb);
WriteFlash(2,out3_usb);

Puis je viens lire
out1_usb=*(int*)( 0xBD000000);
out2_usb=*(int*)( 0xBD000001);
out3_usb=*(int*)( 0xBD000002);

La localisation de données, et la notion de page descrites me sont pour l'instant pas très claire d'ailleurs

[davidif]

D'après certain post que j'ai lu en anglais chez microchip, j'ai cru comprendre qu'il fallait définir les blocks mémoire, serai-ce nécessaire selon vous?

[davidif]

Bon enfin ça fonctionne, en tout cas pour mémoriser une valeur, je dis une valeur par ce que quand je souhaite mémoriser plusieurs valeurs j'ai quelques soucies.

C'est à dire que quand je fais comme ça :

WriteFlash(out1_usb,0);

avec

void WriteFlash(unsigned int data,unsigned address)
{


	NVMErasePage((void *)NVM_PROGRAM_PAGE);
	NVMWriteWord((void*)(NVM_PROGRAM_PAGE + address), data);

	// Verify data matches
	if(*(int *)(NVM_PROGRAM_PAGE + address) != data)
	{
		LED3=1;
	}

}

puis je lis ma valeur comme ça

out1_usb=*(int *)(NVM_PROGRAM_PAGE );

là c'est ok , ça fonctionne;
maintenant, je voudrais pouvoir mémoriser plusieurs valeurs.
J'ai donc pensé incrémenter l'adresse, sachant que la taille de stockage à une adresse est de 32bits donc la taille d'un entier,c'est à dire:

Pour lire
WriteFlash(out1_usb,0);
WriteFlash(out2_usb,1);
WriteFlash(out3_usb,2);

Donc pour lire
out1_usb=*(int *)(NVM_PROGRAM_PAGE );
out2_usb=*(int *)(NVM_PROGRAM_PAGE +1);
out3_usb=*(int *)(NVM_PROGRAM_PAGE +2);

Mais bon là mon programme plante.

Quelqu'un pourrai m'éclairer

[davidif]

bonjour,

je mémorise, seulement quand je mémorise une valeur, celle-ci est bien mémorisé, seulement quand je souhaite mémoriser une autres valeurs a la même adresse, celle-ci ne sauvegarde pas la nouvel valeur mais semble faire un and entre l'ancienne et la nouvelle valeur, j'ai donc penser à rentrer 0xFFFFFFFF dans l'adresse avant de rentrer la nouvelle données, mais ça ne fonctionne pas

#define 	NVM_PROGRAM_PAGE		0xbd008000
#define		NVM_ERASE				0xFFFFFFFF


void WriteFlash(unsigned int data,int address)
{
int addr=NVM_PROGRAM_PAGE + address;

//data1=*(int *)(NVM_PROGRAM_PAGE + address);

	NVMWriteWord((void*)(addr), NVM_ERASE);
	if(*(int *)(addr) !=NVM_ERASE)	LED3=1; else LED3=0;
	

	NVMWriteWord((void*)(addr), data);
	if(*(int *)(addr) != data)	LED3=1; else LED3=0;
	

}



WriteFlash(out1_usb,0);

la après de multiple essai, je m'en sort pas.

Je mémorise une première valeur comme 237hex, puis une autre 2Dhex et la sauvegarde va être 25

[davidif]

D'après ce que j'ai compris il m'est impossible d'écrire a nouveau du FFFFFFFF seulement à l'adresse à laquel je souhaite modifier la valeur mise à part si je fais un "NVMErasePage" seulement si je fait cette fonction j'efface également les autres données du block que j'ai mémorisées et ça m'oblige donc de les réécrire eux aussi.

il a t-il un autre moyen de modifier une seul valeur à une même adresse sans pour autant tout effacer ? ça fait un bon moment que je suis là dessus et je block

void WriteFlash(unsigned int data,int address)
{
int addr=NVM_PROGRAM_PAGE + address;
	
	if(*(int *)(addr) != data)
	{	
        NVMErasePage((void*) 0xBD000000);	
	}


	NVMWriteWord((void*)(addr), data);
	if(*(int *)(addr) != data)	LED3=1; else LED3=0;
	

}

s'il vous plait help me !!!