3 votes

Comment pourrais-je écrire à la mémoire ?

J'essaie d'écrire un test simple pour la RAM afin de vérifier l'intégrité de base de la mémoire à bord d'un dispositif embarqué. Voici ce que je veux être capable de faire :

Essentiellement, écrivez certains modèles : "10101010101010" dans un bloc de mémoire puis écrire "01010101010" puis réécrire le premier et tester pour voir si le motif a été écrit correctement.

J'essaie d'écrire ce programme en C. Je me demandais comment je pourrais écrire ce modèle. Je veux pouvoir activer et désactiver certains bits dans les cellules de mémoire RAM.

Est-ce que je pourrais simplement allouer un bloc de mémoire et ensuite écrire quelque chose comme

uint32 pattern = 0xaaaaaaaa;
uint32 * mem_loc = malloc some memory;
int i = 0;
int offset = 1; 
uint32 * location = &mem_loc;

while ((&mem_loc)++ && (!i))  {
   &mem_loc = pattern;
   if (!(&(mem_loc+offet))) { 
      mem_loc = location;
      pattern = 0x55555555;
      i++;
   }
}

//Check to see if values written are consistent

Le code ci-dessus fonctionnerait-il ? L'écriture des motifs hexagonaux en mémoire activera-t-elle les bits du motif ?

Je sais que le code ci-dessus est horriblement tronqué mais je veux juste avoir une idée si faire quelque chose comme ça avec la bonne logique permettra d'obtenir le résultat souhaité.

Merci

3voto

dwelch Points 27195

Vous avez un problème de poule et d'œuf. Pour faire tourner suffisamment de code pour faire des mallocs ou même utiliser du code C, vous avez déjà une mémoire de travail.

Vous devez définir votre problème. Par exemple, s'agit-il d'une vérification de conception ou d'un test de production ? Testez-vous la puce mémoire elle-même ou la carte ? Normalement, vous achetez des puces (mémoire) qui fonctionnent ou qui ont été testées, ou des puces qui ont une qualité définie par le vendeur. Et vos tests sont souvent des tests de production, les points de soudure de fabrication. Les lignes de données, les lignes d'adresse, les lignes de contrôle.

Le problème de l'oeuf et de la poule est que vous voulez faire tourner un logiciel sur le processeur embarqué, ce qui nécessite un code qui s'exécute quelque part, et cela implique de la mémoire (qui pourrait simplement être de la flash et n'en avoir besoin d'aucune ou d'un minimum). La situation idéale est de fonctionner complètement sans rom, en utilisant uniquement les ressources du processeur ou uniquement les ressources de la puce interne et sans ram externe, de sorte que la ram externe puisse être complètement testée. Chaque ligne d'adresse, etc. Sinon, vous devez trouver un système ou déclarer que des morceaux de mémoire ne seront pas testés.

Ou bien une approche en plusieurs étapes, le code de démarrage de la rom peut faire une vérification rapide d'une petite partie de la ram sans l'utiliser pour fonctionner. Ensuite, copier le programme de test principal dans cette petite partie de la mémoire vive et l'exécuter. Puis faire les tests de la mémoire principale avec plus de flexibilité de code. Vous pouvez utiliser le C au lieu de l'assembleur par exemple. Vous pourriez par exemple faire un pré-test, un test super simple, 25% de la mémoire vive, puis copier le test là, tester les 75% restants, puis déplacer le programme vers un autre 25% de la mémoire vive et faire le test lourd sur les premiers 25% qui n'ont pas eu de test complet.

Types de test, vous devez comprendre les défaillances, vous pouvez vouloir tester les joints de soudure en particulier et les traces sur les cartes de circuits imprimés. Vous pouvez avoir des connexions ouvertes et donc faire en sorte que chaque broche ait un un et un zéro, vous pouvez aussi avoir des courts-circuits, que le un et le zéro couvrent, et vous pouvez avoir des "bits amis" où des broches voisines peuvent avoir un court-circuit entre elles et donc vous voulez que chaque paire de signaux soit différente de l'autre.

Souvent, les gens font des tests comme tous les uns, tous les zéros, les 5, les As. Puis des tests en damier où un emplacement de mémoire contient disons des 5 et le suivant des As. Pour les tests de lignes d'adresses, vous devez utiliser des valeurs non puissantes de deux, ou mieux encore, chaque emplacement de mémoire a une valeur différente, par exemple des mots de 32 bits ayant chacun leur propre adresse.

Si vous utilisez un pseudo-aléatoire, quelque chose de répétable comme un lfsr, un passage pour remplir toute la mémoire en utilisant l'aléatoire, réensemencez, revenez en arrière et vérifiez. puis recommencez et remplissez avec des valeurs inversées, réensemencez et vérifiez les valeurs inversées. Vous obtenez les bits d'adresse, chaque ligne de données, mais tous les voisins ne sont pas vérifiés. Réensemencer et recommencer tout cela en déplaçant le motif aléatoire peut couvrir cela. Parfois, il suffit d'utiliser le test aléatoire comme test d'adresse et les traditionnels uns zéros cinq As, 3s, Cs, 6s, 9s, etc.

Pour ce qui est de votre pointeur vers la mémoire à tester, vous ne pouvez pas vous contenter de faire un malloc, vous devez connaître l'adresse physique et vous occuper de la traduction, le cas échéant, de sorte que si/quand il y a un problème, vous communiquez avec des adresses physiques. Vous devez également connaître et contrôler la part de la mémoire. Normalement, j'écrirai des tests basés sur le processeur en C, mais je n'utiliserai aucun appel à la bibliothèque C (comme malloc, printf ou autre).

2voto

AShelly Points 17389

En écho à la réponse de @Martin : vous ne voulez pas utiliser les appels de la bibliothèque standard pour fournir la mémoire à tester.

Votre chaîne d'outils embarqués devrait être capable de produire une carte mémoire de votre application. Vous devez identifier les segments de mémoire que vous voulez tester, et extraire leur adresse de départ du fichier de carte.

La boucle de test pourrait ressembler à quelque chose comme :

 const int* AddressToTest = MEM_SEGMENT;
 const int* SegLength     = SEGMENT_LENGTH;
 volatile int* mem;
 for (mem = AddressToTest; mem < AddressToTest + SegLength; mem++)
 {
    *mem = PATTERN;
    if (*mem != PATTERN) {report("Read-Write Failure at %x",mem);}
 }
 //-or- you could separate the write and verify into 2 separate loops.

Le gros problème ici est que vous ne pouvez pas tester le segment à partir duquel vous vous exécutez, vous devez donc planifier soigneusement. Les outils intégrés devraient avoir une sorte de fichier d'options de linker (et/ou de compilateur #pragmas) qui contrôle quel code utilise quelle mémoire. Vous devrez donc configurer votre code de test pour qu'il s'exécute dans un endroit différent de la mémoire testée.

0voto

Martin Beckett Points 60406

Voulez-vous utiliser new ?
Si vous essayez de tester des zones spécifiques de la mémoire du système embarqué, ne voudriez-vous pas définir cette adresse directement plutôt que de vous fier à n'importe quel système de gestion de la mémoire ? new vous donne ?

Si cela incorporé Si votre système est vraiment un linux, un Windows embarqué ou un autre système d'exploitation complexe, alors il est probablement plus complexe. Vous pouvez avoir des espaces d'adresse mémoire pour différents processus, des caches, une allocation optimisée à prendre en compte.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X