utilisation flash externe SST26VF064

[davidif]

Après avoir exécuté SPI_WriteBlockProtection(), utilise la fonction SPI_ReadBlockProtection() pour lire les 18 octets de protection des blocs.
Il y a peut être un lock quelque part.

J'ai fait quelque chose comme ça

               i=0;
            while (i<=255)
            {
             data_256[i]=170;
                i++;
            }

            SPI_WREN();

            block_protection_18[0]=0x00;
            block_protection_18[1]=0x00;
            block_protection_18[2]=0x00;
            block_protection_18[3]=0x00;
            block_protection_18[4]=0x00;
            block_protection_18[5]=0x00;
            block_protection_18[6]=0x00;
            block_protection_18[7]=0x00;
            block_protection_18[8]=0x00;
            block_protection_18[9]=0x00;
            block_protection_18[10]=0x00;
            block_protection_18[11]=0x00;
            block_protection_18[12]=0x00;
            block_protection_18[13]=0x00;
            block_protection_18[14]=0x00;
            block_protection_18[15]=0x00;
            block_protection_18[16]=0x00;
            block_protection_18[17]=0x00;

             SPI_WriteBlockProtection();
              SPI_Wait_Busy();


              

             SPI_ReadBlockProtection();  
              SPI_Wait_Busy();
             SPI_WREN();
              
            SPI_Chip_Erase();	//Erase the chip


            SPI_Wait_Busy();
             i=0;
            SPI_WREN();


             while(i<highest_address)
             {	SPI_WREN();
        
            SPI_Page_Program(i);
                SPI_Wait_Busy();
                i=i+256;
            }

                    SPI_WREN();


              j=0;
             while(j<highest_address)
             {
                	//SPI_Set_Burst(0x03);
                	//SPI_Read_Burst(j, 64); 			//verify that it got programmed.
                	//SPI_Wait_Busy();

                   SPI_HighSpeed_Read_Cont(j, 64);
                     for (i=0;i<64;i++)
                     {
                        if (data_256[i]==170)
                        {tempcheck&=1;
                        }
                          else
                        { tempcheck=0;
                        }
                      }

                j=j+64;
            }


                    if ((tempcheck == 1)&&(status==1))
                    {check=(check+1);
                    status=status&1;}
                    else
                    {status=0;}

Mais pour le moment toujours le même problème de check au dessus de 3FFFF est à 1
-----

[satinas]

quand je te dis de lire les octets de protection, c'est pour vérifier qu'il contiennent bien la valeur que tu as écrite, c'est a dire 18 fois 0 !

Autre chose, sur le document de migration, il disent d'utiliser la commande 98H de déblocage complet du bignou, c'est à essayer aussi.

[davidif]

quand je te dis de lire les octets de protection, c'est pour vérifier qu'il contiennent bien la valeur que tu as écrite, c'est a dire 18 fois 0 !

Autre chose, sur le document de migration, il disent d'utiliser la commande 98H de déblocage complet du bignou, c'est à essayer aussi.

Désolé, tu sais moi en ce moment , c'est bête et discipliné (: mais je sature , ça fait pas mal de temps que je suis dessus comme tu sais ...

J'ai donc lu les valeurs des octets de protection sont sont a priori bien à 0x00



Alors effectivement, j'ai cru comprendre, lors de discution de forum qu'il fallait faire un dévérouillage avec 98H ? mais à quel moment, à l'initialisation ? ou à chaque mouvement de la flash .
Je vois ça

[satinas]

Si c'est pas dans le driver, elle doit pas être nécessaire, à moins qu'avec tous les essais que tu as déjà faits, tu as locké une partie de la flash.
Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

[davidif]

J'ai tenté d'envoyer la commande 98h avant le dévérouillage des secteurs et à l'init également mais rien de plus, après je fais rien de plus que ce qui l'y a dans les drivers

j'initialise en tout début

Portassign();
CE_High();
WP_High();
Reset_Hold_High();
init();
tempcheck=0;
status=0;
compt_nbr_save=0;
nbr_read=0;

// deuxième flash non utilisé
CS2_SPI=1;
WP2_FLASH=1;
RST2_FLASH=1;

