Discussion :

[keys13]

Je souhaite copier la valeur 0xFF à l'adresse 0xC000 et la valeur 0x00 à l'adresse 0xC001

Le programme ci-dessous est t'il correct ?

Code :

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

1
2
3
4
5
6
unsigned int addr=0xC000; // 0-65535 valeur type d'adresse mémoire sur mon système
unsigned char * byte_spi; // 0 - 255 valeur
byte_spi=&addr;
*byte_spi=0xFF;
byte_spi++; 
*byte_spi=0x00;

Ok ou pas OK ?

[ram-0000]

En plus simple, je dirai:

Code :

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

1
2
3
4
5
 
   unsigned char * byte_spi = (unsigned char *)0xC000;
   *byte_spi=0xFF;
   byte_spi++; 
   *byte_spi=0x00;

[keys13]

Ok merci, si je compile le code ci-dessous sur PC, je m'aperçois
que mes valeurs ont été copiées à l'adresse 12ff33 & 12ff34 pas c000 et c001 comme je voulais ????

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
 
 
int main ()
{
	unsigned int addr=0xC000; // 0-65535 valeur type d'adresse mémoire sur mon système
	unsigned char * byte_spi; // 0 - 255 valeur
 
	byte_spi=&addr;
 
	*byte_spi=0xFF;
 
	printf("valeur trouvee en 0xC000 :%x\n",*byte_spi);
 
	byte_spi++;
 
	*byte_spi=0x00;
 
	printf("valeur trouvee en 0xC001 :%x\n",*byte_spi);
 
	printf("valeur adresse memoire du pointeur :%x\n",&byte_spi);
	printf("valeur adresse memoire du pointeur voulue 0xC000\n");
 
}

Résultat de l'execution :

Microsoft Windows [version 6.0.6001]
Copyright (c) 2006 Microsoft Corporation. Tous droits réservés.

C:\lcc\projects\test\lcc>test
valeur trouvee en 0xC000 :ff
valeur trouvee en 0xC001 :0
valeur adresse memoire du pointeur :12ff34
valeur adresse memoire du pointeur voulue 0xC000

C:\lcc\projects\test\lcc>

[jeroman]

je m'aperçois que mes valeurs ont été copiées à l'adresse 12ff33 & 12ff34

&byte_spi te donne l'adresse du pointeur, pas l'adresse sur laquelle il pointe.
byte_spi te donne l'adresse vers laquelle pointe le pointeur.
*byte_spi pointe sur l'objet en question.

EDIT:

De plus, je crois que tu t'emmêles les pinceaux.

Dans ton code, addr n'est pas un pointeur, mais une variable de type unsigned int ayant pour valeur 0xc000.

byte_spi=&addr; -> byte_spi contient l'adresse de la variable addr.

*byte_spi=0xFF; -> Ca modifie la valeur de la variable addr en modifiant un octet (valeur 0xFF).
byte_spi++;*byte_spi=0x00; -> Pareil, mais modifie l'octet suivant de la variable (valeur 0x00)
printf("valeur trouvee en 0xC000 :%x\n",*byte_spi); -> Ceci t'affiche la valeur du premier octet composant la variable addr et non pas l'octet à l'adresse 0xC000.
Idem pour le printf qui suit, un octet après.
printf("valeur adresse memoire du pointeur :%x\n",&byte_spi); -> Adresse du pointeur byte_spi et non pas adresse pointée (c-à-d pas : addr).

[keys13]

Que dois je modifier dans le code pour que cela soit ce que je veux ????

[jeroman]

Que dois je modifier dans le code pour que cela soit ce que je veux ????

Ben, déjà, explique ce que tu veux réellement faire.

On ne peut pas écrire à la volée "comme ça" dans une adresse mémoire, sauf à l'intérieur du segment dans lequel tourne ton exécutable. (Après, ça dépasse un peu mes connaissances en la matière)

Alors pourquoi écrire à l'adresse 0xc000 ? Tu veux faire quoi exactement ?

[ram-0000]

Ok merci, si je compile le code ci-dessous sur PC, je m'aperçois
que mes valeurs ont été copiées à l'adresse 12ff33 & 12ff34 pas c000 et c001 comme je voulais ????

Si tu ne prends pas en compte ce que l'on te dit dans le post précédent et que tu continues à faire comme avant, ne t'étonne pas d'avoir le même résultat

[Médinoc]

Une minute: Tu manipules des addresses absolues sous Windows ?

Où te crois-tu ? Sur un système embarqué?

[ram-0000]

