Ajouter un module au logiciel Total Phase Flash Center

TotalPhase

1. Introduction

Bien que de nombreux dispositifs de mémoire soient inclus par défaut dans la liste des pièces du Flash Center, il se peut que les utilisateurs se rendent compte que la pièce qu'ils souhaitent programmer n'est pas disponible. C'est pourquoi le Flash Center contient une méthode permettant aux utilisateurs d'ajouter des pièces de mémoire supplémentaires à la bibliothèque et de spécifier les paramètres pour la programmation de ces pièces. Pour ajouter un périphérique de stockage au Flash Center, l'utilisateur doit d'abord définir les paramètres de programmation des périphériques de stockage dans un fichier XML, puis charger le fichier dans le Flash Center.

2. Importer des fichiers de périphériques de stockage

Il existe deux méthodes pour ajouter des périphériques de stockage à la liste des pièces du Flash Center à partir d'un fichier de pièces de stockage.

Une méthode pour charger le fichier dans le Flash Center consiste à ouvrir la boîte de dialogue Sélectionner le périphérique cible, puis à cliquer sur le bouton Charger le fichier de pièces .... Le fichier de pièce de stockage peut ensuite être sélectionné dans la boîte de dialogue de sélection de fichier.

L'autre façon d'ajouter les pièces définies dans un fichier de pièces de mémoire est de placer le fichier dans le répertoire de pièces du Flash Center. Ce répertoire se trouve dans le répertoire d'installation du Flash Center et s'appelle Pièces. Lorsque le Flash Center est lancé, tous les fichiers ayant l'extension .xml sont automatiquement chargés dans le répertoire des pièces.

Quelle que soit la méthode choisie pour charger le fichier de pièces de mémoire, les pièces sont intégrées dans la liste des pièces si elles sont correctement formatées et peuvent être sélectionnées pour la programmation dans la boîte de dialogue Sélectionner l'appareil cible.

Remarque : les paramètres d'utilisation de l'appareil pour les appareils de stockage doivent être uniques. Si les paramètres de nom de périphérique sont dupliqués entre les définitions de pièces, les pièces chargées plus tard écrasent les définitions de pièces chargées plus tôt. Si tu utilises l'option "Charger le fichier de pièces ...", cela est utile car cela permet d'affiner les définitions des pièces sans avoir à redémarrer le Flash Center. Si les pièces avec des paramètres doubles pour le nom de l'appareil se trouvent dans le répertoire des pièces, il est impossible de savoir lesquelles seront chargées.

3. Définir des fichiers de périphérique de stockage

Pour ajouter un périphérique de stockage à la liste de pièces de Flash Centers, la pièce doit d'abord être définie dans un fichier de pièces de stockage.

Pour utiliser un débit binaire plus élevé que le débit binaire maximal spécifié dans la bibliothèque de pièces avec la Promira Serial Platform, il faut mettre à jour un fichier dans le répertoire des pièces.

Le débit binaire SPI maximal avec la Promira Serial Platform avec l'application SPI Active Level 3 est de 80 MHz.
Vérifie la fiche technique de la pièce de mémoire pour t'assurer que la pièce de mémoire supporte le débit binaire souhaité.
ouvre le fichier dans le répertoire des pièces qui indique la pièce de mémoire souhaitée.
Mettre à jour maxBitrate pour obtenir le débit binaire souhaité. Vérifie que ce bitrate est égal ou inférieur au bitrate maximum de ta Promira Serial Platform.
Il n'est pas recommandé de mettre à jour d'autres nœuds.
L'exemple suivant montre un fichier de partie mémoire à partir d'un des fichiers fournis avec le Flash Center : st-spi-flash-m25pe.xml. Il définit 4 parties de mémoire qui héritent la plupart de leurs paramètres des valeurs par défaut globales ou des valeurs par défaut déclarées en haut du fichier.

