utilisation flash externe SST26VF064

**davidif** · 30/09/2016, 16h35

Bon ça y est on ma laché (;

j'aurais pourtant bien besoin d'aide, en m'inspirant des dernière fonctions , j'ai fais quelques chose comme ça pour la fonction d'écriture

Code:

void NVM_SST26VF0XXB_WriteByte(uint8_t data, uint32_t address)
{
    SPI_WREN();

    APP_SPI_CS_SELECT();/* enable device */

    DRV_SPI_Put(0x02);
    DRV_SPI_Put(((SST26_ADDRESS)address).uint8Address[2]);
    DRV_SPI_Put(((SST26_ADDRESS)address).uint8Address[1]);
    DRV_SPI_Put(((SST26_ADDRESS)address).uint8Address[0]);
    DRV_SPI_Put(data);

    SPI_WRDI();

    // Wait for write end
    //while(NVM_SST26VF0XXB_IsWriteBusy());
    
}

puis pour la fonction de lecture

Code:

uint8_t NVM_SST26VF0XXB_ReadByte(uint32_t address)
{
    uint8_t temp;
    
    APP_SPI_CS_SELECT();/* enable device */

    DRV_SPI_Put( 0x03);
    DRV_SPI_Put( ((SST26_ADDRESS)address).uint8Address[2]);
    DRV_SPI_Put(((SST26_ADDRESS)address).uint8Address[1]);
    DRV_SPI_Put(((SST26_ADDRESS)address).uint8Address[0]);
    temp = DRV_SPI_read();

    APP_SPI_CS_DESELECT();			/* disable device */

    return (temp);
}

Je viens donc récupérer ma valeur en mémoire flash

Gdome_val=NVM_SST26VF0XXB_Read Byte(0x00000000);

après l'avoir écrite

NVM_SST26VF0XXB_WriteByte(Gdom e_val, 0x0000000);

Mais bon , évidemment ça ne fonctionne pas encore , j'ai un doute sur les pin wp et hol que j'ai mis à "0"

**davidif** · 01/10/2016, 09h17

apparement , je dois être le seul au monde à utiliser ces flash, microchip va pas en vendre beaucoup si ils compte sur moi (:

**davidif** · 03/10/2016, 11h55

juste si mon problème intéresse encore qq (:

après pas mal de test je sort bien du code sur mon bus spi, seulement le teste JEDEC ne me renvoi pas les valeurs attendus

j'ai donc repris les fonctions recommandé par les drivers
http://ww1.microchip.com/downloads/e...ST26VF064B.zip

et donc refait les fonctions une à une, configuré les pin cs, wp, hold, et pour commencer fait le teste JEDEC

Code:

void Jedec_ID_Read()
{


	APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x9F);
	//Send_Byte(0x9F);                    /* send JEDEC ID command (9Fh) */
   	Manufacturer_Id = DRV_SPI_read();       /* receive byte */
  	Device_Type = DRV_SPI_read();           /* receive byte */
  	Device_Id = DRV_SPI_read();            /* receive byte */
    
    Manufacturer_flash=Manufacturer_Id;
    Device_type_flash=Device_Type;
    Device_Id_flash=Device_Id;
    
    
    
    

	APP_SPI_CS_DESELECT();			/* disable device */
}

En visualisant avec mon oscilo 100M de BP, ce que j'envoi me parais coherent, 0x9F part bien mes horloges aussi et CS, le problème est que j'ai que 2 sondes et pas analyseur ce qui est difficile pour moi de bien me rendre compte des temps, mais a priori ça a l'aire d'aller.

Là ou je me pose des questions est sur la forme des données envoyées qui tombent bien à 0 pendant les 2 bits à 0 de l'octet envoyé mais il est pas très beau, je n'ai pas mis de pull up ou down sur les lignes si et so et me et me pose la question sur la nécessité, d'après caractéristiques Cin=6pF ET Cout=8pF

**davidif** · 03/10/2016, 17h10

bonjour à tous,

J'essai d'utiliser ma flash externe SST26VF064B avec mon micro PIC32MX795F512L.
http://ww1.microchip.com/downloads/e.../20005119G.pdf

Je m'inspire des fonctions données sur ce lien : http://ww1.microchip.com/downloads/e...ST26VF064B.zip
Je comprend pas tout ce que ça fait, mais une vague idée pour le moment de certaine fonction

Code:

/* ************************************************************************** */
#include "system_definitions.h"
#include "my_spi_pic32.h"
/* ************************************************************************** */
/* ************************************************************************** */
/* Section: Included Files                                                    */
/* ************************************************************************** */
/* ************************************************************************** */

/* This section lists the other files that are included in this file.
 */

/* TODO:  Include other files here if needed. */

unsigned int data_256[256];	/* global array to store read data */
unsigned int block_protection_18[18];	/* global array to store block_protection data */
unsigned char   Manufacturer_Id, Device_Type, Device_Id; /* global array to store Manufacturer and Device id information */

/* ************************************************************************** */
/* ************************************************************************** */
/* Section: File Scope or Global Data                                         */
/* ************************************************************************** */
/* ************************************************************************** */

/*  A brief description of a section can be given directly below the section
    banner.
 */

/* ************************************************************************** */
/** Descriptive Data Item Name

  @Summary
    Brief one-line summary of the data item.
    
  @Description
    Full description, explaining the purpose and usage of data item.
    <p>
    Additional description in consecutive paragraphs separated by HTML 
    paragraph breaks, as necessary.
    <p>
    Type "JavaDoc" in the "How Do I?" IDE toolbar for more information on tags.
    
  @Remarks
    Any additional remarks
 */
int global_data;

// internal type definition
typedef union
{
    struct
    {
        uint8_t uint8Address[4];
    };

    uint32_t uint32Address;
} SST26_ADDRESS;


/************************************************************************/
/* PROCEDURE:	Page_Program						*/
/*									*/
/* This procedure does page programming.  The destination               */
/* address should be provided.                                  	*/
/* The data array of 256 bytes contains the data to be programmed.      */
/* Since the size of the data array is 256 bytes rather than 256 bytes, this page program*/
/* procedure programs only 256 bytes                                    */
/* Assumption:  Address being programmed is already erased and is NOT	*/
/*		block protected.					*/
/* Input:								*/
/*		Dst:		Destination Address 000000H - 7FFFFFH	*/
/*		data_256[256] containing 256 bytes of data will be programmed using this function */
/************************************************************************/

void APP_SPI_CS_SELECT(void)
{
 CS1_SPI=0;   
    
}

void APP_SPI_CS_DESELECT(void)
{
   CS1_SPI=1; 
    
}

void APP_SPI_CS2_SELECT(void)
{
 CS2_SPI=0;   
    
}

void APP_SPI_CS2_DESELECT(void)
{
   CS2_SPI=1; 
    
}

void Reset1_Hold_Low()
{
    RST1_FLASH=0;
    
}

void Reset1_Hold_High()
{
    RST1_FLASH=1;
    
}

void Reset2_Hold_Low()
{
    RST2_FLASH=0;
    
}

void Reset2_Hold_High()
{
    RST2_FLASH=1;
    
}


void WP1_Low()
{
    WP1_FLASH=0;
}


void WP1_High()
{
    WP1_FLASH=1;
}

void WP2_Low()
{
    WP2_FLASH=0;
}


void WP2_High()
{
    WP2_FLASH=1;
}




void SPI_Page_Program(unsigned long Dst)
{
	unsigned int i;
	i=0;

	
    APP_SPI_CS_SELECT();
    DRV_SPI_Put(0x02);
    DRV_SPI_Put(((Dst & 0xFFFFFF) >> 16));
    DRV_SPI_Put(((Dst & 0xFFFF) >> 8));
    DRV_SPI_Put(Dst & 0xFF);
    
	for (i=0;i<256;i++)
	{	DRV_SPI_Put(data_256[i]);		/* send byte to be programmed */
	}
	APP_SPI_CS_DESELECT();			/* disable device */
}


/************************************************************************/
/* PROCEDURE: Read_Status_Register					*/
/*									*/
/* This procedure reads the status register and returns the byte.	*/
/************************************************************************/


unsigned char SPI_Read_Status_Register()
{
	unsigned char byte = 0;
	APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x05);
	//Send_Byte(0x05);		/* send RDSR command */
	byte = DRV_SPI_read();		/* receive byte */
	APP_SPI_CS_DESELECT();			/* disable device */
	return byte;
}

/************************************************************************/
/* PROCEDURE: WREN							*/
/*									*/
/* This procedure enables the Write Enable Latch.               	*/
/************************************************************************/


void SPI_WREN()
{
	//APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x06);
	//Send_Byte(0x06);		/* send WREN command */
	//APP_SPI_CS_DESELECT();			/* disable device */
}


/************************************************************************/
/* PROCEDURE: WRDI							*/
/*									*/
/* This procedure disables the Write Enable Latch.			*/
/************************************************************************/

void SPI_WRDI()
{
	//APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x04);
	//Send_Byte(0x04);		/* send WRDI command */
	//APP_SPI_CS_DESELECT();			/* disable device */
}


/************************************************************************/
/* PROCEDURE: QuadJ_ID							*/
/*									*/
/* This procedure Reads the manufacturer's ID, device Type and device ID.  It will 	*/
/* use AFh as the command to read the ID.                               */
/* Returns:								*/
/*	ID1(Manufacture's ID = BFh, Device Type =26h , Device ID = 02h)	*/
/*									*/
/************************************************************************/


void Jedec_ID_Read()
{


	//APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x9F);
    //DRV_SPI_Put(0x9F);
    //DRV_SPI_Put(0x9F);
   

    Manufacturer_Id = DRV_SPI_read();
    Device_Type = DRV_SPI_read();
    Device_Id = DRV_SPI_read();
    
    
    Manufacturer_flash=Manufacturer_Id;
    Device_type_flash=Device_Type;
    Device_Id_flash=Device_Id;
    
    

}

Actuellement j'arrive à communiquer tant bien que mal ; j'ai testé le JEDEC et reçois les données d’identification comme tel :

par cette fonction :

Code:

void Jedec_ID_Read()
{

    DRV_SPI_Put(0x9F);

    Manufacturer_Id = DRV_SPI_read();
    Device_Type = DRV_SPI_read();
    Device_Id = DRV_SPI_read();
    
    
    Manufacturer_flash=Manufacturer_Id;
    Device_type_flash=Device_Type;
    Device_Id_flash=Device_Id;
      

}

le truc est que je ne reçois pas les valeur dans l'ordre d'envoi et pas toujours à la valeur correspondante :

La ou je dois avoir :

Code:

   Manufacturer_flash=BF
    Device_type_flash=26
    Device_Id_flash=43

J'ai parfois :

Code:

   Manufacturer_flash=BF
    Device_type_flash=43
    Device_Id_flash=43

ou

Code:

   Manufacturer_flash=BF
    Device_type_flash=BF
    Device_Id_flash=26

Evidemment, l'objectif final est de pouvoir sauvegarder mes valeurs à l'extinction de mon appareil

inviteeb160de1 · 04/10/2016, 09h49

Reste dans ton fil et evite les doublons :
http://forums.futura-sciences.com/el...x795f512l.html

C'est pas en posant deux fois le même post que tu auras davantage d'aide pour un problème dont tu ne donnes toujours que la moitié des détails !

**davidif** · 04/10/2016, 10h11

Envoyé par Aurélien

Reste dans ton fil et evite les doublons :
http://forums.futura-sciences.com/el...x795f512l.html

C'est pas en posant deux fois le même post que tu auras davantage d'aide pour un problème dont tu ne donnes toujours que la moitié des détails !

j'ai récrit un poste avec le bonne intitulé, ce n'était pas une volonté de faire du doublon c'est simplement que je me suis dit qu'au vue des retours peut nombreux il fallait peut-être corriger le titre.

Maintenant, que veux tu comme détails , moi je veux bien donner des détails, seulement j'ai l'impression d'en avoir dit beaucoup.
J'essai simplement d'utiliser une flash dont je site la réf; j'ai mis le lien de la docs, je renseigne mon compilateur, c'est pas de la rétention, simplement n'étant pas expert en prog de micro, j'omet peut-être les informations qui pourrai vous éclairer, mais lesquelles ...

Je me débat pour la faire causer en allant chercher les drivers dont je fait référence, j'ai tant bien que mal réussi à avoir un retour, mais je encore loin du compte.

Merci d'avance pour votre disponibilité et grande aide

inviteeb160de1 · 04/10/2016, 12h30

Aucune idée de pourquoi tu utilises deux variables pour chaque valeur, de la tronche des chronogrammes dont tu parles dans ton autre post, de la config de ton bus SPI...
Tu mélanges trop d'informations, du coup tu nous noies et te noies toi même dedans. Et en plus de ça, tu créées de multiples posts pour le meme sujet.
Rien que dans ton post #1, tu as tellement de commentaires dans ton code qu'on ne va pas à l'essentiel.
Les erreurs que tu rencontres ne sont pas liées à cette mémoire en particulier mais à la façon dont tu la pilotes. Le titre de ton précédent post était donc meilleur !

**Antoane** · 04/10/2016, 12h46

Bonjour,

Fusion des discussions.

Crdt.

**davidif** · 04/10/2016, 13h15

Désolé pour le trop plein d'information, seulement comme je pas trop ou trouver le détaille ou ça cloche, j'ai tendance à tout balancer pour que vous puissiez la trouver plus rapidement.

Envoyé par Aurélien

Aucune idée de pourquoi tu utilises deux variables pour chaque valeur, de la tronche des chronogrammes dont tu parles dans ton autre post, de la config de ton bus SPI...

effectivement, il n'y a pas besoin de redondance de variables , une fois suffit.
Mes chronogrammes sont pas trop lisible avec mon oscilo 2 voies 100Mh de BP plus la capacitée des sondes qui déforme, mais bon a priori au niveau chrono ça a l'aire d'aller, j'ai pu voir que mon horloge arrivais bien au bon moment, les données transitaient bien également et j'ai fais une sélection permanente de CS.

Mon bus SPI est configuré comme tel :
Nom : spi.png
Affichages : 116
Taille : 27,6 Ko

Nom : spi.png
Affichages : 116
Taille : 27,6 Ko

Actuellement, test la fonction JEDEC, je reçois les données mais pas dans le bonne ordre des variables et est changeant en fonction du temps auquel je fais la pause en débug.
Je regarde donc les buffer si ceux-ci sont plein je prend la données puis fait un clear du buffer, mais apparemment quelque chose ne fonctionne pas, mes valeurs reste à 0.

Ma fonction de lecture

Code:

uint8_t DRV_SPI_read(void)
{
 uint8_t buffer;
 
    while(PLIB_SPI_ReceiverBufferIsFull(DRV_SPI_SPI_ID_IDX1)==false){}
    buffer=PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1);
    
    PLIB_SPI_BufferClear(DRV_SPI_SPI_ID_IDX1);
    return buffer;
      
}

