Discussion :

[gsxr100045]

Bonjour,
Je connais pas très bien en C (soyez indulgent). J'ai récupéré un fichier en C pour communiquer avec un composant électronique. En compilant j'ai des fichiers manquants (ce qui génère des erreurs, enfin je pense).

Mais en inhibant ces fichiers '.h' j'ai encore plus d'erreurs. A mon avis, la personne qui m'a donné le fichier en '.C' a probablement oublié de me donner aussi le '.h'. Je pensai qu'à partir du .C on peut faire marcher le programme. Avez vous une idée ou une explication d'où viennent mes erreurs pour que je puisse creuser un peu.

Merci par avance de votre aide

[Sve@r]

Bonjour

J'ai récupéré un fichier en C pour communiquer avec un composant électronique. En compilant j'ai des fichiers manquants (ce qui génère des erreurs, enfin je pense).

Pourquoi "tu penses"? Normalement la compilation te dit "il y a telle erreur sur telle ligne". Si c'est un ".h" manquant, il te dit "fatal error: xxx.h aucun fichier ou dossier de ce type" est c'est assez clair pour que tu n'aies aucun doute sur la cause de l'erreur !

Mais en inhibant ces fichiers '.h' j'ai encore plus d'erreurs.

Ca c'est totalement normal.

Je pensai qu'à partir du .C on peut faire marcher le programme.

Un programme qui a été créé sans ".h" oui. Mais s'il nécessite des headers, il ne fonctionnera pas sans.
Ca semble assez complexe mais en réalité c'est assez simple. Un source C travaille avec des fonctions. Or, en C, une fonction doit être déclarée (on doit dire "il existe telle fonction") avant toute utilisation ; puis ensuite on peut la définir (la coder) plus tard. Généralement les deux opérations sont conjointes (en la codant cela la déclare aussi mais uniquement si elle n'a pas été appelée avant)
Exemple

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
// Déclaration (et définition dans la foulée) d'une fonction
double inverse(int n) {
	return 1.0/n;
}
 
// Programme principal
int main() {
	// Appel de la fonction
	printf("Inverse de 123: %f\n", inverse(123));
}

Règle respectée: déclaration (avec définition) puis appel

Autre exemple
Exemple

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
double inverse(int);		// Ca c'est une simple déclaration
 
// Programme principal
int main() {
	// Appel de la fonction
	printf("Inverse de 123: %f\n", inverse(123));
}
 
// Définition de la fonction
double inverse(int n) {
	return 1.0/n;
}

Règle respectée: d'abord déclaration (le compilo la connait), puis appel, puis définition (et là le compilo fait les liens entre "appel" et "instructions de la fonction")

Si on ne respecte pas la règle, alors une fonction non déclarée mais appelée est alors déclarée par défaut par le compilateur, et il la déclare "int" par défaut. Ca peut marcher mais c'est une erreur de compter dessus
Exemple

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
// Programme principal
int main() {
	// Appel de la fonction
	printf("Inverse de 123: %f\n", inverse(123));		// Appel d'une fonction inconnue? Elle sera définie en int
}
 
// Déclaration mais trop tard (fonction mal définie par le compilo)
double inverse(int n) {
	return 1.0/n;
}

Ce code ne compilera pas ; ou alors il compilera mais avec warnings et de toute façon on aura à l'exécution n'importe quoi parce que le compilo aura décidé que la fonction "inverse" est de type "int donc considèrera que tout ce qu'elle renvoie comme du "int" et un codage "int" n'est pas la même chose qu'un codage "float".

Mais le C ce n'est pas seulement "un codeur", ça peut-être une équipe. Donc X écrit la fonctionX, Y écrit la fonctionY et toi tu veux les utiliser => il te faut les déclarer mais sans les définir (elles ont été définies par X et Y). Et quand cela se répète pour 10/100/1000 fonctions tu ne peux plus.
Donc avec les fonctions sont aussi fournis les ".h", ".h" qui contiennent ces déclarations. En incluant le ".h" qui sera lu par le compilo cela t'évite de devoir déclarer toi-même fonctionX et fonctionY.
Mais si tu tentes de les utiliser sans le ".h" qui va avec, tu te retrouves dans le cas qui foire. Ainsi dans tous mes exemples j'ai utilisé la fonction printf() sans l'avoir déclarée, ni inclus le ".h" (très exactement "<stdio.h>") qui contient sa déclaration => chance la fonction printf() étant naturellement "int", les deux premiers exemples fonctionneront quand-même mais avec warnings à la compilation.

Avez vous une idée ou une explication d'où viennent mes erreurs pour que je puisse creuser un peu.