j'ai deux flash en parallèle, dont une que je n'utilise pas, donc le cs n'est pas actif

void write_data (void)
{
  unsigned int tempdatalong;   
  unsigned long i,k,j;
  //int status;
  
  
  
 i=0;
 j=0;
  
 status=1;  //1 means memory/code works and 0 means fault has occured.
 check=0;  //keeps track of code progress.
 tempcheck=1; 
   
   
   
   
    
  /*Portassign();
  CE_High();
  WP_High();
  Reset_Hold_High();
  init();*/
    
   
  
              
                SPI_WREN();

                tempdatalong = SPI_Read_Status_Register();
                tempdatalong = tempdatalong<<8;
                tempdatalong = tempdatalong | 0x82;
                SPI_Write_Status_Register(tempdatalong, 2);
                tempdata=SPI_Read_Configuration_Register();

                // Test Jedec ID
                Jedec_ID_Read();
                if (Manufacturer_Id == 0xbf && Device_Type == 0x26 && Device_Id == 0x43) { 
                check = 1;
                } 
                else { 
                check=0; 
                } 
                
                
                //SPI_WREN();
                //SPI_unlock();
                //SPI_Wait_Busy();
                
/************* 2a. Page program whole chip using SPI protocol and verify its OK. *********/

               i=0;
            while (i<=255)
            {
             data_256[i]=170;
                i++;
            }

               
               
               
               
            SPI_WREN();

            block_protection_18[0]=0x00;
            block_protection_18[1]=0x00;
            block_protection_18[2]=0x00;
            block_protection_18[3]=0x00;
            block_protection_18[4]=0x00;
            block_protection_18[5]=0x00;
            block_protection_18[6]=0x00;
            block_protection_18[7]=0x00;
            block_protection_18[8]=0x00;
            block_protection_18[9]=0x00;
            block_protection_18[10]=0x00;
            block_protection_18[11]=0x00;
            block_protection_18[12]=0x00;
            block_protection_18[13]=0x00;
            block_protection_18[14]=0x00;
            block_protection_18[15]=0x00;
            block_protection_18[16]=0x00;
            block_protection_18[17]=0x00;

             SPI_WriteBlockProtection();
              SPI_Wait_Busy();


             //SPI_ReadBlockProtection();  
              //SPI_Wait_Busy();
             SPI_WREN();
              
            SPI_Chip_Erase();	//Erase the chip


            SPI_Wait_Busy();
             i=0;
            SPI_WREN();


             while(i<highest_address)
             {	SPI_WREN();
        
            SPI_Page_Program(i);
                SPI_Wait_Busy();
                i=i+256;
            }

                    SPI_WREN();


              j=0;
             while(j<highest_address)
             {
                	//SPI_Set_Burst(0x03);
                	//SPI_Read_Burst(j, 64); 			//verify that it got programmed.
                	//SPI_Wait_Busy();

                   SPI_HighSpeed_Read_Cont(j, 64);
                     for (i=0;i<64;i++)
                     {
                        if (data_256[i]==170)
                        {tempcheck&=1;
                        }
                          else
                        { tempcheck=0;
                        }
                      }

                j=j+64;
            }


                    if ((tempcheck == 1)&&(status==1))
                    {check=(check+1);
                    status=status&1;}
                    else
                    {status=0;}

               
/************* 3a. Do Sector Erase and verify that the sector is erased *********/


	SPI_WREN();
	SPI_Sector_Erase(0);	//Do Sector Erase
	SPI_Wait_Busy();

        j=0;
 	while (j<(4096))
	{
    	SPI_WREN();
  		SPI_Set_Burst(0x03);
		//SPI_Read_Burst(j, 64);
        SPI_HighSpeed_Read_Cont(j, 64);
	    for (k=0;k<63;k++)
		 {
		 	if (data_256[k]==0xff)			  // Verify that the values are correct
			{tempcheck&=1;}
			  else
			{ tempcheck=0;}
   		  }
   		  j=j+64;
	}

        j=4096;
 	while (j<(4096*2))
	{
    	SPI_WREN();
  		SPI_Set_Burst(0x03);
		//SPI_Read_Burst(j, 64);
        SPI_HighSpeed_Read_Cont(j, 64);
	    for (k=0;k<63;k++)
		 {
		 	if (data_256[k]==0xAA)			  // Verify that the values are correct
			{tempcheck&=1;}
			  else
			{ tempcheck=0;}
   		  }
   		  j=j+64;
	}


	  	if ((tempcheck == 1)&&(status==1))
		{check=(check+1);
		status=status&1;}
		else
		{status=0;}

 
}