le while ne fonctionne pas , les valeur reste à 0 alors que quand je l'enlève , mes valeurs prennent des valeurs différentes, soit bf, soit 26, ou soit 43

après j'execute en permance la fonction jedec

Jedec_ID_Read();

Code:

void Jedec_ID_Read()
{


	//APP_SPI_CS_SELECT();/* enable device */
    DRV_SPI_Put(0x9F);

    Manufacturer_Id = DRV_SPI_read();
    Device_Type = DRV_SPI_read();
    Device_Id = DRV_SPI_read();
    //APP_SPI_CS_DESELECT();/* enable device */
    
}

Envoyé par Aurélien

Tu mélanges trop d'informations, du coup tu nous noies et te noies toi même dedans. Et en plus de ça, tu créées de multiples posts pour le meme sujet.
Rien que dans ton post #1, tu as tellement de commentaires dans ton code qu'on ne va pas à l'essentiel.
Les erreurs que tu rencontres ne sont pas liées à cette mémoire en particulier mais à la façon dont tu la pilotes. Le titre de ton précédent post était donc meilleur !

la ou je te suis c'est qu'effectivement , je suis sous l'eau pour le moment (:

**davidif** · 04/10/2016, 16h39

personne peut m'aider ou je suis pas assez claire (: s'il vous plait, là je rames mais à l'envers sans véritablement de driver ou tout du moins le minimum.

