Discussion :

[benjaminadv]

Bonjour à tous.

Avant tout, je tiens à dire que je suis un débutant en assembleur (merci de votre compréhension)
Je dois traduire un programme écrit en assembleur pour l'écrire en C.
Jusque là tout va bien mais je suis bloqué à un endroit, je m'explique...

J'ai un "fichier de définition de la zone mémoire RAM" que me sert à déclarer mes variables.

Code :

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

1
2
3
V0_TEMP		EQU	20h	; Donnee temporaire 
V0_toto		EQU	21h	; 
V0_Rtcc_cpt	EQU	22h	; Compteur d'inter RTCC

En gros, sa donne ça.( j'ai pris juste une partie pour vous donner une idée de la structure)

Code :

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

V0_TEMP		EQU	20h	; Donnee temporaire

Je sais que V0_TEMP est le nom de la variable et 20h l’emplacement de cette variable (grossièrement).

J'aimerais savoir comment interpréter ça en C.

J'ai eu pour idée de faire de cette façon:

Code :

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

1
2
3
unsigned short     V0_TEMP=0x20;   //Donnée temporaire
unsigned short     V0_toto=     0x21;  
unsigned short     V0_Rtcc_cpt= 0x22;   //Compteur d'inter RTCC

Qu'en pensez-vous?

Puis dans le programme en assembleur, j'ai des variables sur 1 bit :

Code :

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

1
2
3
4
5
6
7
8
9
Vx_Ent_Etat	EQU	71h	; Etat final des entrees
Vxb_EBP1	EQU	0	; Bouton poussoir 1
Vxb_EBP2	EQU	1	; Bouton poussoir 2
Vxb_EIR1	EQU	2	; Infra rouge 1
Vxb_EIR2	EQU	3	; Infra rouge 2
Vxb_ECAR	EQU	4	; Commande Arret
Vxb_EPVE	EQU	5	; Entree PV
Vxb_EGVE	EQU	6	; Entree GV
Vxb_EFUS	EQU	7	; Entree Fusible

sous cette forme.

Je ne vois pas comment traduire ces lignes en C.

Toute aide est la bienvenue =)

Je m'exprime peut-être mal mais le cœur y est

[Kannagi]

Salut,

Alors pour répondre a ta question :

Code :

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

1
2
3
4
 
unsigned short     V0_TEMP=0x20;   //Donnée temporaire
unsigned short     V0_toto=     0x21;  
unsigned short     V0_Rtcc_cpt= 0x22;   //Compteur d'inter RTCC

Ceci est faux vu que pour le moment ça donnera la valeur a la variable V0_TEMP a 0x20.
Il faut utilisé les pointeurs si tu veux leur donné une adresse donc ça sera plus de cette façon :

Code :

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

1
2
3
4
 
unsigned short     *V0_TEMP=0x20;   //Donnée temporaire
unsigned short    * V0_toto=     0x21;  
unsigned short     *V0_Rtcc_cpt= 0x22;   //Compteur d'inter RTCC

Ensuite je ne pense pas que unsigned short soit le plus indiqué , mais c'est toi qui voit moi j’aurai utilisé un simple int.

Puis dans le programme en assembleur, j'ai des variables sur 1 bit:

J'ai pas vraiment compris la , des variable de 1 bit vraiment ? vu que après tu met des chiffres de plus de 1 bit.
Tu pourrait donné plus de précision a leur utilisation ? au début je me suis dit que ça devait être une variable qu'on actionne avec chaque bit mais la logique voudrait que ça soit avec 0x01 ,0x02,0x04,0x08,0x10 ,0x20,0x40,0x80 et non 1,2,3,4,5,6,7.

[benjaminadv]

Pour l'histoire de "variable sur 1 bits" je me suis mal exprimé.

Code :

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

1
2
3
4
5
6
7
8
9
Vx_Ent_Etat	EQU	71h	; Etat final des entrees
Vxb_EBP1	EQU	0	; Bouton poussoir 1
Vxb_EBP2	EQU	1	; Bouton poussoir 2
Vxb_EIR1	EQU	2	; Infra rouge 1
Vxb_EIR2	EQU	3	; Infra rouge 2
Vxb_ECAR	EQU	4	; Commande Arret
Vxb_EPVE	EQU	5	; Entree PV
Vxb_EGVE	EQU	6	; Entree GV
Vxb_EFUS	EQU	7	; Entree Fusible

ici on peut voir l’octet 71h. Dans cette octets, le bit 0 correspond à l'état du bouton poussoir 1. le bit 1 à l'état du BP2 ...
En gros le bit est égal à 1 BP enfoncé. Si il est égal à 0 il est relaché.
je sais pas comment dire en C que par exemple Vxb_EBP1 correspond au bit tant de l'octet tant...

[Kannagi]

Oui j'ai compris mais tu est sur que tu ne t'es pas trompé ?
Parce que on est d'accord que :

Code :

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