[satinas]

Ce qui m'intéresse c'est ce qu'il y a de nouveau, c'est à dire comment tu envoies la commande 98h, pas que tu m'envoies 50 fois le même programme que j'ai déjà vu.

Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

[davidif]

Si c'est pas dans le driver, elle doit pas être nécessaire, à moins qu'avec tous les essais que tu as déjà faits, tu as locké une partie de la flash.
Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

En fait, j'ai la même chose, que ce soit sur la flash de mon starter kit(ou j'ai débuté et fais la plupart des tests flash) que ce soit sur ma carte câblé (que je commence à tester)
Les deux ne passe pas après 3FFFF.

Serait-ce lié au câblage à ton avis, je pense à l'installation de pull up ou down sur les entrées ou sorties ....

[davidif]

Ce qui m'intéresse c'est ce qu'il y a de nouveau, c'est à dire comment tu envoies la commande 98h, pas que tu m'envoies 50 fois le même programme que j'ai déjà vu.

Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

J fais un truc comme ça

SPI_WREN();
SPI_unlock();
SPI_Wait_Busy();

avec

void SPI_unlock()
{
CE_Low(); /* enable device */
Send_Byte(0x98);
CE_High(); /* disable device */
}

[satinas]

Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

[davidif]

Il faut déterminer à partir de quelle page l'écriture pose problème, si cela varie, ce n'est pas un problème de lock, mais de communication.

OK, je regarde, comment je pourrai tester les différentes pages les une à la suite des autres, si c'est la bonne méthode (:

[satinas]

En mettant un break debugger au bon endroit dans ton programme.

[davidif]

D'après mes tests, ce n'est qu'une question de temps.

He oui ! (:

Je viens donc tester le check :

        if(check==3)
            break_l=1;

et celui-ci passe bien tout le temps à 3 seulement il met du temps, c'est à dire que quand j'envoi ma commande d'écriture , vérif et d'effacement, si je fais une pause trop rapidement il n'a pas le temps de tout faire, alors que si je laisse environ 6s , j'ai un break qui s’arrête bien.

je comptabilise aussi le nombre de fois il passe

                  SPI_HighSpeed_Read_Cont(j, 64);
                     for (i=0;i<64;i++)
                     {
                        if (data_256[i]==170)
                        {
                            tempcheck&=1;
                            page_good++;
                        }
                          else
                        { 
                            tempcheck=0;
                            page_bad++;
                        }

                     }

et il ce trouve, que je ne passe pas en tempcheck=0;

6 seconde, ça me parait long quand même ?

[satinas]

J'ai rien compris, je ne vois pas ou tu fais une pause.
Si tu as un debugger, met un break sur la ligne tempcheck&=1;
tu sauras à quelle adresse j+i il y a une erreur
fais le plusieurs fois et sans faire de pause.

for (i=0; i<64; i++)
{
  if (data_256[i]==170) 
  {
     tempcheck&=1;
  }
  else  {
     tempcheck=0;}
  }
  j = j+64;
}

[satinas]

oops, break sur ligne tempcheck=0; bien sur

[davidif]

J'ai rien compris, je ne vois pas ou tu fais une pause.
Si tu as un debugger, met un break sur la ligne tempcheck&=1;
tu sauras à quelle adresse j+i il y a une erreur
fais le plusieurs fois et sans faire de pause.

for (i=0; i<64; i++)
{
  if (data_256[i]==170) 
  {
     tempcheck&=1;
  }
  else  {
     tempcheck=0;}
  }
  j = j+64;
}