**davidif** · 12/10/2016, 16h15

Bonjour,

bon bah je rame toujours, y aurait-il un sauveur qui pourrait enclencher la machine s'il vous plait ?

je me testé plusieurs driver trouver sur le net et parmis eux je suis tombé sur ce lien et aimerai que quelqu'un me donne son avis sur ceux-ci
https://xa.yimg.com/kq/groups/233890...6-driver.patch

il me parait intéressante, seulement j'ai évidemment quelque problèmes, notamment sur quelques structures comme celle-ci par exemple, ou je ne comprend pas le "FAR"

FAR struct mtd_dev_s *sst26_initialize_spi(FAR struct spi_dev_s *dev);

il parle également de driver MTD

référence à
#include <nuttxmtd/mtd.h>

s'il vous plait, j'aimerai aboutir avec cette flash,

merci de l'aide que vous pourriez m'apporter

inviteeb160de1 · 12/10/2016, 19h04

Et le support technique Microchip ?

**davidif** · 12/10/2016, 20h31

Envoyé par Aurélien

Et le support technique Microchip ?

J'ai eu des contacts à plusieurs reprise, malgré leur réactivité, à ce jour ils n'ont à priori pas de driver SPI pour les mémoire flash SST26 sous harmony, SST25 oui mais pas la SST26.