1
2
3
4
5
 
Decimal    Binaire
1              0000 0001
2              0000 0010
3              0000 0011

Du coup pour moi 3 c'est Bouton poussoir 2 et Infra rouge 1 non ?
J'ai compris ce que tu dis mais je comprend pas pourquoi les valeur ne sont pas comme je te l'ai dit auparavant 0x01 ,0x02,0x04,0x08,0x10 ,0x20,0x40,0x80 vu que la chaque bit représente un état (du bouton poussoir ect).
Pour moi ça devrait plus etre ça :

Code :

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

1
2
3
4
5
6
7
8
9
 
Vxb_EBP1	EQU	01h	; Bouton poussoir 1
Vxb_EBP2	EQU	02h	; Bouton poussoir 2
Vxb_EIR1	        EQU	04h	; Infra rouge 1
Vxb_EIR2	        EQU	08h	; Infra rouge 2
Vxb_ECAR	EQU	10h	; Commande Arret
Vxb_EPVE	EQU	20h	; Entree PV
Vxb_EGVE	EQU	40h	; Entree GV
Vxb_EFUS	EQU	80h	; Entree Fusible

La sur un octet on a bien le contrôle de tout tes i/o en bits et donc si on met 3 c'est le bouton poussoir 0 et1 qui sont activé.
Je dis ça parce que en général c'est comme ça que ça marche (surtout sur du bas niveau).

Enfin bref dans tout les cas je te conseille seulement d'utilisé des simples define vu que en C pour les bits en les utilise pour ça :

Code :

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

1
2
3
4
5
 
#define Vx_Ent_Etat 0x71
#define Vxb_EBP1 0
#define Vxb_EBP2 1
//ect

Apres niveau utilisation ça marche comme ça en général :

Code :

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

1
2
3
4
5
 
if(mavariable == Vxb_EBP1 | Vxb_EBP2)
{
 
}

Ce n'est qu'un exemple

[Forthman]

Donc, si j'ai bien compris, tes données se trouvent sur le port 71h, et chaque bit correspond à un bouton tout ou rien.

que ce soit en assembleur ou en C c'est le même problème (je ne peux pas te donner de code, je n'y connais rien en microcontrôleurs et en C )
Tu récupères la valeur du port, et tu la compare avec 2^(numéro bouton)
d'ailleurs, pour avoir un code moins compliqué, si c'était moi je mettrais directement les puissances de 2 dans les "variables boutons"
Comme ça :

Code :

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

1
2
3
4
5
6
7
8
Vxb_EBP1	EQU	1	; Bouton poussoir 1
Vxb_EBP2	EQU	2	; Bouton poussoir 2
Vxb_EIR1	EQU	4	; Infra rouge 1
Vxb_EIR2	EQU	8	; Infra rouge 2
Vxb_ECAR	EQU	16	; Commande Arret
Vxb_EPVE	EQU	32	; Entree PV
Vxb_EGVE	EQU	64	; Entree GV
Vxb_EFUS	EQU	128	; Entree Fusible

Il suffit alors de faire un "ET" entre la valeur du port et la valeur du bouton pour savoir si ce dernier est actionné ou non

[benjaminadv]

c'est sa Kannagi, c'est à peut près se que je cherche.

Code :

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

1
2
3
4
#define Vx_Ent_Etat 0x71
#define Vxb_EBP1 0
#define Vxb_EBP2 1
//ect

Je pense pouvoir faire je que je veut avec sa

Avec ces variables là,

Code :

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

1
2
3
V0_TEMP		EQU	20h	; Donnee temporaire 
V0_toto		EQU	21h	; 
V0_Rtcc_cpt	EQU	22h	; Compteur d'inter RTCC

je peut reprendre le même principe?

Code :

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

1
2
3
#define V0_TEMP 0x20	; Donnee temporaire 
#define V0_toto 0x21	; 
#define V0_Rtcc_cpt 0x22	; Compteur d'inter RTCC

c'est correct?

[Kannagi]

je peut reprendre le même principe?

Oui et non ça dépend d comment tu code derrière ensuite , c'est vrai que EQU c'est l'équivalent du #define mais la différence c'est que en assembleur le EQU ça peut être a peu prés tout et n'importe quoi (variable , adresse mémoire , structure , des define ect).
En C le define a une utilisation plus limité , c'est plus structuré tu peux faire ce que tu as fait mais pour écrire sur une adresse mémoire l'utilisation d'un pointeur reste indispensable.

Donc pour écrire sur l'adresse 20h en gardant ton principe :

Code :

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

1
2
3
4
5
6
7
 
#define V0_TEMP 0x20	; Donnee temporaire 
#define V0_toto 0x21	; 
#define V0_Rtcc_cpt 0x22	; Compteur d'inter RTCC
 
//il faudra alors dans ton code faire cela :
short *mavariable = V0_TEMP;

[benjaminadv]