Excuse moi satinas, je n'ai certainement pas été claire, ou j'ai rien compris moi même (: mais
lors d'un lancement du test j'ai mis un break sur une condition if( check==3) en fin de fonction et celui-ci passe toujours à 3 mais met un certain temps (environ 5 à 6 s ) clock à 10Mhz.

je crois avoir compris que cette condition tempcheck&=1 voulait dire que l'octet testé est bon(170 AA) et tempcheck=0 octet mauvais, donc si je met un test je m’arrêterais tout de suite.

[satinas]

Tu fais la manip 10 fois en notant à chaque fois la valeur de j+i lors du break

[davidif]

j'ai testé cette condition en premier et je n'y passe justement pas , car il n'y a pas d'erreur en fait;

[satinas]

Ca serait bien qu'on arrête de tourner en rond ...
Enlève la variable check et remplace la par int check1a=0, check2a=0, check3a=0;
tu remplaces check=(check+1); par check1a=(check1a+1); idem pour les 2 autres
tu auras des résultats indépendants pour les 3 tests.

[satinas]

Plus simple, mettre un break sur toutes les ligne tempcheck=0;
A essayer de te suivre j'y pers mon latin

[davidif]

Ca serait bien qu'on arrête de tourner en rond ...
Enlève la variable check et remplace la par int check1a=0, check2a=0, check3a=0;
tu remplaces check=(check+1); par check1a=(check1a+1); idem pour les 2 autres
tu auras des résultats indépendants pour les 3 tests.

satinas, on tournait pas en rond, tout du moins j'avais compris ce que tu souhaitais savoir

test ok.jpg

j'ai fais ce que tu m'a demandé, et sa confirme bien qu'il met un certain temps, s'est à dire environ 5 à 6s pour faire le test et vérifier chaque étape.
Si je fais la pause trop rapidement après avoir lancé le test, tout n'est pas à 1, par contre j'attend environ ce délai et tout est à 1.

Alors effectivement, ça parait long.

[satinas]

Si tu mets des breaks sur les lignes tempcheck=0;
cela s'arrêtera quand il y aura une erreur, pause ou pas pause !
Tes histoires de pause sont incompréhensibles pour moi.

[satinas]

Si j'ai bien compris, ta flash marche très bien, mais tu considères que l'écriture d'une flash doit se faire à la vitesse de la lumière, alors c'est pour ça qu'on a perdu encore des heures à tourner en rond ?
Met 0x7FFFFF dans highest_address et va faire une sieste pendant le test !

[davidif]

satinas, ça y est j'ai fini ma sieste (:

désolé si ta l'impression d'avoir perdu du temps mais c'est ce que j'essayai tant bien que mal de t'expliquer avec mes notions à moi depuis plusieurs postes, sachant que je n'ai pas trop d'élément de comparaison sur le fonctionnement normal d'une mémoire externe, après je ne demande pas qu'elle fonctionne à la vitesse de la lumière mais 5 a 6s pour le test de 7FFFF me Parais excessif pour le transfert, non ?

[davidif]

après je n'ai pas énormément à sauvegarder, environ 312 octet , ma structure (paramètre réseau plus valeurs caractéristiques du fonctionnement à l'extinction)

j'ai commencer la fonction d'écriture, ou j'ai essayé de faire comme la flash interne , en faisant ça

nvm_write_data_spi ((char *)&appDataTCPIP_WIFI, sizeof(appDataTCPIP_WIFI));