Leur support vient de m'indiquer récemment un fichier sous hamony qui utilise la mémoire flash SST26 en SQI sur une application, seulement je suis en en SPI et en regardant la data sheet du pic32mx , je pas encore vue comment fonctionne le bus SQI et sur quelle pin est-il présent, sachant que ma flash est déjà câbler sur mon bus SPI4.

d'après les forum de microchip, ils prévoiraient un driver sst26 sous harmony d'ici 2 semaines, seulement j'ai entendu ça il y a déjà 2 ou 3 semaines

En cherchant, sur le net ou bien le site de microchip j'arrive à trouver des fichiers qui implémente du code flash SST26 seulement actuellement j'aurai vraiment besoin d'aide car je ne m'en sort pas.

J'ai réussi tant bien que mal à communiquer en spi avec ma flash pour faire le test jedec, ou j'ai eu en retour les codes(ID, fabricant, ...) mais pas forcement dans l'ordre ou consécutif.

**davidif** · 12/10/2016, 20h36

Poste 93 et 101, montre un lien sur deux endroits ou l'on peut trouver des drivers, je vois des choses similaires notamment sur les différentes commandes pour adresser la flash, j'ai intégré les fonctions une à une dans mon soft.

J'ai tenté des les utiliser en spi

**davidif** · 24/10/2016, 15h41

