PIC 16F: synthèse d'une liaison série 16bit

[invite2de7076a]

Bonjour,

je cherche à générer une liaison série de 16bits ayant comme caractéristiques:
- deux signaux: CLK et DATA
- bit de start et de stop de 2ms
- tps haut/bas de clk 200µs
- prise en compte de la data sur front montant de clk

pour l'instant je l'ai fait comme ça:

 Cliquez pour afficher

void liaison_serie(unsigned trame_transmise)
{
     char i,tab[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
     
     GIE_bit=0;                 // Déactive les interruptions

     for(i=0;i<16;i++)
     {
         tab[i]= trame_transmise % 2;
         trame_transmise = trame_transmise / 2;
     }

     CLK=0;
     Delay_us(2000);           // Bit de start

     for(i=16;i>0;i--)
     {
         DATA= tab[i-1];
         Delay_us(200);
         CLK=1;
         Delay_us(200);
     }
     
     Delay_us(2000);            // Bit de stop

     GIE_bit=1;                // Réactive les interruptions
}

Je passe un mot de 2 octets à ma fonction. Celle ci calcule les bits qui la compose et génère la trame.

Sauf que cette méthode ne me plait pas!

Comme je ne peux faire de tableau de booléens mon tableau est en char.

Cela prend de la place et je n'aime pas le bidouillage...

Je souhaite donc passer par l'asm pour générer ma trame. Il me faut 2 octets de mémoire et un simple décalage.

Ce serait simple si je travaillai sur un octet.
Deux, je bloque, impossible de faire ce que je veux.

Quelqu'un à t-il une idée? ou une base de départ?

C'est la gestion des deux octets pour former le mot de 16 bits qui me gène.

Merci.
-----

[sdec25]

Bonjour
Sache déjà que même si ça prend plus de place en mémoire, utiliser des mots 8 bits pour stocker des booléens n'est pas plus long à traiter par le processeur.

Tu as plusieurs solutions :
1 : Utiliser des structures avec champs de bits, sur 1, 2 octets ou plus : facile à utiliser pour accéder à un bit en particulier.

2 : Utiliser des types simples (char ou short) et décaler les bits :

unsigned short trame;
unsigned char i;
unsigned short x = trame;
for(i=0; i<16; ++i) {
  envoyer(x & 1); // envoie un bit
  x = x>>1; // on décale de 1 bit vers la droite
}

Ce code n'est pas optimal et peut être amélioré parce que décaler 2 octets prend forcément plus de temps qu'en décaler un seul.
Si tu veux le faire en ASM il faut utiliser les instruction de décalage ou de test sur les bits.

[invite2de7076a]

Ben oui!!!

Je ne sais pas pourquoi je n'ai pas pensé à faire des rotation en C !!!

J'étais partis sur de l'assembleur et gestion des octets...

Je vais essayer!

merci!

[invite2de7076a]

Bon j'ai modifié mon programme, cela donne:

 Cliquez pour afficher

void liaison_serie(unsigned trame_transmise)
{
     GIE_bit=0;                 // Déactive les interruptions

     CLK=0;
     Delay_us(2000);           // Bit de start

     for(i=0; i<16; i++)
     {
         toto = (trame_transmise) && (0x8000);
         DATA = toto;
         trame_transmise = trame_transmise << 1;
         Delay_us(200);
         CLK=1;
         Delay_us(200);
         CLK=0;
     }
     
     CLK=1;
     Delay_us(2000);            // Bit de stop
     GIE_bit=1;                 // Reactive les interruptions
}

Il y à cependant un problème.

La simulation ne fonctionne pas comme je le souhaite.

DATA (ou toto) passe à '1' je ne sais pas trop comment.
Je m'explique:
si par exemple je met trame_transmise= 0x0100
A la première boucle DATA passe à 1.

or (0x0800 && 0x8000) devrait donner 0.

Incompréhensible ce truc...


EDIT: je transmet le MSB d'abord.

[A voir en vidéo sur Futura]

[sdec25]

or (0x0800 && 0x8000) devrait donner 0.

Non, && est le symbole "ET logique" qui renvoie 1 si les 2 opérandes sont différents de 0.
Le ET bit à bit est le symbole &

[invite2de7076a]

Non, && est le symbole "ET logique" qui renvoie 1 si les 2 opérandes sont différents de 0.
Le ET bit à bit est le symbole &

Merci, juste avant ta réponse j'ai été vérifier dans l'aide du compilo et j'ai vu ma bourde... j'ai inversé les deux!

Voici la réponse donc:

 Cliquez pour afficher

void liaison_serie(unsigned trame_transmise)
{
     GIE_bit=0;                 // Déactive les interruptions

     CLK=0;
     Delay_us(2000);           // Bit de start

     for(i=0; i<16; i++)
     {
         DATA = ((trame_transmise) & (0x8000)) && 0x0001;
         trame_transmise = trame_transmise << 1;
         Delay_us(200);
         CLK=1;
         Delay_us(200);
         CLK=0;
     }
     
     CLK=1;
     Delay_us(2000);            // Bit de stop
     GIE_bit=1;                 // Reactive les interruptions
}

Merci...

PS: entre temps j'ai updater MikroC... bourde encore j'ai effacer le programme de licence: me voila une semaine minimum à faire un prog de moins de 2k...
On paye un compilo pour être tranquille mais c'est pas toujours le cas!!


Merci à toi en tout cas...

EDIT: une demi aprem pour 10 lignes de code...