Une minute: Tu manipules des addresses absolues sous Windows ?

Où te crois-tu ? Sur un système embarqué?

Son OS n'est peut être pas Windows (DOS ?) quoique j'ai un doute en voyant le prompt

Microsoft Windows [version 6.0.6001]
Copyright (c) 2006 Microsoft Corporation. Tous droits réservés.
...

Est ce qu'il est possible dans une boite DOS de Windows d'aller directement "taper" dans la mémoire (comme au temps où c'était possible sous DOS pur) sans "memory violation". Je pense par exemple à l'accès directe à la mémoire video (je sais, c'est pas propre, mais bon...)

[Médinoc]

S'il utilise un Windows Vista 32 bits, la NTVDM (Virtual DOS Machine) qui permet de faire tourner des programmes DOS et Windows 16 bits existe encore. Il est donc en effet possible qu'il s'agisse d'un programme pour DOS, exécuté depuis le prompt de Vista...

[keys13]

Mon programme tourne sur un système embarqué je peux aller lire/écrire directement en mémoire, j'avais juste fait un essai sous dos
depuis vista 32 car je n'avais pas à disposition mon système embarqué...

Ce que je souhaite faire, je précise :

copier la valeur 0xFF à l'adresse 0xC000 et la valeur 0x00 à l'adresse 0xC001

sur un système embarqué !

Voici donc le code modifié ci-dessous avec vos commentaires, OK ?

J'ai un petit doute à vous lire car pour moi un unsigned char va de 0 à 255, or mon adresse peut s'exprimer de 0 à 65535, ici 0xC000 n'est pas un unsigned char ???

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
 
 
#include <stdio.h>
 
int main ()
{
	unsigned char * byte_spi = (unsigned char *) 0xC000;
 
	*byte_spi=0xFF;
 
	printf("valeur trouvee en 0xC000 :%x\n",*byte_spi);
 
	printf("valeur adresse memoire du pointeur :%x\n",&byte_spi);
 
	byte_spi++;
 
	*byte_spi=0x00;
 
    printf("valeur trouvee en 0xC001 :%x\n",*byte_spi);
 
	printf("valeur adresse memoire du pointeur :%x\n",&byte_spi);
 
}

[gl]

J'ai un petit doute à vous lire car pour moi un unsigned char va de 0 à 255

Il s'agit effectivement du minimum garantit.
La plage peut être plus grande sur certaines architectures. Mais cela n'a pas vraiment d'importance ici.

or mon adresse peut s'exprimer de 0 à 65535, ici 0xC000 n'est pas un unsigned char ???

Oui et alors quel est le problème ? Ton adresse n'est pas contenu dans un unsigned char mais dans un pointeur sur unsigned char.

[3DArchi]

On a l'impression que tu t'emmêles encore les pinceaux entre pointeurs et variables:

Code :

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

unsigned char uc;

0<=uc<=0xFF=255
0<=&uc<=0xFFFF = 65535 (16 bits) ou 0xFFFFFFFF=4294967295 (32bits). Bien sûr pour un pointeur, toutes les plages ne sont pas autorisées.
Si on reprend ton problème (commentaire dedans):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned int addr=0xC000; // 0-65535 valeur type d'adresse mémoire sur mon système
/* Si je ne m'abuse, ce sont des commentaires C++ et non C*/
unsigned char * byte_spi; // 0 - 255 valeur
/* 0<=*byte_spi<=255 mais 0<=byte_spi<=0xFFFF(FFFF)*/

byte_spi=&addr;
/* byte_spi pointe sur l'adresse de addr. Toi, tu veux que byte_spi pointe sur la valeur de addr: 
byte_spi =(unsigned char*)(addr);*/

*byte_spi=0xFF;
byte_spi++; 
*byte_spi=0x00;

[keys13]

Merci pour vos réponses !

Si à la suite du code suivant, je veux maintenant écrire 0xAA à l'adresse
0xD000 en utilisant les mêmes pointeurs comment faire ???

byte_spi=OxD000; donne une erreur "incompatible pointer types"

Sorry je débute ...

Code :

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

1
2
3
4
5
 
unsigned char * byte_spi = (unsigned char *)0xC000;
*byte_spi=0xFF;
byte_spi++; 
*byte_spi=0x00;

[crocodilex]

Tu as fait un cast pour l'adresse 0xC000.
Pourquoi ne fais-tu pas la même chose pour l'adresse 0xD000 ?

Code :

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

byte_spi = (unsigned char *)0xD000;

[keys13]

Ah Oui ç'est ok merci !