Bon bah bonjour à tous,

He oui , je encore avec ma flash et désespéré également (:
Bien que j'ai de la vie sur mon bus, celui-ci ne veut toujours pas me répondre et ne sais plus trop quoi faire,

Je suis toujours sur ces drivers là
http://ww1.microchip.com/downloads/e..._installer.exe

Les fichiers :
https://www.dropbox.com/sh/247oili3a...lXRrU3gba?dl=0

En fait, j'initialise ma mémoire en mode SPI, je la débloque et fait un reset :

Code:

void init_sst26_device (void)
{
    DRV_SPI_Open(DRV_SPI_INDEX_1,DRV_IO_INTENT_READWRITE )
    NVM_SST26VF0XXB_WriteStatusRegister(SST26_CMD_RSTQIO);  // mode spi
    NVM_SST26VF0XXB_Reset();   //reset 
    NVM_SST26VF0XXB_WriteStatusRegister(SST26_CMD_ULBPR);   //    
}

TEK00000.jpg

pour l'écriture, j'utilise cette fonction :

Code:

void NVM_SST26VF0XXB_WriteByte(uint8_t data, uint32_t address)
{
    NVM_SST26VF0XXB_WriteEnable();

   NVM_SST26_ChipSelectEnable();

    //DRV_SPI_Put(spiInitData.channel, SST26_CMD_WRITE);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 , SST26_CMD_WRITE);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[2]);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[1]);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[0]);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,data);
    NVM_SST26_ChipSelectDisable();
    
}

TEK00002.jpg TEK00001.jpg

Par contre pour la lecture de ma mémoire, que dale :

Code:

uint8_t NVM_SST26VF0XXB_ReadByte(uint32_t address)
{
    uint8_t temp;
    
    DRV_SPI_Open(DRV_SPI_INDEX_1,DRV_IO_INTENT_READWRITE );
    
    NVM_SST26_ChipSelectEnable();
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 , SST26_CMD_READ);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[2]);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[1]);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,((SST26_ADDRESS)address).uint8Address[0]);
    temp = PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1);
    NVM_SST26_ChipSelectDisable();
    return (temp);
}

TEK00003.jpg et TEK00004.jpg

Merci de vos éclaircissements

invite830075ec · 24/10/2016, 15h58

Salut, est-ce que tu arrives à lire l'id Jedec ?

**davidif** · 24/10/2016, 17h40

Bonjour satinas,

Alors en fait, j'y suis arrivé il fut un temps mais là je n'arrive plus à les récupérer, pourtant j'ai bien un retour de ma commande de demande de JEDEC

A la base j'avais ça

Code:

void NVM_SST26VF0XXB_JEDEC_ID_Check(uint8_t *pManufacturer_Id, uint8_t *pDevice_Type, uint8_t *pDevice_Id)
{
 
    NVM_SST26_ChipSelectEnable();
    // send JEDEC ID command
    DRV_SPI_Put(spiInitData.channel, SST26_CMD_JEDECID);
    *pManufacturer_Id = DRV_SPI_Get(spiInitData.channel);
    *pDevice_Type = DRV_SPI_Get(spiInitData.channel);
    *pDevice_Id = DRV_SPI_Get(spiInitData.channel);

    /*  
        for SST25VF064B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x43;      
     
        for SST25VF032B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x42;

        for SST25VF016B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x41;

    */


    NVM_SST26_ChipSelectDisable();

}

J'ai modifier comme tel :

Code:

void NVM_SST26VF0XXB_JEDEC_ID_Check(uint8_t pManufacturer_Id, uint8_t pDevice_Type, uint8_t pDevice_Id)
{
 
    DRV_SPI_Open(DRV_SPI_INDEX_1,DRV_IO_INTENT_READWRITE );
    
    NVM_SST26_ChipSelectEnable();
    // send JEDEC ID command
    //DRV_SPI_Put(spiInitData.channel, SST26_CMD_JEDECID);
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,  SST26_CMD_JEDECID);
    pManufacturer_Id = PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1);
   
    
    NVM_SST26_ChipSelectEnable();
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,  SST26_CMD_JEDECID);
    pDevice_Type = PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1);

    
    PLIB_SPI_BufferWrite ( DRV_SPI_SPI_ID_IDX1 ,  SST26_CMD_JEDECID);
    pDevice_Id = PLIB_SPI_BufferRead (DRV_SPI_SPI_ID_IDX1);

    /*  
        for SST25VF064B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x43;      
     
        for SST25VF032B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x42;

        for SST25VF016B
        Manufacturer_Id = 0xBF
        Device_Type = 0x26
        Device_Id = 0x41;

    */


    //NVM_SST26_ChipSelectDisable();

}

Voici ce que je visualise pourtant, j'ai bien les code en retour

Nom : TEK00005.jpg
Affichages : 118
Taille : 98,2 Ko

invite830075ec · 24/10/2016, 18h04

J'ai terminé entre-temps la modification du driver de SST pour le pic32. Tu devrais voir ce que ça donne. Il n'y a que la lecture de l'id. C'est une première étape nécessaire pour valider la liaison spi.

**davidif** · 24/10/2016, 18h06

OK je regarde dès que je peux y avoir accés

**davidif** · 24/10/2016, 19h12

Envoyé par satinas

J'ai terminé entre-temps la modification du driver de SST pour le pic32. Tu devrais voir ce que ça donne. Il n'y a que la lecture de l'id. C'est une première étape nécessaire pour valider la liaison spi.

Le temps pour moi de tout remanier, j'ai donc repris tes modifs, qui en soit font bien vivre le bus SPI

TEK00006.jpg

La partie en gras s'exécute qu'une fois a chaque fois ?

Code:

int main()
{
  int check; unsigned int tempdatalong; 
  
  Portassign();
  init();
    
  SPI_WREN();

  tempdatalong = SPI_Read_Status_Register();
  tempdatalong = tempdatalong<<8;
  tempdatalong = tempdatalong | 0x82;
  SPI_Write_Status_Register(tempdatalong, 2);
  
  // Test Jedec ID
  Jedec_ID_Read();
  if (Manufacturer_Id == 0xbf && Device_Type == 0x26 && Device_Id == 0x43) { 
    check = 1;
  } 
  else { 
    check=0; 
  } 

  while (1) ;  return 0;
}

En fait, check ne passe pas à "1", a priori je ne récupère pas les ID

**davidif** · 24/10/2016, 19h46

En mode débug, les ID sont tous à 0xFF, sauf erreur les données sont pris sur le front montant, il me semble la sst prend sur du front descendant, non ?

invite830075ec · 24/10/2016, 19h51

Je ne sais pas, je n'ai pas touché au contenu du driver, je me suis contenté de l'adapter au processeur. Il faut d'abord s'assurer que la lecture marche bien, et ensuite tu pourras voir ce qui est superflu. Il faut d'abord partir d'un truc qui marche. Et tu es le seul à pouvoir le faire, car tu disposes de la flash. Je n'ai pas lu la doc car c'est frustant de lire un document sans pouvoir faire des manips dans la foulée.
Pour ta dernière question, je te rappelle que ce driver vient du fabricant, alors si tu veux le mettre en cause, va falloir des billes.
Ce driver doit marcher tel quel.