<?xml version="1.0" binding="UTF-8"?> <devices> <default version="1.0">.<manufacturerName> STMicro </manufacturerName> <deviceAlgorithm>SPI flash</deviceAlgorithm> <maxBitrate>33000</maxBitrate> <addressWidth>3<<addressWidth> <readDummyBytes>1</readDummyBytes> <writeSize>256</ writeSize> <eraseSize>256</eraseSize> <writeTime>1200</writeTime> <eraseSize>256</eraseSize> <writeTime>1200</writeTime> <readDummyByBytes>1</readDummyByByteseraseTime>10000</eraseTime> <readInstruction>0x0b</readInstruction> <readDeviceIdInstruction>0x9f</readDeviceIdInstruction> <eraseInstruction>0xdb</eraseInstruction> <deviceConnectedBits>0x00</deviceConnectedBits><deviceConnectedMask>0xfc</deviceConnectedMask> </default> <device version="1.0"> <deviceName>M25PE10</deviceName> <deviceDescription> STMicro M25PE10 128 kilobytes SPI Flash </deviceDescription> <deviceDescription> <deviceDescription>.capacity>128*1024</capacity > <expectedDeviceId>\\x20\x80\\x11</expectedDeviceId> </device> <device version="1.0"> <deviceName>M25PE20</deviceName> <deviceDescription> STMicro M25PE20 256 kilobytes SPI Flash </deviceDescription> <capacity>256*1024</capacity> <expectedDeviceId>\x20\x80\\x12</expectedDeviceId> </device> <device version="1.0"> <deviceName>M25PE40</deviceName> <deviceDescription> STMicro M25PE40 512 kilobytes SPI Flash </deviceDescription> <deviceDescription> <deviceDescription>.capacity>512*1024</capacity> <expectedDeviceId>\x20\\x80\\x13</expectedDeviceId> </device> <device version="1.0"> <deviceName>M25PE80</deviceName> <deviceDescription> STMicro M25PE80 1 Megabyte SPI Flash </deviceDescription> <capacity>1024*1024</capacity> <maxBitrate>50000</maxBitrate> <hasEraseAll>true</hasEraseAll> <writeTime>1350</writeTime> <eraseAllTime>10*1000000</eraseAllTime> <eraseAllInstruction>0xc7</eraseAllInstruction> <expectedDeviceId>\x20\x80\x14</expectedDeviceId> </device> <device version="1.0"> <deviceName>M25PE16</deviceName> <deviceDescription> STMicro M25PE16 2 mégaoctets SPI Flash </deviceDescription> <capacity>2*1024*1024</capacity> <maxBitrate>50*1000</maxBitrate> <blockProtectBits>0x1c </blockProtectBits> <hasEraseAll>true</hasEraseAll> <writeTime>800</writeTime> <eraseAllTime>17*1000000</eraseAllTime> <eraseAllInstruction>0xc7</eraseAllInstruction>. <expectedDeviceId>\x20\\x80\\x15 </expectedDeviceId> <deviceConnectedMask>0x60</deviceConnectedMask> </device> </devices>

3.1. format de pièce de fichier de mémoire