Merci, tu ma éclairé sur le sujet.
Je vais suivre t'es conseil. Je vais pouvoir m'en dépatouiller

merci du coup de mains bonne continuation =)

[chrtophe]

Je rajouterais qu'en assembleur on écrit effectivement des données sur une adresse mémoire. En C, on écrit un valeur dans une variable, adresse qui est attribuée par le compilateur et non par toi. Mais dans ton cas ou tu dois utiliser des adresses précises de Micro-controleur, Il te faut utiliser un pointeur comme le disait Kannagi. Un pointeur est en fait une variable contenant une adresse mémoire, elle est en général typée (entier, char, etc ...). Exemple quand tu utilises la fonction malloc, celle-ci te retourne l'adresse de la mémoire réservée dans ton pointeur. Le fait d'écrire en C

Code :

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

*pointeur=&0x20;

va affecter l'adresse 0x20 au pointeur.

Code :

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

pointeur=0x20

va affecter la valeur 0x20 la case mémoire de pointeur.
un peu comme la différence entre adr=0x20 et [adr]=0x20.

[Invité]

Je rajouterais qu'en assembleur on écrit effectivement des données sur une adresse mémoire. En C, on écrit un valeur dans une variable, adresse qui est attribuée par le compilateur et non par toi

Pareil qu'en assembleur, ce n'est pas toi qui décides, d'ailleurs c'est personne à part l'OS, quand tu fais un code source, tu définis juste l'offset de l'adresse linéaire, dont la base c'est le début de la source, ensuite le compilo ajoute à l'offset l'offset du début de l'executable..
Ensuite c'est au tour de l'OS et le MMU du cpu de traduire l'offset en adresse absolue dans la RAM, à chaque fois que le CPU doit exécuter un mov à une référence mémoire, bien que cette traduction soit transparente au programmeur.


Et pour le problème d'origine, passer par un pointeur n'est pas nécessaire, une simple variable globale suffit:

Code C :

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
 
#define     V0_TEMP             0x20    // Donnee temporaire 
#define     V0_toto             0x21    // 
#define     V0_Rtcc_cpt         0x22    // Compteur d'inter RTCC
 
#define     Vx_Ent_Etat         0x71    // Etat final des entrees
#define     Vxb_EBP1            0       // Bouton poussoir 1
#define     Vxb_EBP2            1       // Bouton poussoir 2
#define     Vxb_EIR1            2       // Infra rouge 1
#define     Vxb_EIR2            3       // Infra rouge 2
#define     Vxb_ECAR            4       // Commande Arret
#define     Vxb_EPVE            5       // Entree PV
#define     Vxb_EGVE            6       // Entree GV
#define     Vxb_EFUS            7       // Entree Fusible
 
 
unsigned    int     temp = V0_TEMP;     // Je préfère ne travailler qu'avec des int, car c'est le type de data le plus commun et le moins conteux en opération.
                                        // C'est-à-dire que lors d'une opération avec un autre int par exemple (très courant) le compilateur n'aura pas besoin
                                        //  de le convertir en int s'il était en char par exemple (remplissage par 0 de la zone supérieur de char pour le transformé en int).
// ...
 
int     main()
{
 
    return (0);
}

Des variables sur 1 bit n'existent pas, le minimum que l'ont peut mouvoir en mémoire (RAM et registre) est un octet.

[chrtophe]

Je rajouterais qu'en assembleur on écrit effectivement des données sur une adresse mémoire. En C, on écrit un valeur dans une variable, adresse qui est attribuée par le compilateur et non par toi
Pareil qu'en assembleur, ce n'est pas toi qui décides, d'ailleurs c'est personne à part l'OS

J'ai cru comprendre que c'était pour un micro-controleur : donc pas d'OS en jeu. Sinon tu as raison, avec un OS on ne peut accéder qu'à une adresse mémoire qui est dans l'espace d'adressage du processus en cours.

[Invité]

Mais le processeur dans le µc a aussi un MMU non ?

A moins que le mode d'adressage utilisé par le proc soit en mode flat.

[chrtophe]

Mais le processeur dans le µc a aussi un MMU non ?

Non. Et de toute façon sans OS, la MMU tu la programme comme tu veux.

Si je prend l'exemple du x86, Quand tu es en ring0, tu as tous les droits, tu crées ta segmentation (la segmentation est surtout utilisé avec les CPU x86), ta pagination pour la MMU (la MMU est incorporée au CPU dans le cas du x86). Si tu passes en ring3, tu as des droits restreints, tu ne peux pas utiliser les instruction de modification de pagination, segmentation, etc... Le mode ring3 ne peut pas retourner en mode ring0, sauf si tu l'as paramétré en amont par le biais de call gates.

Dans le cas des processeurs ARM par exemple, tu as un mode superviseur et un mode utilisateur. Passer de l'un à l'autre s"effectue apparemment par le déclenchement d'interruption.

Il faut savoir qu'un micro contrôleur est très simpliste, ce n'est pas un CPU.