**davidif** · 24/10/2016, 20h00

Je suis en train de regarder, et je n'ai pas la prétention du contredire le fabricant à mon stade (:
maintenant j'ai une deuxième flash si tu veux ... je m'en suis récupérer pour éviter de cramer celle sur mes cartes et les essayent sur mon starter kit.

Par contre, ce qui est bizzare c'est que je ne vois pas de signal sur le SO du pic , ce qui n'est évidemment pas possible puisque la sst répond bien à la commande.

invite830075ec · 24/10/2016, 20h11

effectivement, dans get_byte() il lit la data avant de lever le signal clk, surprenant. Mais avant il a envoyé une commande par send_byte(), dont la flash est sans doute prête à envoyer des données.

**davidif** · 24/10/2016, 21h18

Envoyé par satinas

effectivement, dans get_byte() il lit la data avant de lever le signal clk, surprenant. Mais avant il a envoyé une commande par send_byte(), dont la flash est sans doute prête à envoyer des données.

Juste pour info ; voila ce que je lis sur mon SI sst26 :

06 05 FF 01 FF 82 9F FF FF

J'ai l'impression d'avoir les so et si inversé ou c'est moi ?

**davidif** · 24/10/2016, 21h24

Voici le début

Nom : TEK00007.jpg
Affichages : 117
Taille : 106,5 Ko

**davidif** · 24/10/2016, 21h37

quand on fait un

void Portassign()
{
SST_CE_TRIS = 0; // outputs sst
SST_SCK_TRIS = 0;
SST_SI_TRIS = 0;
SST_SO_TRIS = 1; // input sst
}

on parle bien du côté du pic ? ou du côté de le sst

Il n'y aurait pas un problème quelque part

invite830075ec · 24/10/2016, 21h45

Je ne comprends pas ce que tu ne comprends pas.

**davidif** · 24/10/2016, 22h22

OK ça fonctionne

Nom : ID.jpg
Affichages : 103
Taille : 13,1 Ko

Enfin , quelque chose d'encourageant, ça fait du bien (:

j'ai modifier et mis :

SST_SO_LAT au Send_Byte()

et SST_SI_PORT au Get_Byte()

Code:

void Send_Byte(unsigned char out)
{
	unsigned char i = 0;

	for (i = 0; i < 8; i++) {
		if ((out & 0x80) == 0x80)	/* check if MSB is high */
			SST_SO_LAT = 1;
		else
			SST_SO_LAT = 0;         /* if not, set to low */
		SST_SCK_LAT = 1;          /* toggle clock high */
		out = (out << 1);	        /* shift 1 place for next bit */
		SST_SCK_LAT = 0;          /* toggle clock low */
	}
}

/************************************************************************/
/* PROCEDURE: Get_Byte							                                    */
/*					                                                    				*/
/* This procedure inputs a byte shifting in 1-bit per clock falling	    */
/* edge on the SIO1 pin(LSB 1st).					                              */
/************************************************************************/
unsigned char Get_Byte()
{
	unsigned char i = 0, in = 0, temp = 0;

	for (i = 0; i < 8; i++)	{
		in = (in << 1);		        /* shift 1 place to the left or shift in 0 */
		temp = SST_SI_PORT;		    /* save input */
		SST_SCK_LAT = 1;          /* toggle clock high */
	  if (temp == 1)			      /* check to see if bit is high */
		  in = in | 0x01;		      /* if high, make bit high */
		SST_SCK_LAT = 0;          /* toggle clock low */
	}
	return in;
}

invite830075ec · 24/10/2016, 22h31

CE, SCK, SO, SI sont les noms des pins de la flash, voir datasheet, les pins étaient baptisées correctement. SO n'est pas une pin spi du pic, c'est SDO

utilisation flash externe SST26VF064

Re : utilisation mémoire flash SST25VF064C pic32mx795f512l

Re : utilisation mémoire flash SST25VF064C pic32mx795f512l

Re : utilisation mémoire flash SST25VF064C pic32mx795f512l

utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Re : utilisation flash externe SST26VF064

Discussions similaires

Questions compatibilité mémoire flash externe

Données d'un disque dur interne non reconnu en utilisation externe

Utilisation DMA du PIC32 pour mémoire flash sur SPI

Emuler une liaison SPI memoire Flash externe avec un PIC