void nvm_write_data_spi (char *buf, int size)
{ 
  unsigned long i,j,k;
  
 // check=0;  
    
  Portassign();
  CE_High();
  WP_High();
  Reset_Hold_High();
  CS2_SPI=1;
  WP2_FLASH=1;
  RST2_FLASH=1;
  init();
                
                

            SPI_WREN();

            block_protection_18[0]=0x00;
            block_protection_18[1]=0x00;
            block_protection_18[2]=0x00;
            block_protection_18[3]=0x00;
            block_protection_18[4]=0x00;
            block_protection_18[5]=0x00;
            block_protection_18[6]=0x00;
            block_protection_18[7]=0x00;
            block_protection_18[8]=0x00;
            block_protection_18[9]=0x00;
            block_protection_18[10]=0x00;
            block_protection_18[11]=0x00;
            block_protection_18[12]=0x00;
            block_protection_18[13]=0x00;
            block_protection_18[14]=0x00;
            block_protection_18[15]=0x00;
            block_protection_18[16]=0x00;
            block_protection_18[17]=0x00;

             SPI_WriteBlockProtection();
             SPI_Wait_Busy();
             
             SPI_WREN();
             SPI_Chip_Erase();	//Erase the chip 
             SPI_Wait_Busy();
            

            
            i=0;
            k=0;              
             
            SPI_WREN();


             //while(i<highest_address)
            while(i < size)    
             {	
                  for (j = 0; j < 255; j++)
                  {
                      data_256[j] = buf[k];
                      k++;
                      //if(k>size)k=0;
                  }
                  
                 SPI_WREN();
                       
                SPI_Page_Program(i);
                SPI_Wait_Busy();
                i=i+256;
            }

}

et la lecture, nvm_read_data_spi ((char *)&appDataTCPIP_WIFI, sizeof(appDataTCPIP_WIFI));

void nvm_read_data_spi (char *buf, int size)
{ 
  //unsigned int tempdatalong;   
  unsigned long j;
  //int tempcheck;
    
  
  Portassign();
  CE_High();
  WP_High();
  Reset_Hold_High();
  CS2_SPI=1;
  WP2_FLASH=1;
  RST2_FLASH=1;
  init();

  
            SPI_WREN();


              j=0;
             while(j<size)
             {
                	//SPI_Set_Burst(0x03);
                	//SPI_Read_Burst(j, 64); 			//verify that it got programmed.
                	//SPI_Wait_Busy();

                   SPI_HighSpeed_Read_Cont(j, 64);


                j=j+64;
            }
    
   
}

