communication entre microcontrolleur et CF avec librairie

Bonjour,

En effet j'ai à ma disposition un circuit imprimé intégrant un microcontrolleur AT89C51SNDC1 et qui dialogue avec une interface CompactFlash (cette carte est donc destinée à stocker les fichiers mp3).

J'ai à ma dispostion la librairie d'Atmel (notamment le fichier snd1c-demo-ide-2_0_3) pour le AT89C51SNDC1 et qui est très complet mais malheureusement il n'y a pas d'exemple de code source avec une fonction main() qui demontre une lecture-ecriture dans une CompactFlash.

Donc le problème est au niveau architecture du software et l'implementation des fonctions cf_read_open(x,x) et cf_read_byte()
car en effet j'essaie de lire un secteur logique (à une addresse offset) de la carte CompactFlash mais je ne parviens pas
je pense qu'il faut d'abord utiliser la fonction cf_read_open(x,x) et puis la cf_read_byte(), dois-je ausi utiliser la fonction cf_read_sector() étant donné que dans mon aplication je ne devrais pas transfere les fichiers mp3 sur le bus usb mais simplement aller lire les fichiers mp3 de la carte CF vers le micro?

Avez vous un exemple de code (ou une architecture d'organigramme descriptif) afin d'aller dans un premier temps lire sur une addresse logique de la CF et puis dans un deuxième temps un code pour lire un fichier mp3 en mode fichier (FAT)?

En fait voila ce code vient d'une librairie et il s'agit d'une librairie qui interroge les registres d'une CompactFlash (même fonctionnement qu'un disque dur IDE/ATA).
Je dispose d'un pcb contenant un microcontrolleur qui va aller lire dans la CF.

Definition selon la librairie:

/* IDE/ATA Definition */
/* With LATCH
A0 A0 P0_0
A1 A1 P0_1
A2 A2 P0_2
CS0# P5_2 P5_2 /Modifier
CS1# P5_3 P5_3 /Modifier

For compact flash
A0 A0 P0_0
A1 A1 P0_1
A2 A2 P0_2
CS0# P5_2 P5_2
CS1# P5_3 P5_3
CS1# CS0# A2 A1 A0
Data 1 0 0 0 0 0x10
Error/features 1 0 0 0 1 0x11
Sector count 1 0 0 1 0 0x12
Sector No 1 0 0 1 1 0x13
Cyl. Low 1 0 1 0 0 0x14
Cyl. High 1 0 1 0 1 0x15
Select Card/Head 1 0 1 1 0 0x16
Status/Command 1 0 1 1 1 0x17
Alt stat/ dev ctrl 0 1 1 1 0 0x0E
Drive address 0 1 1 1 1 0x0F
*/

voici la definition des adrresses des registres de la CF

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 
xdata Byte volatile ide_data                  _at_ IDE_DATA_ADDRESS;      
xdata Byte volatile ide_error                _at_ IDE_ERROR_ADDRESS;        
xdata Byte volatile ide_sector_count   _at_ IDE_SECTOR_COUNT_ADDRESS; 
xdata Byte volatile ide_sector_number  _at_ IDE_SECTOR_NUMBER_ADDRESS; 
xdata Byte volatile ide_cylinder_low     _at_ IDE_CYLINDER_LOW_ADDRESS;  
xdata Byte volatile ide_cylinder_high    _at_ IDE_CYLINDER_HIGH_ADDRESS; 
xdata Byte volatile ide_drive_head       _at_ IDE_DRIVE_HEAD_ADDRESS;    
xdata Byte volatile ide_status             _at_ IDE_STATUS_ADDRESS;        
xdata Byte volatile ide_alt_status        _at_ IDE_ALT_STATUS_ADDRESS;

Et voisi le détail le main et les fonctions de la librairie que j'utilise.

Le main():

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
/////////////////////////////::test
unsigned char testrd[512];  //testali220207
unsigned char tstok[512];     ///testali030307 //testali070307 mettre 512 sinon Warning L2
int rd;                     //testali220207
int rrd;                     //testali220207
//long int tstok=18;            ///testali030307
//long int tstok[];            ///testali030307
//unsigned char tstok[];     ///testali030307
 
unsigned char varilec;  //testali280207
unsigned char variaff;  //testali280207
 
/**********************************************************************************
Function: CF_operations
Remarque: Cette fonction réprend ce qui est utile pour lire et écrire dans le CF
***********************************************************************************/
 
 
 
void CF_operations2 (void)  //testali050307
 
{
 
      if (cf_read_open (0,1))   //testali070307
		{
		printf ("\ncf_read_open is done\n");
     printf ("ide_status avant cf_read_byte() CF_operations: 
                                        %X\n\r",ide_status); //test
        printf ("\n now call to cf_read_byte() and diplay of data\n");
        getchar();
 
 
       printf ("\n valeur de gl_ptr_mem avanr read byte (0): \n",gl_ptr_mem);	
	   getchar();   
     	for(rd=0;rd<512;rd++)
		{
		testrd[rd]=cf_read_byte();          
    		}
		for(rrd = 0; rrd < 512; rrd++)
		{
 
        tstok[rrd]=testrd[rrd];   
 
		printf("%X",tstok[rrd]);  
		}
 
        data_lu = cf_read_byte();            //APPEL
        printf("\nDATA LU = %X\n",data_lu);  //re
        getchar();
		}
		else {printf ("\ncf_read_open is not done\n");}
	   printf("ide_status fin CF_operations: %X\n\r",ide_status); 
 
}

Les fonctions: cf_read_open

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
 
/*F****************************************************************
 
**********
* NAME: cf_read_open
*----------------------------------------------------------------------------
* PARAMS:
*   sect: address of the logic sector to read (size 512 bytes)
*   size : number of sector
*   global: gl_ptr_mem
*
* return:
*   open status:  OK: open done
*                 KO: open not done
*----------------------------------------------------------------------------
* PURPOSE: 
*   Open memory card in read mode (read block)
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   CF card are driven in LBA mode (not in CHS mode)
*   drive/head register     -> LBA 27-24
*   cylinder high register  -> LBA 23-16
*   cylinder low register   -> LBA 15-8
*   sector number register  -> LBA 7-0
*----------------------------------------------------------------------------
* REQUIREMENTS:
******************************************************************
 
*/
 
bit cf_read_open (Uint32 sect, Byte nb_sector)
{
 
 ide_status1 = ide_status;
 
  while (ide_status & IDE_BSY)
  {
    printf ("ide_status est occupé\n");  //testali260207    //testali280207 a ameliorer si 
 
boucle continue
    if ( (Card_detect() == KO) )
    {
      gl_mem_failure = TRUE;
	  lecture_cond = KO;
      return KO;
    }
  }
 
  /* Write device/head register */
  ide_alt_status;
  Ide_set_drive_head(ATA_LBA_MODE + (((Byte*)&sect)[0] & 0x0F));  /* LBA 27-24 
 
*/
 
  BSY = 0;
  while ( Ide_notbsy_drdy() == KO)          /* Wait for BSY = 0  and DRDY = 1 */
  {
 
    if ((Card_detect() == KO) )
    {
      gl_mem_failure = TRUE;
	  lecture_cond = KO;
      return KO;
    }
     printf ("ide_status value = %X\n", ide_status);
     printf ("ide_notsy_bsy \n");  //testali260207       probleme dans cette boucle infinie
     printf ("IDE_STATUS_ADDRESS = %X \n",IDE_STATUS_ADDRESS); 
    if (BSY >=60)                //
	{ //;                              //
   ide_status = IDE_DRDY; //testali260207         //          
 
	}                               //
	BSY++;                          //
  }
  printf ("ide_status dasn cf_read_open() CF_operations avant set: 
 
%X\n\r",ide_status);  ///testali050307 
  while (Ide_notbsy_notdrq() == KO);         /* Wait for BSY = 0  and DRQ = 0 */ //Le 
 
boucle fonctionne en envers
  Ide_set_sector_count ( nb_sector );        /* sending parameters  */
  Ide_set_sector_number(((Byte*)&sect)[3]);  /* LBA 7-0    */
  Ide_set_cylinder_low (((Byte*)&sect)[2]);  /* LBA 15-8   */
  Ide_set_cylinder_high(((Byte*)&sect)[1]);  /* LBA 23-16  */
  Ide_send_command(ATA_CMD_READ_SECTOR);     /* send command */
  gl_ptr_mem = sect;                         /* Initialize the global byte counter */ 
  printf ("ide_status dasn cf_read_open() CF_operations apres set: 
 
%X\n\r",ide_status);   ///testali050307 
 
  while (ide_alt_status & IDE_BSY); //Fonctionnement à l'envers c à d sortie du boucle 
 
lorsque la condition = 0
 
    if (ide_status & IDE_ERR)
  {
 
    lecture_cond = KO;
    return KO;
  }
 
  ide_alt_status;
  ide_status = IDE_DRQ;  //testali260207
%X\n\r",ide_status);  ///testali050307 si pqs cette ligne OK
  if (!(ide_status & IDE_DRQ))
    {
    lecture_cond = KO;
    return KO;
	}
    lecture_cond = OK;
 
  printf("ide_status fin cf_read_open de C_Flash: %X\n\r",ide_status); //testali280207
getchar();
 
  return OK;  
 
}

cf_read_byte ()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
*********
* NAME: cf_read_byte
*---------------------------------------------------------------------------
* PARAMS:
*   global: gl_ptr_mem
*
* return:
*   Data read from memory
*   gl_mem_failure set to TRUE if command failure (card removed)
*----------------------------------------------------------------------------
* PURPOSE: 
*   Card byte read function
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   
*----------------------------------------------------------------------------
* REQUIREMENTS:
******************************************************************
 
**********/
 
#define ide_read_8_databyte()                 ide_data
 
 
Byte cf_read_byte(void)
{
 
  printf("ide_status debut cf_read_byte de C_Flash: %X\n\r",ide_status); 
 
 
 if ((Card_detect() == KO) )
  {
    gl_mem_failure = TRUE;
    return 0xFF;
  }  
 
  while (Ide_notbsy() == KO)                  /* Wait for bsy = 0 */
  {
    printf ("le registre est busy \n");
    if ((Card_detect() == KO) )
    {
      gl_mem_failure = TRUE;
      return 0xFF;
    }  
  }
  ide_status = 0x08;   //test  //test
 
 if (!(ide_status & IDE_DRQ))
  {
    //gl_ptr_mem++;
	printf ("Il incrémente car IDE_DRQ\n"); //testali070307
   // cf_read_open(gl_ptr_mem, 1);              /* open the next sector */
    //\ printf ("Lecture OK\n"); //testali0103
  }
 
  return  ide_read_8_databyte();
 
   printf("ide_status fin cf_read_byte de C_Flash: %X\n\r",ide_status); //test
   getchar();
}
 
 // /*   //test
void cf_read_byte1(void)
{
 if (cf_read_byte() == ide_data)
    {
	 ide_data1 = ide_data;
	 printf("\nide_data = %X\n",ide_data1);
	}
}

Je n'arrive donc pas a avoir les resultats attendus je voudrais voir ce qui se trouve dans le premier secteur de la CF qui est le boot secteur( et qui est semblable pour tous les disques durs) mais je ne parviens à lire qu'un seul et mêm byte pour les 512 affichages de l 'hyperterminal comme vous pouvez le voir:

Resultats capture:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
Il incrémente car IDE_DRQ
ide_status debut cf_read_byte de C_Flash: 5100
 
Il incrémente car IDE_DRQ
ide_status debut cf_read_byte de C_Flash: 5100
 
Il incrémente car IDE_DRQ
ide_status debut cf_read_byte de C_Flash: 5100
 
Il incrémente car IDE_DRQ
 
FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00FA00i
 
Il incrémente car IDE_DRQ
 
DATA LU = FA00
 ide_status fin CF_operations: 5100

Merci d'avance

Ta carte c'est celle-ci?

http://www.atmel.com/dyn/resources/p...ts/doc4206.pdf

Merci,

Je suis Aliveli j'avais pas mon mot de passe j'ai utilisé ce login.

En fait la carte que tu as linkée est celle qui sert de kit de devellopement

mais en fait elle ne comprend pas la libraire pour la CF.

Par contre Atmel a sa propre librairie que tu peux voir sur leur site:
http://www.atmel.com/dyn/products/to...p?tool_id=2924

mais le code que j'ai ecrit au-dessus je me suis inspiré de la librairie propre d'Atmel que je peux te l'envoyer a ton mail si tu veux voir comment c'est ecrit.

Merci

Est-ce que tu disposes d'un oscillo et/ou d'un debugger?
Est-ce que tu as compilé et essayé le soft livré avec avec la carte d'éval?

Bonjour,

je dispose d'un oscillo. pour le debugger j'utilise celui de mon compilateur
uvision2 C51 mais il ne debug pas bien car des qu'il y a un printf ca arrete.

En fait il ne s'agit pas d'une carte d'eval mais une carte fabriquee par nous meme
mais cette carte integre un microconttrolleur qui lui fait partie d'une carte d'eval avec une librairie et donc j'ai adapte cette librairie

Je suis arrive a avoir des bons resultats mais il y a un petit souci encore.
le lien se trouve ici : http://www.developpez.net/forums/sho...d.php?t=293776

Apres quoi je dois integrer la gestion des fichiers (FAT) de la librairie Atmel mais la je crois que ca devrait aller si je resoud ce probleme?

Merci

Il est possible que tu aies une erreur d'alignement de tes données. A priori tes données sont décalées de 8 bits. Essaye de voir si tu n'utilises pas des variables 16 bits quelque part. Elle seraient interprétée ensuite comme des variables 8 bits par un pointeur. Les compilateurs stockent les données 16 bits en LSB first. Du coup, quand on pointe une donnée 16 bits par un pointeur vers une donnée 8 bits, ou inversement, on obtient ce genre de résultat.
Concernant le debugging avec des librairies, oublie, c'est très souvent impossible à mettre en oeuvre. Pour faire un printf, si tu n'a besoin que d'envoyer des chaînes de caractères, fais-toi ta propre fonction, tu maîtriseras en plus les temps d'exécution, ce qui est important quand tu fais du traitement temps réel.

Merci,

le problème est résoud, j'ai du enlever deux lignes

fonction cf_read_byte() fct appellée
Code:

1 2 3 4 5 6 7 8 9 10 // printf ("ide_data avant return read_8_data cf_read_byte de C_Flash: %X\n\r",ide_data); // getchar(); //testali1403 return ide_read_8_databyte();
fonction appellante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 for(rd=0;rd<512;rd++) { printf("valeur de AUXR durant boucle de lecture : %X\n\r",AUXR) ; testrd[rd]=cf_read_byte(); //APPELAPPEL } printf("RESULTAT DE LECTURE addresse sector 0 :\n\r"); for(rrd = 0; rrd < 512; rrd++) { afff=testrd[rrd]; //testali1303Patou //testali1403 dis printf("%X,",afff); //testali1303Patou //testali1403 dis }
Au fait cette phrase, peux tu donner un exemple :
(Pour faire un printf, si tu n'a besoin que d'envoyer des chaînes de caractères, fais-toi ta propre fonction, tu maîtriseras en plus les temps d'exécution, ce qui est important quand tu fais du traitement temps réel.)

Merci