[PIC et C] : Convertir un BYTE en ... série de bi ts

On Apr 18, 9:26 pm, Laurent CLAUDE

ive

Ce bit est-il destin=E9 =E0 etre transmis physiquement sur une ligne, ou est-ce juste une donn=E9e soft destin=E9e =E0 une fonction ? (parce-que dans ce dernier cas il y a sans doute une autre facon de proc=E9der)

Ensuite, la s=E9rie de bits a quelle longueur ? (meme si elle doit etre transmise en continu, il y a une taille en nombre de bits pour un cycle)

Laurent CLAUDE a tapoté du bout de ses petites papattes :

Tu fais des shifts et tu récupères le bit dans le carry.

--
LeLapin

Le 18/04/2010 23:21, Jean-Christophe a écrit :

Ce bit est destiné a la fonction soft que j'ai mentionné. En ce qui concerne une taille de cycle : je suis totalement libre de faire comme je veux. Il me faut définir la taille en fonction de la 'résolution' qu'elle donnerait a la série, donc je dirais aux alentours des 16bits. Mais a savoir : mon octet de départ peut changer a tout moment pendant la 'transmission' de la série. La série serait alors immédiatement mise à jour par la nouvelle conversion Octet -> Série.

Tu penses a quoi ? L.

Le 19/04/2010 02:16, LeLapin a écrit :

Oui, mais le truc c'est de savoir quoi 'shifter'...

Laurent CLAUDE a écrit :

unsigned char x = valeur à convertir; unsigned char t = 0; // ou autre, par exemple 0x80. Cela ne change // que le point de départ du cycle. unsigned char y = 0xff - x; // ou ~x si le compilateur n'est pas capable // d'optimiser lui même.