qui pour le moment me donne pas de retour (:

[satinas]

C'est faux, les premiers posts ou tu en as parlé, tu disais que ça ne marchait pas, de façon laconique, en donnant le code d'erreur pseudo-final, et SANS DIRE que tu interrompais le programme. On va s'en tenir là. Je n'ai plus de temps à perdre.

[davidif]

C'est faux, les premiers posts ou tu en as parlé, tu disais que ça ne marchait pas, de façon laconique, en donnant le code d'erreur pseudo-final, et SANS DIRE que tu interrompais le programme. On va s'en tenir là. Je n'ai plus de temps à perdre.

Désolé si on c'est mal compris, j'ai commencé à en parler à partir du poste 162, sans trop savoir si c'était normal par rapport a la durée c'est tout , il y a rien de volontaire.
quand je te parlais des pause, j'employais pas forcement les bon terms , mais effectivement à un moment données ne voyant pas mon break arrivé j'ai dû interrompre et forcé de constater que les tests étaient bien fait mais au bout de quelques second.

Je répète que je débute dans ce domaine, c'est la raison pour laquelle j'ai besoin de poster pour être aidé et manque de pratique dans le domaine et donc n'emploi pas forcement les mêmes terms qui peuvent faire naître des incompressibles et donner l'impression de tourner en rond.

Après je suis pas loin de la solution, de m'aider à finaliser serait pas négligeable

En tout cas merci de ta patience et grande aide

[davidif]

Bonjour,

En espérant, une aide je poste à nouveau car je ne dois pas être loin, seulement je bloc.

à l'init, je rempli un tableau

uint8_t i;
char j;
j=0;
      
    for(i=0;i<18;i++)
    {

        write_men[i]=j;
        j=j+2;
        
    }

Que j'envoi vers ma flash, je vois bien que ma fonction d'écriture, rempli sont buffer donnée_256[] par mes valeurs et les envois bien, enfin je croix au vus des trames qui passe à l'oscilo et quand je li mes données,c'est pas encore ça, est-ce qu'une bonne âme pourrai m'aider à comprendre (:

nvm_write_data_spi ((char *)&write_men, sizeof(write_men));

nvm_read_data_spi ((char *)&verif_men, sizeof(verif_men));


J'ai fais ma fonction d'écriture

void nvm_write_data_spi (char *buf, int size)
{ 
  unsigned long i,j,k;
  //int status;
  
check1a=0;
check2a=0;
check3a=0; 
 page_bad=0;
 page_good=0;
 i=0;
break_l=0;
  
 status=1;  //1 means memory/code works and 0 means fault has occured.
 check=0;  //keeps track of code progress.
 tempcheck=1; 

               
               
            SPI_WREN();

            block_protection_18[0]=0x00;
            block_protection_18[1]=0x00;
            block_protection_18[2]=0x00;
            block_protection_18[3]=0x00;
            block_protection_18[4]=0x00;
            block_protection_18[5]=0x00;
            block_protection_18[6]=0x00;
            block_protection_18[7]=0x00;
            block_protection_18[8]=0x00;
            block_protection_18[9]=0x00;
            block_protection_18[10]=0x00;
            block_protection_18[11]=0x00;
            block_protection_18[12]=0x00;
            block_protection_18[13]=0x00;
            block_protection_18[14]=0x00;
            block_protection_18[15]=0x00;
            block_protection_18[16]=0x00;
            block_protection_18[17]=0x00;

             SPI_WriteBlockProtection();
              SPI_Wait_Busy();

            SPI_Sector_Erase(0);	//Do Sector Erase
            SPI_Wait_Busy();
              
             i=0;
            SPI_WREN();

            k=0;
             while(i<size)
             {	
                 
                 for(j=0;j<=255;j++)
                 {

                     data_256[j]=buf[k];
                     k++;
                     
                 }
                 

            SPI_WREN();
            SPI_Page_Program(i);
            SPI_Wait_Busy();
            i=i+256;
            break_l=1;
            }

}

Puis la lecture

void nvm_read_data_spi (char *buf, int size)
{   
  unsigned long i,j,k;
  //int status;
  
check1a=0;
check2a=0;
check3a=0; 
 page_bad=0;
 page_good=0;
 
 j=0;
break_l=0;
  
 status=1;  //1 means memory/code works and 0 means fault has occured.
 check=0;  //keeps track of code progress.
 tempcheck=1; 

  

               
            SPI_WREN();

            block_protection_18[0]=0x00;
            block_protection_18[1]=0x00;
            block_protection_18[2]=0x00;
            block_protection_18[3]=0x00;
            block_protection_18[4]=0x00;
            block_protection_18[5]=0x00;
            block_protection_18[6]=0x00;
            block_protection_18[7]=0x00;
            block_protection_18[8]=0x00;
            block_protection_18[9]=0x00;
            block_protection_18[10]=0x00;
            block_protection_18[11]=0x00;
            block_protection_18[12]=0x00;
            block_protection_18[13]=0x00;
            block_protection_18[14]=0x00;
            block_protection_18[15]=0x00;
            block_protection_18[16]=0x00;
            block_protection_18[17]=0x00;

             SPI_WriteBlockProtection();
              SPI_Wait_Busy();

            SPI_WREN();
            j=0;
            i=0;
           // while (j<(4096))
             while (j<size)   
            {
               // SPI_WREN();
               // SPI_Set_Burst(0x03);
                SPI_HighSpeed_Read_Cont(j,256);
                for (k=0;k<255;k++)
                 {
                    
                     buf[i]=data_256[k];
                     i++; 


                 }
                 j=j+256;
                 break_l=2;
            }
   
}

[davidif]

J'ai oublié de préciser, que j'ai commencé par remplir un tableau avec des valeurs incrémenté de 1

write_men[18]={0,1,..,17} quand je li , j'ai du verif_men={0,0,2,2,0,0,10,..} quelques chose comme ça

En faite je ne comprend pas trop cette fonction SPI_HighSpeed_Read_Cont(j, 64); je sais qu'elle censé lire la flash mais 64, veut bien dire de lire 64 octet au qu'elle cas si je souhaite lire UNE PAGE de 256 , je dois mettre 256 ,

[davidif]

Bon bah, juste pour dire que ça fonctionne et j'écris bien dans ma flash et li bien .

Merci encore Satinas

[satinas]

C'est pas toi qui écrit et lit, c'est le Pic32