Sans avoir ni le code source (une image ce n'est pas un code, cf les règles) ni au-moins les messages d'erreur...

[gsxr100045]

Bonjour,

Merci pour l'explication, je ne saisi pas tout mais je devine. Dont il faut que je retrouve les '.h' car dans ce .h il doit avoir d'autres choses ce qui fait que je ne peux pas utiliser uniquement .c fournit par le constructeur. Mais juste pour savoir, qu'est ce qu'il y a dans ce .h ? Est ce qu'on peut deviner pour les retrouver sans passer par le constructeur ?

Et d'ailleurs, pourquoi il me fournit uniquement .C sans le .h en sachant que je vais me planter à la compilation ? En tout cas merci pour les explications.

[foetus]

je tiens à compléter avec la notion de "forward declaration" : en français on dit déclaration anticipée ou déclaration avancée.

forward declaration, lien wikipedia en anglais

Mais juste pour savoir, qu'est ce qu'il y a dans ce .h ?

Essentiellement les déclarations des fonctions et des structures/ unions.

et les "include guard" (<- lien wikipedia en français)

Est ce qu'on peut deviner pour les retrouver sans passer par le constructeur ?

Et d'ailleurs, pourquoi il me fournit uniquement .C sans le .h en sachant que je vais me planter à la compilation ?

Ce que ne te dit pas vraiment @Sve@r c'est la notion de bibliothèque.

En gros, s'il te manque par exemple l'entête "quelque_chose.h" (1), il faut comprendre qu'il faut en même temps le fichier source "quelque_chose.c" (2).
Comme on te l'a dit dans l'entête (1) il y a essentiellement les déclarations. Mais il te faut 1 fichier source (2) pour avoir les définitions.

On fait cela parce qu'ainsi celui qui a codé cette bibliothèque peut la livrer en fournissant les entêtes et soit les fichiers source soit les fichiers source "compilés" (fichier .o, .lib, .a, .dll)
Le code source d'1 bibliothèque peut être protégé parce que cela demande du temps/ de l'argent, il y a des brevets, la bibliothèque est vendue, ...
Sinon la bibliothèque est "open source".

Donc "retrouver le code source" cela est [quasi] impossible si tu ne la trouves pas sur Internet : tu ne sais pas la taille du code, il faut recoder toutes les fonctions, ...
Et même si tu la retrouves sur Internet, le C n'a pas de gestion de version : il se peut qu'il ait 1 décalage entre l'entête et le fichier source.
Il faut lire les fichiers pour s'assurer s'il y a ou pas 1 numéro de version quelque part.

[Sve@r]

Je connais pas très bien en C (soyez indulgent). J'ai récupéré un fichier en C pour communiquer...

Et d'ailleurs, pourquoi il me fournit uniquement .C sans le .h en sachant que je vais me planter à la compilation ?

Je ne sais pas qui est ce "il". Tu as commencé en disant "j'ai récupéré un fichier". On ne sait pas comment tu l'as récupéré. Peut-être que celui qui le fournit dit aussi comment récupérer les ".h" mais que t'as raté l'info. Peut-être aussi que tu l'as volé sur son ordi pendant qu'il était aux toilettes...

et les "include guard" (<- lien wikipedia en français)

Ca c'est pour plus tard, quand il voudra faire des ".h"

Ce que ne te dit pas vraiment @Sve@r c'est la notion de bibliothèque.

C'était un peu induit quand j'ai parlé de X qui crée fonctionX et Y qui crée fonctionY. Et pareil, je ne voulais pas non plus alourdir le truc

[gsxr100045]

Je ne sais pas qui est ce "il". Tu as commencé en disant "j'ai récupéré un fichier". On ne sait pas comment tu l'as récupéré. Peut-être que celui qui le fournit dit aussi comment récupérer les ".h" mais que t'as raté l'info. Peut-être aussi que tu l'as volé sur son ordi pendant qu'il était aux toilettes...

Désolé de vous décevoir mais je ne suis pas aussi doué que ça pour voler les infos sur un ordinateur de qqn, d'abord je serai mort de peur ensuite je ferai n'importe quoi ! Blague à part. C'est le fournisseur du composant NXP d'un CODEC qui s'appelle SGTL5000 que j'ai besoin de le configurer dans un mode de fonctionnement bien particulier pour notre carte en électronique via STM32IDE. Je peux vous fournir le lien mais il faut se connecter sur mon compte et c'est un peu compliqué. Je ne sais pas s'il vont me répondre sinon il faut que je me débrouille (Et là c'est chaud CHAUD !!!!).

[gsxr100045]

.... Essentiellement les déclarations des fonctions et des structures/ unions.part.

Merci pour cette info. Pour la déclaration des fonctions on peut éventuellement regarder à quel moment on les utilise dans le '.C' et écrire le prototype de la fonction dans le '.h' (si je ne me trompe pas dans mes réflexions). En revanche, pour les structures et les unions.part là je ne pourrai pas deviner

[gsxr100045]

Bonjour,
J'ai eu la réponse de NXP ils n'ont rien de spécial sinon qq code sous LINUX (ce qui ne me correspond pas, je travaille sous Windows). En revanche ils m'ont envoyé une Application Note, que j'essaie de comprendre voici une partie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
// This prototype writes a value to the entire register. All
// bit-fields of the register will be written. Write REGISTER REGISTERVALUE
// This prototype writes a value only to the bit-field specified.
// In the actual implementation, the other bit-fields should be
// masked to prevent them from being written. Also, the
// actual implementation should left-shift the BITFIELDVALUE
// by appropriate number to match the starting bit location of
// the BITFIELD.
 
Modify REGISTER -> BITFIELD, BITFIELDVALUE //Bitfield Location
 
// Example implementation
// Modify DAP_EN (bit 0) bit to value 1 to enable DAP block
Modify( DAP_CONTROL_REG, 0xFFFE, 1 << DAP_EN_STARTBIT );
// Example Implementation of Modify
 
void Modify(unsigned short usRegister, unsigned short usClearMask, unsigned short usSetValue)
{ unsigned short usData;
  // 1) Read current value
   ReadRegister(usRegister, &usData);
   // 2) Clear out old bits
   usData = usData & usClearMask;
   // 3) set new bit values usData = usData | usSetValue;
    // 4) Write out new value created
   WriteRegister(usRegister,usData);
}

Que je ne comprends pas tout bien évidemment, par exemple la fonction WriteRegister et ReadRegister comment je dois coder ? DAP_CONTROL_REG et DAP_EN_STARTBIT c'est quoi exactement ? C'est un registre associé à ce composant sans doute ? Je suis un peu perdu à vrai dire. Si vous avez qq idées ou des explications je serai bien content.

[foetus]

Que je ne comprends pas tout bien évidemment, par exemple la fonction WriteRegister et ReadRegister comment je dois coder ? DAP_CONTROL_REG et DAP_EN_STARTBIT c'est quoi exactement ? C'est un registre associé à ce composant sans doute ? Je suis un peu perdu à vrai dire. Si vous avez qq idées ou des explications je serai bien content.

C'est pas du code la ligne 11 ne compile pas et il manque l'étape 3 (qui est 1 ou binaire |).

Mais ce "morceau de code" est juste 1 explication de ce que fait la fonction Modify : elle change la valeur d'1 registre avec 1 masque et 1 valeur paramètre.
N'ayant pas le matériel, je comprends sans comprendre

Et 1 des conventions en C, c'est que le nom des macros sont en majuscule (le "code" qu'on définit avec #define).
Notamment, avec les macros on définit les constantes/ nombres magiques. Donc d'après le nom DAP_CONTROL_REG est 1 registre et DAP_EN_STARTBIT 1 valeur.

Édit : on trouve facilement cette note sur internet et le code c'est 1 espèce de tutoriel.

The objective of this document is to familiarize the reader with the code and methodology required to initialize and program the SGTL5000 using C code.
The first section describes the programming prototypes needed to access the SGTL5000's registers.
The next section is a guide to initializing the SGTL5000 out of reset, and configuring various features. Programming examples are provided, intended for the end-user.

[gsxr100045]

C'est pas du code Notamment, avec les macros on définit les constantes/ nombres magiques. Donc d'après le nom DAP_CONTROL_REG est 1 registre et DAP_EN_STARTBIT 1 valeur.

Effectivement, je pense qu'il faut déclarer les registres propres au composant.

Et je pense qu'il faut créer une union en C pour définir tous les bits de ce registre qui commence à l'adresse 0x0100. Bon c'est pas gagné mais je vois un peu près comment il faut s'y prendre.
Par exemple je peux déclarer ce registre dans '.h'
#define DAP_CONTROL 0x0100
Et dans ce même fichier '.h' je déclare les différents champs de ce registre et comme ça je peux accéder aux différents champs de ce registre pour effectuer les modifications.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
union{
	uint16_t data;
	struct{
		uint16_t DAP_EN :1;
		uint16_t RSVD1 :3;
		uint16_t MIX_EN :1;
		uint16_t RSVD0 :11;
	};
}DAP_CONTROL;

Par contre, je ne maitrise pas les 'Unions' je vais compiler et voir ce que cela donne.

[Sve@r]

Par contre, je ne maitrise pas les 'Unions'

Si tu maitrises les 'struct' c'est exactement la même syntaxe. L'opérateur "." (point) permet d'accéder à un champ de l'union, et l'opérateur "->" (flèche, symbolisé par un tiret suivi d'un supérieur) à un champ d'un pointeur sur l'union.
La seule chose qui diffère de la structure, c'est que tous les champs se recouvrent en mémoire donc que tu ne peux travailler que sur l'un à la fois. Ecrire sur un champ écrase tout ce qui se trouve sur les autres.

[foetus]

J'ai travaillé 1 tout petit peu en embarqué, et il y a des unions partout

Avec ton code union, tu vas prendre 16 bits (2 octets) et tu vois ce chunk soit comme 1 tableau XXX.data soit comme 1 structure XXX.str (il manque 1 nom à ta structure)

[gsxr100045]

Si tu maitrises les 'struct' c'est exactement la même syntaxe. L'opérateur "." (point) permet d'accéder à un champ de l'union, et l'opérateur "->" (flèche, symbolisé par un tiret suivi d'un supérieur) à un champ d'un pointeur sur l'union.

Bonsoir,
Je vous remercie pour les infos (par ailleurs, j'en ai un peu trop), il me faut un peu de temps pour assimiler ce que vous dites. J'ai fais une compilation apparemment j'en ai pas aussi autant d'erreurs que ça. Merci