for (;;) { if (t >= y) { t -= y; // envoyer un bit 1 } else { t += x; // envoyer un bit 0 } }

Notez que les cycles sont beaucoup plus longs que ce que vous suggérez car si 0xff doit correspondre à 100%, 0x80 (par exemple) correspond à un peu plus de 50% : on n'a pas exactement 0,1,0,1,0,1..., mais tous les

255 ou 256 bits, deux 1 se suivent.

Si une approximation de ces série vous suffit, on peut faire correspondre 0x100 à 100% et alors il suffit en assembleur d'ajouter x continuellement à la valeur de départ t (quelconque) et de récupérer le bit de retenue. En C, on ne gagnerait pas grand chose car récupérer la retenue n'est pas une opération élémentaire. Les cycles obtenus pour les valeurs 0x80 et 0xcc seraient bien ceux que vous suggérez, mais le cycle de 0xff contiendrait un bit 0 pour 256 bits 1.

--
Emmanuel Lesueur

On Apr 19, 8:26 am, Laurent CLAUDE

rs

Ok.

mise

Oui bien sur. Je suis curieux de savoir pourquoi tu as besoin d'un tel format dans ton programme ?

Emmanuel m'a battu de vitesse ... lis son post. Voir ci-dessous la fonction LectureBit();

Pour mettre =E0 jour la valeur de l'octet : LectureBit( nouvelle_valeur );

Pour lire la valeur du bit courant de la s=E9rie : bit =3D LectureBit(-1);

Voici la s=E9quence g=E9n=E9r=E9=E9 (tu peux changer pour 16 bits) 0x00 00000000 0x20 00000001 0x40 00010001 0x60 00100101 0x80 01010101 0xA0 01011011 0xC0 01110111 0xE0 01111111 0xFF 11111111

// Globales /////////////////////////////////////

const unsigned int mask =3D 0xFF; // util unsigned int valeur =3D 0, // la valeur =E0 convertir complement =3D 0, // util compteur =3D 0; // util

// Fonction ///////////////////////////////////// // Entree : // n >=3D 0 : initialise // n < 0 : lecture de la valeur du bit courant unsigned char LectureBit( int n ) { // initialisation de la valeur if( n >=3D 0 ) { valeur =3D (unsigned int)(n); complement =3D mask ^ valeur; compteur =3D 0; return 0; } // valeur du bit courant if( compteur >=3D complement ) { compteur -=3D complement; return 1; } compteur +=3D valeur; return 0; }

"Laurent CLAUDE" a écrit dans le message de news: 4bcb6af8$0$23453$ snipped-for-privacy@news.free.fr...

=========== Il faut etudier sérieusement les instructions de manipulation de bits de ton compilateur De maniere à présenter à la fonction(?) .. ce qu'elle réclame on peut utiliser les pointeurs de chaîne ou les instructions int xxx > n décalage à droite Le masquage "&" les instructions spécifiques : shift_right() shift_left() bit_clear() bit_set bit_test()

On Apr 19, 11:47 am, "maior "

La g=E9n=E9ration de la s=E9rie demand=E9e est une application qui ne d=E9pend certainement pas des instructions du compilo. Il faut d'abord d=E9finir l'algo (qui ne d=E9pend pas du langage) et ce n'est qu'ensuite qu'on l'impl=E9mente via le langage choisi.

Ce ne sont pas des instructions standard du C, mais des impl=E9mentations particuli=E8res =E0 un compilateur donn=E9, que tu aurais du sp=E9cifier.

Pour apprendre un langage, =E9crire shift_right(x) ne permet pas d'apprendre quoi que ce soit sur l'op=E9ration r=E9alis=E9e, par contre =E9crire explicitement x>>=3D1 apprend quelque chose. Sinon autant remplacer x=3Da+b par la fonction x=3Daddition(a,b);

D'ailleurs, l'algo propos=E9 par Emmanuel r=E9alise bien la fonction demand=E9e sans aucune op=E9ration de manipulation de bits.

Le 19/04/2010 10:30, Usenet Free a écrit :

Merci de cette réponse, Je vais avoir besoin de la décortiquer en détails car elle me dépasse un peu.... je n'ai malheureusement pas trop eu le temps de l'étudier aujourd'hui, je vois ça demain en me faisant un décorticage pas à pas !

Oui, je peux faire une approx d'un bit sans pb, je ne suis pas à un 1 de trop.

Merci aussi Jean-Christophe, ton complément va bien m'aider a décortiquer tout ça ! Peux tu stp me décrire ta variable "mask" dans la ligne complement = mask ^ valeur;

Merci et a demain, Laurent

Avoir une resolution de 16 bits en transmettant un byte (8 bits) me parait utopique. En fait , si j'ai bien compris (ou alors merci de me rectifier) tu veux faire du PWM.

--

Alain

Le 19/04/2010 22:30, alain denis a écrit :

je ne sais pas trop comment t'expliquer la situation, mais il ne s'agit pas vraiment d'une résolution (d'ailleurs j'avais mis des guillemets dans mon message), peut être faudrait-il parler de 'précision'...

Pour ce qui est du PWM j'ai aussi regardé de ce côté et il est vrai qu'on s'en rappoche, mais à ce que j'ai compris, le PWM est lié au temps. Ce qui n'est pas mon cas, et je ne vois pas de solution par là.

Laurent CLAUDE a tapoté du bout de ses petites papattes :

J'ai pas dû tout comprendre à ton application. Tu ne peux pas être plus explicite ?

--
LeLapin

Si ce n'est pas class=E9 Secret D=E9fence, pourquoi ne pas d=E9crire l'application. Il y a peut d'=EAtre d'autres solutions que tu n'as pas imagin=E9e...

--

-Stan

On Apr 20, 1:06=A0am, LeLapin

C'est vrai que c'est confusing lorsqu'il parle de s=E9rialiser, parce-que ce n'est pas une simple s=E9rialisation qu'il veut :

--------------------------- valeur | s=E9quence

--------------------------- 0x00 | 00000000 0x20 | 00000001 0x40 | 00010001 0x60 | 00100101 0x80 | 01010101 0xA0 | 01011011 0xC0 | 01110111 0xE0 | 01111111 0xFF | 11111111

---------------------------

Par contre il ne semble pas vouloir dire dans quel but il a besoin de cet =E9trange format de donn=E9es, c'est dommage.

On Apr 20, 5:32=A0pm, Laurent CLAUDE

C'est un =AB int =BB

J'ai rien compris.

Un PWM donc...

On Apr 20, 9:52 pm, OBones

Un PWM ca donnerait ca :

00000000 00000001 00000011 00000111 00001111 00011111 00111111 01111111 11111111

Alors que lui il veut ca :

00000000 00000001 00010001 00100101 01010101 01011011 01110111 01111111 11111111

Bon, sans etre strictement identique, y'aurait comme un cousinage, mais bon.

========== Pour un ordinateur , la valeur est toujours une suite de bits ( 19 decimal = "10011" )

========== La lecture donnera un nombre, si tu veux le transformer en "pourcent" de la course totale du joystick il faudra effectuer un traitement de la valeur (valeur trouvée / course totale*100) = data si (data == 50) data = 0xAA ( binaire :10101010 ) si autre valeur que 0 ou 50 data = ??? ========== Si ton compilateur dispose de la fonction "shift"

fonction d'envoi de chaque bit du registre data vers la fonction de gestion usb "int ecran(void)"

void envoi_fonction_ecran (byte data) { byte i; for(i=1;i0;i--) ecran( (data>>i)&1);

On Apr 21, 9:07 am, "maior=E9"

Le bit z=E9ro n'est pas trait=E9.