test RAM

Bonjour, j'ai trouvé un programme embarqué afin de tester une ram externe, précisémment une cypress de 128KO pouvez vous m'expliquer le programme silvouplait

/*********Ecriture à toutes les adresses***********************/
/*********Pour vérification de la RAM**************************/

void test_ram_lecture_ecriture(void)
{
 __far unsigned char *ram_ptr; //pointeur sur la RAM 128 Ko
 unsigned long adr;
 unsigned char i;
 unsigned int val_1;
 unsigned char erreur=0;

/***Ecriture dans la RAM*********************************/
/***à toutes les adresses********************************/

 for(adr=0;adr<0x20000;adr++)        // toute la RAM   0
 {
  ram_ptr= (__far unsigned char *) (DEBUT_EXT_RAM + adr);  
  *ram_ptr=0; 
 }
 
 i=0;
 for(adr=0;adr<0x20000;adr++)
 {
  ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;  /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
  *ram_ptr=i; 
  i++;
 }

/***Relecture des valeurs ecrites***********************/
/********************************************************/

 i=0;

 for(adr=0;adr<0x20000;adr++)
 {
  ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;  /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
  val_1=*ram_ptr;
  if(val_1 != i)
  {
   erreur=1;
   Envoie_chaine_uart1((const char *)"Probleme RAM : Addresse ");
   send_char_hexa_uart1( (char*) (adr>>8) );//adresse poid fort
   send_char_hexa_uart1( (char*) adr );     //adresse poid faible
   Envoie_chaine_uart1((const char *)"\n\r");
   Envoie_chaine_uart1((const char *)"Valeure ecrite : ");
   send_char_hexa_uart1( (char*) &i );  //adresse poid fort
   Envoie_chaine_uart1((const char *)"Valeure lue : ");
   send_char_hexa_uart1( (char*) &val_1 );     //valeur lue poid faible
   Envoie_chaine_uart1((const char *)"\n\r");
  }
  i++;  
 }

  // test pou détecter un CC ou CO sur une piste d'adresse
 for(adr=0;adr<0x20000;adr++)
 {
  ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;   /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
  *ram_ptr=0;             // Toute la RAM à 0
 }

 adr =1;
 i=1;              // seules les adresses avec un seul 1 dans l'adresse sont ré-écrit
 while(adr<0x20000)
 {
  ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;  /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
  *ram_ptr=i; 
  i++;
  adr = (adr<<1);
 }
 
 adr =1;
 i=1;
 while(adr<0x20000)
 {
  ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;  /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
  val_1=*ram_ptr;
  if(val_1 != i)
  {
   erreur=1;
   Envoie_chaine_uart1((const char *)"Probleme RAM : Addresse ");
   send_char_hexa_uart1( (char*) (adr>>8) );//adresse poid fort
   send_char_hexa_uart1( (char*) adr );     //adresse poid faible
   Envoie_chaine_uart1((const char *)"\n\r");
   Envoie_chaine_uart1((const char *)"Valeure ecrite : ");
   send_char_hexa_uart1( (char*) &i );  //adresse poid fort
   Envoie_chaine_uart1((const char *)"Valeure lue : ");
   send_char_hexa_uart1( (char*) &val_1 );     //valeur lue poid faible
   Envoie_chaine_uart1((const char *)"\n\r");
  }
  i++;  
  adr = (adr<<1);
 }
 
 adr = 0;
 ram_ptr=DEBUT_EXT_RAM + (__far unsigned char *)adr;  /*Modif LME ajout du (__far unsigned char *) Ecriture à toutes les adresses*/
 val_1=*ram_ptr;
 if(val_1 != 0)           // on vérifie que l'adresse 0 est toujours à 0
 {
  erreur=1;
  Envoie_chaine_uart1((const char *)"Probleme RAM : Addresse ");
  send_char_hexa_uart1( (char*) (adr>>8) );//adresse poid fort
  send_char_hexa_uart1( (char*) adr );     //adresse poid faible
  Envoie_chaine_uart1((const char *)"\n\r");
  Envoie_chaine_uart1((const char *)"Valeure ecrite : ");
  send_char_hexa_uart1( (char*) &i );  //adresse poid fort
  Envoie_chaine_uart1((const char *)"Valeure lue : ");
  send_char_hexa_uart1( (char*) &val_1 );     //valeur lue poid faible
  Envoie_chaine_uart1((const char *)"\n\r");
 }

 // fin test CC ou CO sur une piste d'adresse

 if(erreur==0)
 {
  Envoie_chaine_uart1((const char *)"RAM OK");
  Envoie_chaine_uart1((const char *)"\n\r");
 } 
}

/********************************************************************/
/************FONCTION DE TEST DE LA RAM******************************/
/********************************************************************/

void Test_RAM(void)
{
 test_ram_lecture_ecriture();

Salut,
C'est pas très compliqué en plus il y a des commentaires.

Ce programme écrit des données dans la RAM et essaye de les relire ensuite pour s'assurer qu'il n'y a pas eu d'erreur.
Toutes les boucles vont de 0 à 0x20000 ( soit 131072 en décimal car 137072 octets = 128Ko).

Dans la 1ère boucle il va initialiser tous les espaces mémoire a zéro.
Dans la 2ère boucle il va ecrire 1,2,3,4,5,.... dans tous les espaces mémoire de la RAM.
Dans la 3ième boucle il va lire chacun des emplacements mémoire pour voir si ce qui a été ecrit vaut bien 1,2,3,4,5,....

Et ainsi de suite, il va écrire différente donnée en se basant sur certains critères.

La constanteDEBUT_EXT_RAM correspond au premier emplacement mémoire lisible. 



Shell

pourquoi (__far unsigned char *)

(__far unsigned char *) permet de caster l'itérateur de boucle "i" en pointeur de type char.
Dans ton exemple on souhaite parcourir chaque zone mémoire de 1 en 1 donc on choisies d'utiliser des char car la taille d'un char vaut 1 octet.
Pour ce qui est de far c'est une vieille convention pascale utilisée sur les systèmes 16bits. 

Shell

Il a donc mélanger du langage C avec du PASCAL?

Non le far est juste une convention pascale dont le language C s'est inspiré.

Shell