Le format de définition des pièces utilisé pour le Flash Center est basé sur XML. (Tu trouveras un aperçu du format XML sur le site officiel XML à l'adresse http://www.w3.org/XML/)

Le format de fichier de pièce de mémoire contient plusieurs éléments. Il commence par la déclaration XML et est suivi du nœud <devices>, qui peut contenir un nœud <default> et plusieurs nœuds <device>. Le nœud <standard> et le nœud <appareil> contiennent chacun plusieurs éléments qui définissent des valeurs de paramètres pour les appareils de stockage. Chaque nœud <appareil> définit un seul appareil de stockage. Le nœud <Standard> peut être utilisé pour définir des caractéristiques communes à tous les éléments de stockage du fichier.

Déclaration XML

La première ligne du fichier d'exemple est la ligne de déclaration XML. Cette ligne devrait être la première ligne de tous les fichiers de parties de mémoire.

Nœud de dispositif

Le seul élément au niveau de la racine dans le fichier XML est le nœud d'élément <appareils>. Tous les autres éléments du fichier sont des sous-nœuds du nœud <appareils>. La deuxième ligne du fichier devrait être la déclaration du nœud <appareils>, et la dernière ligne du fichier devrait fermer le nœud <appareils>. Le nœud <default> et tous les nœuds <device> devraient être des sous-nœuds du nœud <devices>.

Nœud standard

Le nœud <Standard> est un nœud optionnel qui définit les valeurs de paramètres communes pour tous les appareils définis dans le fichier. Tous les paramètres définis dans le nœud <Standard> remplacent les valeurs par défaut intégrées pour ce paramètre unique.

L'élément <default> a un attribut, version, qui doit être fixé à 1.0. Il ne devrait y avoir qu'un seul nœud <standard> . S'il y a plus d'un nœud <standard> , seul le premier est analysé. les autres sont ignorés.

Nœuds d'appareils

Chaque nœud <appareil> dans le fichier de mémoire définit une partie de mémoire individuelle. Sous le nœud <appareils>, plusieurs nœuds <appareils> sont autorisés, chacun d'entre eux définissant un appareil de stockage différent. Les valeurs de paramètres déclarées sous chaque nœud <appareil> définissent les caractéristiques de l'appareil et identifient également la méthode de programmation pour l'appareil de stockage. Les paramètres définis dans chaque nœud <appareil> varient en fonction du type d'appareil de stockage et des particularités de l'appareil de stockage.

Lors de l'ajout de nouvelles pièces à la liste de pièces du Flash Center, il est important que la nouvelle pièce ait un nom unique, comme défini dans le paramètre <Nom du périphérique>. S'il y a des pièces de mémoire qui ont la même valeur <deviceName>, une seule des pièces sera ajoutée à la liste des pièces. Dans cette situation, un avertissement est affiché à l'utilisateur.

L'élément <device> dispose d'un attribut, version, qui doit être mis à 1.0.

Nœud dualIO et nœud quadIO

Le nœud <dualIO> et le nœud <quadIO>, qui sont autorisés sous le nœud <device>, définissent le mode Dual-E / A et le mode Quad-E / A pour le périphérique de stockage. Si Dual ou Quad est sélectionné pour le mode SPI-E / A, les paramètres sous le nœud <dualIO> ou <quadIO> sont utilisés. Tous les paramètres qui ne sont pas définis sous ces nœuds sont hérités du nœud <appareil>

3.2 Paramètres du dispositif

Dans le fichier de la partie mémoire, chaque dispositif de mémoire est décrit comme une liste de valeurs de paramètres qui définissent des caractéristiques telles que le nom du dispositif, la taille de la mémoire, le type de dispositif, etc. Les paramètres nécessaires pour définir une certaine partie de la mémoire Cela dépend du type de mémoire ainsi que d'autres caractéristiques spécifiques de la partie.

Remarque : Les noms des paramètres sont sensibles à la casse.

Valeurs par défaut des paramètres

Pour certains paramètres, des valeurs par défaut sont définies, de sorte qu'il n'est pas nécessaire de les définir pour la plupart des dispositifs de stockage. Par exemple, baseDeviceAddress et writeInstruction ont des valeurs par défaut de 0x50 et 0x02 respectivement. Ces valeurs par défaut sont prises à partir de valeurs typiques pour ces paramètres. Pour de nombreuses pièces de mémoire, les valeurs par défaut sont correctes, de sorte que ces paramètres ne doivent pas être définis dans le nœud <appareil>. Pour les pièces dont les valeurs des paramètres diffèrent des valeurs par défaut, l'indication de ce paramètre remplace la valeur par défaut.

En outre, il est possible de définir des valeurs de paramètres par défaut spécifiques aux fichiers en définissant la valeur du paramètre dans le nœud <Standard>. Les paramètres définis sous le nœud <Standard> remplacent les valeurs standard régulières. Comme pour les valeurs par défaut normales, les paramètres par défaut spécifiques aux dates peuvent également être écrasés dans le nœud <Périphérique> pour chaque partie de la mémoire.

Types de paramètres

Il existe quatre types principaux de paramètres de l'appareil : les données textuelles, booléennes, entières et binaires. De plus, il existe un paramètre, deviceAlgorithm, un paramètre de type texte pour lequel seules trois valeurs spécifiques sont acceptées.

Les paramètres "texte" peuvent accepter n'importe quelle entrée de texte. Les exemples sont ManufacturerName et deviceDescription, et toute valeur de chaîne de caractères autorisée par XML est acceptée.

Les paramètres "booléens" permettent deux valeurs : true ou false, les majuscules et les minuscules ne sont pas prises en compte. Les exemples de paramètres booléens sont hasEraseAll et BusyBitPolarity.

Les paramètres "Integer" acceptent des valeurs numériques non signées. Par défaut, les valeurs entières sont analysées comme des valeurs décimales. Si tu ajoutes 0x à la valeur, le Flash Center analyse la valeur en tant que valeur hexadécimale. En outre, les valeurs entières peuvent être définies comme une multiplication de deux valeurs avec le symbole *. (Aucun espace n'est autorisé autour du symbole *.) Par exemple, 16384, 0x4000, 16 * 1024, 0x10 * 0x400 et 0x10 * 1024 représentent la même valeur. Des exemples de paramètres entiers sont la capacité, writeInstruction et deviceBusyBit.

Les paramètres "données binaires" représentent une séquence de valeurs d'octets. Chaque valeur d'octet dans la séquence peut être représentée par n'importe quel caractère autorisé par XML ou être saisie comme valeur hexadécimale avec le préfixe \ x. Par exemple, abc123, \ x20 \ x80 \ x14 et abc \ xff sont des entrées valides pour une valeur de données binaires.

Types de périphériques de stockage

Il existe trois types de périphériques de stockage pris en charge par le Flash Center. Ce sont les suivants : I2C-EEPROM, SPI-EEPROM et SPI-Flash. Certains paramètres des périphériques de stockage sont communs aux trois types de périphériques de stockage, tandis que certains sont spécifiques aux EEPROM I2C, certains sont spécifiques aux périphériques SPI (aussi bien les EEPROM que les périphériques Flash) et certains paramètres sont spécifiques aux périphériques Flash SPI.

3.3 Paramètres globaux du périphérique de stockage

Ce qui suit est un tableau des paramètres qui sont communs à tous les périphériques de stockage. Tous ces paramètres doivent être définis pour chaque partie de la mémoire.

Paramètres	Type	Défaut	Description
`deviceAlgorithm`	text		Le type de périphérique de stockage. L'algorithme de programmation est déterminé en fonction de la valeur de ce paramètre. Les valeurs prises en charge sont i2c eeprom, spi eeprom et spi flash, sans tenir compte des majuscules et des minuscules.
`deviceName`	text		Le nom du périphérique de stockage. Note que le nom du périphérique doit être unique ; les périphériques avec des noms doubles provoquent une erreur.
`deviceDescription`	text		Une longue description du dispositif. S'affiche lorsque le périphérique de stockage est sélectionné pendant la sélection de la destination. Normalement, elle contient le nom du fabricant, le nom de l'appareil, la taille de la mémoire et le type d'appareil.
`nom du fabricant`	text		Le fabricant du dispositif de stockage.
`capacity`	int		Taille de l'appareil en octets. La valeur ne doit pas être nulle.
`maxBitrate`	int		Le débit binaire maximal que l'appareil peut utiliser pour communiquer avec l'adaptateur de programmation. La valeur ne doit pas être nulle. S'il y a plusieurs niveaux de vitesse pour la partie mémoire, le débit binaire le plus élevé est recommandé pour ce paramètre.
`addressWidth`	int	`1`	Le nombre d'octets dans le champ d'adresse de la mémoire lors de la lecture depuis et de l'écriture sur l'appareil. Si l'adresse comporte des bits de débordement, ils sont automatiquement ajoutés à l'adresse de l'appareil (I2C) ou au code de commande (SPI). La valeur ne doit pas être nulle.
`writeSize`	int		Le nombre d'octets par écriture. Pour les pièces avec des tailles de page variables, saisis la taille de la plus petite page. La valeur ne doit pas être nulle.
`writeTime`	int		Le nombre de microsecondes nécessaires pour terminer une opération d'écriture sur une seule page. Utilise la valeur minimale ou typique, car le Flash Center peut interroger l'appareil pour attendre un temps supplémentaire si nécessaire. S'il y a plusieurs niveaux de vitesse pour la partie mémoire, le temps le plus bas est recommandé pour ce paramètre. La valeur ne doit pas être nulle.

3.4 Paramètres du dispositif de mémoire I2C

Ce qui suit est un tableau des paramètres qui sont spécifiques aux dispositifs de mémoire I2C EEPROM.

Paramètres	Type	Standard	Description
`baseDeviceAddress`	int	`0x50`	L'adresse de l'appareil de base pour les appareils I 2 C .
`pageShift`	int	`0`	Les appareils dont la capacité dépasse le nombre total de bits fournis dans leur mot d'adresse utilisent des bits de l'adresse de l'appareil I 2 C pour adresser complètement les données. Le paramètre `pageShift` indique la position du bit le moins significatif de ces bits d'adresse dans l'adresse de périphérique I 2 C . Ce paramètre est normalement nul, mais la famille Microchip 24xx1025 en est une qui nécessite ce paramètre.
`autoPageUpdate`	bool	`VRAI`	Les appareils dont la capacité dépasse le nombre total de bits fournis dans leur mot d'adresse utilisent des bits I 2 C -adresse de l'appareil pour adresser complètement les données. Le paramètre `autoPageUpdate` indique si le compteur d'adresses interne de l'appareil peut dépasser automatiquement des limites de pages, de sorte que ces bits n'ont pas besoin d'être modifiés pendant une lecture séquentielle. Ce paramètre est toujours `faux,` si `pageShift` n'est pas nul.

3.5 Paramètres requis pour les dispositifs de mémoire SPI

Ci-dessous, tu trouveras un tableau des paramètres nécessaires qui sont spécifiques aux appareils SPI EEPROM et aux appareils SPI Flash. Tous ces paramètres doivent être définis pour tous les dispositifs de mémoire SPI. Cependant, pour beaucoup de ces paramètres, les valeurs par défaut sont les bonnes valeurs

Paramètres	Type	Standard	Description
`readStatusRegisterInstruction`	int	`0x05`	L'instruction pour lire le registre d'état du dispositif. C'est le registre qui contient le bit de busy et les bits de protection de bloc. Il faut le définir pour permettre la requête.
`deviceBusyBit`	int	`0x01`	Les bits du registre d'état qui indiquent qu'une opération est en cours. Ce paramètre est utilisé comme masque de bits dans le registre d'état pour déterminer l'état occupé. Ceci doit être réglé pour permettre l'interrogation.
`BusyBitPolarity`	bool	`FAUX`	La polarité du bit busy dans le registre d'état. `Est` mis`à "true`" si le bit busy a une polarité inversée, ce qui signifie que 1 prêt.
`instruction read`	int	`0x03`	L'instruction qui initie une lecture à partir de l'appareil. Pour les appareils avec une instruction de lecture rapide, la valeur par défaut doit être remplacée.
`readDummyBytes`	int	`0`	Le nombre d'octets de remplissage qui sont insérés entre `readInstruction` et le déplacement des données hors de l'appareil. Normalement, ce paramètre ne doit être défini que pour les appareils Flash avec une instruction de lecture rapide.
`writeInstruction`	int	`0x02`	L'instruction d'écrire des données sur l'appareil.
`writeEnableInstruction`	int	`0x06`	L'instruction envoyée pour permettre l'écriture sur l'appareil. Mettre à 0 si l'appareil n'a pas d'instruction d'activation d'écriture.
`writeDisableInstruction`	int	`0x04`	L'instruction envoyée pour quitter le mode d'écriture. Mettre à 0 si l'appareil n'a pas d'instruction de blocage d'écriture.
`writeEnableBits`	int	`0x02`	Les bits du registre d'état qui indiquent la bonne exécution de l'instruction `writeEnableInstruction` indique .

3.6 Paramètres optionnels des dispositifs de stockage SPI

Ci-dessous, tu trouveras un tableau avec des paramètres optionnels spécifiques aux appareils SPI-EEPROM et aux appareils SPI-Flash. Bien que ces paramètres ne soient pas nécessaires, leur définition améliore la capacité du Flash Center à détecter les erreurs pendant le processus de programmation.

Paramètres	Type	Standard	Description
`readDeviceIdInstruction`	int		Pour les appareils qui le supportent, l'instruction pour lire l'ID de l'appareil.
`iD de périphérique attendu`	Données binaires _		Le code ID attendu par l'instruction de lecture de l'ID de l'appareil. La définition de ce paramètre n'est nécessaire que si l'instruction de lecture de l'ID de l'appareil est également présente `readDeviceIdInstruction` est définie.
`advancedAddressingEnableInstruction`	int		Pour les grands périphériques de stockage avec des opérations de lecture, de programmation et d'effacement rétrocompatibles, cette commande active le mode d'adressage avancé pour ces opérations rétrocompatibles. Pour les appareils avec de nouvelles instructions de lecture, de programmation et d'effacement seulement étendues, indique ces instructions au lieu de cette commande.
`writeBufferInstruction`	int		Pour les dispositifs de mémoire qui disposent d'un processus de programmation de page en deux parties, cela définit l'instruction pour écrire des données dans un tampon de mémoire. Tu trouveras des exemples de parties de mémoire qui utilisent des tampons de mémoire pour la programmation de page dans la famille Atmel AT45DBxxxx de dispositifs flash SPI.
`writeAutoAddressIncrementInstruction`	int		Pour les dispositifs de stockage SST qui disposent d'un processus de programme AAI (Auto Address Increment), cela définit l'instruction de programme AAI.
`writeAutoAddressIncrementSize`	int		Pour les périphériques de stockage SST qui disposent d'un processus de programme AAI (Auto Address Increment), cela définit le nombre d'octets qui suivent chaque instance de la commande AAI. La valeur doit être différente de zéro si l'instruction de programme AAI est définie.
`writeAutoAddressIncrementTime`	int		Pour les périphériques de stockage SST qui ont un processus de programme AAI (Auto Address Increment), cela définit le nombre de microsecondes nécessaires pour terminer chaque itération d'écriture AAI. Contrairement à `writeTime` cette valeur doit être le temps d'écriture maximum et non le minimum. La valeur doit être différente de zéro si l'instruction de programme AAI est définie.
`writeStatusRegisterInstruction`	int	`0x01`	L'instruction pour écrire dans le registre d'état. Mis à 0 si l'appareil n'a pas d'instruction pour écrire dans le registre d'état.
`writeStatusRegisterEnableInstruction`	int		L'instruction d'autoriser l'écriture dans le registre d'état. Définir ce paramètre pour les pièces qui ont des instructions séparées pour l'autorisation d'écriture et l'autorisation du registre d'état d'écriture. Si ce paramètre n'est pas défini, le Flash Center utilise le paramètre défini pour l'autorisation d'écriture `writeEnableInstruction` valeur définie .
`writeStatusRegisterTime`	int	`5000`	Le nombre de microsecondes nécessaires pour terminer une écriture dans le registre d'état. Utiliser la valeur minimale ou typique, car le Flash Center peut interroger le périphérique pour attendre un temps supplémentaire si nécessaire. S'il existe plusieurs niveaux de vitesse pour la partie mémoire, le temps le plus bas est recommandé pour ce paramètre.
`deviceConnectedBits`	int		Les bits du registre d'état qui sont toujours définis sur 1 . C'est ce que l'on fait avec le paramètre `"deviceConnectedMask"` utilisé pour détecter les appareils SPI non connectés. Tu trouveras plus d'informations sur ce paramètre dans la section suivante.
`deviceConnectedMask`	int		Les bits du registre d'état qui ont une valeur fixe. Ceci est utilisé avec le paramètre `"deviceConnectedBits"` utilisé pour détecter les appareils SPI non connectés. Si non défini, utilise la valeur de `deviceConnectedBits est utilisé.` Tu trouveras plus d'informations sur ce paramètre dans la section suivante.
`blockProtectBits`	int	`0x9c`	Détermine quels bits du registre d'état indiquent que les blocs de l'appareil ou le registre d'état sont protégés en écriture. Tu trouveras plus d'informations sur ce paramètre dans la section suivante.
`Mode sommeil`	int	`0`	Définit le mode SPI (0-3). 0 : mode 0. Les données sont capturées sur le front montant de l'horloge (transition de bas à haut) et les données sont passées sur un front descendant (transition de haut à bas). 1 : mode 1. Les données sont capturées sur le front descendant de l'horloge et passées sur un front montant. 2 3 : Mode 3. les données sont saisies sur le front montant de l'horloge et transmises sur le front descendant.
`spiBitorder`	bool	`VRAI`	Définit l'ordre des bits SPI. L'option bitorder est utilisée pour indiquer si LSB ou MSB est déplacé en premier. Est défini sur "true" pour MSB.
`spiSSPolarity`	bool	`VRAI`	Définit la polarité SS, c'est-à-dire la polarité de sortie sur la ligne SS. Définit "true" pour le bas actif.

Bits liés à l'appareil et masque

Dans le protocole SPI, il n'y a pas de méthode prédéfinie pour un appareil esclave SPI pour confirmer la réception des commandes du maître SPI. Par conséquent, le maître SPI pourrait envoyer une commande à l'esclave, mais il se peut que le maître ne dispose pas d'une méthode pour déterminer si un appareil esclave a été connecté pour la recevoir. Cependant, si un périphérique de stockage SPI a des bits dans le registre d'état qui ont toujours une valeur fixe, le registre d'état du Flash Center peut être utilisé pour déterminer s'il y a une connexion au périphérique ou non.

Les paramètres deviceConnectedBits et deviceConnectedMask sont utilisés pour définir ces bits dans le registre d'état. Le paramètre deviceConnectedMask indique à Flash Center quels bits ont une valeur fixe, et deviceConnectedBits indique la valeur de ces bits. Si ces paramètres sont définis pour un périphérique de stockage, le Flash Center vérifie ces bits pour voir s'ils sont connectés au périphérique cible, aussi bien lorsque le périphérique de stockage est inactif que lorsqu'une opération de stockage, comme un programme de page ou une opération d'effacement de secteur, est en cours .

Si deviceConnectedBits est défini, mais que deviceConnectedMask est indéfini ou 0, le Flash Center utilise la valeur de deviceConnectedBits pour deviceConnectedMask. Par conséquent, le Flash Center ne peut reconnaître que les bits du registre d'état qui ont une valeur fixe de 1, mais pas les bits qui ont une valeur fixe de 0.

Si deviceConnectedBits et deviceConnectedMask sont tous deux indéfinis ou égaux à 0, le registre d'état ne sera pas utilisé pour détecter une connexion au périphérique de stockage cible.

Remarque : certains périphériques de stockage renvoient des résultats différents lorsque le registre d'état est lu pendant une opération de stockage. Par exemple, la famille AT25xxxx d'Atmel renvoie b1111_1111 pendant l'exécution d'une opération de stockage. Comme aucun des bits du registre d'état n'a la même valeur lorsque les pièces sont inactives, deviceConnectedBits et deviceConnectedMask ne sont pas définis pour ces pièces, et le registre d'état n'est pas utilisé pour déterminer une connexion aux pièces.

Bits de protection de bloc

La plupart des pièces de mémoire SPI disposent d'un système permettant de protéger les parties de la mémoire contre les modifications. Le paramètre blockProtectBits indique à Flash Center quels bits du registre d'état indiquent que la protection de bloc est activée. En général, un appareil de stockage a un bit dans le registre d'état pour indiquer que la protection des blocs est activée, ainsi que des bits qui indiquent quels blocs sont protégés. Tous ces bits doivent être contenus dans le paramètre blockProtectBits.

Si au début d'une opération d'effacement ou d'écriture, l'un des bits de protection de bloc dans le registre d'état est différent de zéro, le Flash Center écrit 0 dans le registre d'état pour supprimer la protection de bloc. Si la commande d'écriture du registre d'état n'est pas définie ou si l'écriture dans le registre d'état n'efface pas les bits de protection de bloc, un message d'erreur s'affiche et l'opération se termine.

Pour les appareils dont les bits de protection de bloc ne sont pas effacés par l'écriture dans le registre d'état (par exemple, ils ont des instructions spéciales pour effacer la protection de bloc), la protection de bloc doit être effacée avant d'utiliser le Flash Center pour programmer l'appareil.

3.7 Paramètres de périphérique de stockage SPI définissables par l'utilisateur

Ci-dessous, tu trouveras un tableau de paramètres optionnels définissables par l'utilisateur, disponibles à la fois pour les appareils SPI-EEPROM et pour les appareils SPI-Flash. Avec deux champs de transaction utilisateur, les utilisateurs peuvent définir n'importe quelle donnée de transaction SPI que Flash Center envoie avant chaque lecture, écriture ou suppression.

Paramètres	Type	Standard	Description
`userTransaction1`	Données binaires _		Transaction définissable par l'utilisateur, envoyée avant le début de chaque opération de lecture, de programmation ou d'effacement.
`userTransaction2`	Données binaires _		Transaction définissable par l'utilisateur, envoyée avant le début de chaque opération de lecture, de programmation ou d'effacement.
`userTransaction1WriteEnable`	bool	`FAUX`	Mettre`sur "true`" pour envoyer writeEnableInstruction avant d'envoyer `de userTransaction1` .
`userTransaction2WriteEnable`	bool	`FAUX`	Mettre`sur "true`" pour envoyer writeEnableInstruction avant d'envoyer `de userTransaction2` .
`userTransaction1Time`	int		Le nombre de microsecondes nécessaires pour terminer `de userTransaction1` . Utiliser la valeur minimale ou typique, car le Flash Center peut interroger l'appareil pour attendre un temps supplémentaire si nécessaire. S'il y a plusieurs vitesses pour la partie mémoire, le temps le plus bas est recommandé pour ce paramètre.
`userTransaction2Time`	int		Le nombre de microsecondes nécessaires pour terminer `de userTransaction2` . Utiliser la valeur minimale ou typique, car le Flash Center peut interroger l'appareil pour attendre un temps supplémentaire si nécessaire. S'il y a plusieurs niveaux de vitesse pour la partie mémoire, le temps le plus bas est recommandé pour ce paramètre.

Remarques sur les transactions personnalisables

Les octets indiqués dans les deux champs userTransaction sont envoyés tels quels sur le bus SPI. L'octet d'instruction et les autres données doivent être combinés dans un champ userTransaction. Si l'opération fournie nécessite une autorisation d'écriture (par exemple la programmation de registres), utilise les champs bool pour l'autorisation d'écriture.

L'exemple suivant montre la programmation d'un registre de configuration non volatile avec la commande 0xB1, les données requises 0xFFFF, WREN et le temps d'écriture moyen de 0,2 seconde.

 <userTransaction1>\\xB1\xFF\xFF</userTransaction1> <userTransaction1WriteEnable>true</userTransaction1WriteEnable>. <userTransaction1Time>200000</userTransaction1Time>.

3.8 Paramètres du dispositif de mémoire flash SPI

Ce qui suit est un tableau des paramètres qui sont spécifiques aux dispositifs de mémoire flash SPI.

Paramètres	Type	Standard	Description
`Instruction d'effacement`	int		L'instruction qui efface une partie de l'appareil. Si l'appareil dispose de plusieurs tailles d'effacement (pour les appareils avec effacement de secteur et de bloc), il est recommandé de spécifier l'instruction pour la taille d'effacement la plus petite.
`EraseSize`	int		La taille du fichier créé par `eraseInstruction` partie supprimée en octets . Si l'appareil dispose de plusieurs tailles d'effacement (pour les appareils avec effacement de secteur et effacement de bloc), il est recommandé d'indiquer la taille la plus petite. La valeur ne doit pas être nulle.
`EraseTime`	int		`Le nombre de microsecondes nécessaires pour terminer l'instruction eraseInstruction` effacement spécifié . Utiliser la valeur minimale ou typique, car le Flash Center peut interroger l'appareil pour attendre un temps supplémentaire si nécessaire. S'il y a plusieurs vitesses pour la partie mémoire, il est recommandé d'utiliser le temps le plus bas pour ce paramètre. La valeur ne doit pas être nulle.
`hasEraseAll`	bool	`FAUX`	`Si` défini `sur true` , cela signifie que l'appareil supporte la commande d'effacement de puce et `eraseAllInstruction` et `eraseAllTime` il faut définir la fonction.
`EraseAllInstruction`	int		L'instruction d'effectuer un effacement complet de la puce.
`EraseAllTime`	int		Le nombre de microsecondes nécessaires pour effectuer l'effacement de la puce. Utiliser la valeur minimale ou typique, car le Flash Center peut interroger l'appareil pour attendre un temps supplémentaire si nécessaire. S'il existe plusieurs niveaux de vitesse pour la partie mémoire, le temps le plus bas est recommandé pour ce paramètre. La valeur ne doit pas être nulle.
`eraseBeforeWrite`	bool	`VRAI`	Si la valeur est définie `sur` `"false`" , Flash Center n'émet pas de commandes d'effacement avant une commande d'écriture. Ceci est utile pour les appareils tels que la famille Atmel AT45DBxxxx de composants flash SPI, car ils supportent une seule commande qui efface et programme une page de mémoire.

3.9 Paramètres du mode E/S SPI

Ce qui suit est un tableau des paramètres qui sont spécifiques aux dispositifs de stockage flash SPI.

Paramètres	Type	Standard	Description
`ioModeAddress`	int	1	Le mode E/S SPI est utilisé pour transmettre le champ d'adresse de la transaction SPI. Les valeurs possibles sont 0, 2 ou 4.
`ioModeDataIn`	int	1	Le mode E/S SPI est utilisé pour recevoir le champ de données de la transaction SPI et les valeurs possibles sont 0, 2 ou 4.
`ioModeDataOut`	int	1	Le mode E/S SPI utilisé pour transmettre le champ de données de la transaction SPI, et les valeurs possibles sont 0, 2 ou 4.