Aide Communication Série MSB du LSB

[invite19d0a581]

Bonjour à tous,

Je réalises actuellement un petit bout de code pour contrôler en SPI un synthétiseur de fréquence via un PIC16f.

Je dois envoyer 40bits :
- 8 bits pour le caractère 'G'.
- 32 bits pour la fréquence avec le LSB envoyé en premier (le PIC transmet le MSB en premier).

Sachant que le registre SSPBUF est constitué d'un octet, il me faut envoyer le caractère 'D', puis les 8 derniers bits...

Pouvez vous m'aider à corriger ma fonction qui doit avoir des problèmes de type de données et valider la fonctionnalité :

void Creer_Freq (unsigned long Freq_MHz)
{
    unsigned long N_Div = Freq_MHz / (1/2);       
    unsigned char Set_Freq = 'G';
    
    SPI1_Write(Set_Freq);
    
    unsigned long n = 0x000F;
    unsigned char Little_End[4];
    for (int i=0;i<4;i++)
    {
        Little_End[i] = N_Div & n;
        SPI_Write(Little_End[i]);
        n = n << 8;
    }
}

Merci d'avance.
-----

[invite19d0a581]

Quelqu'un pour me donner son avis ?

[Jack]

Sachant que le registre SSPBUF est constitué d'un octet, il me faut envoyer le caractère 'D', puis les 8 derniers bits...

Pas très clair tout çà. Pourquoi le caractère 'D'. Que représentent ces 8 derniers bits? Il n'y a pas moyen d'avoir des infos sur le contenu des trames?

[invite19d0a581]

Le synthétiseur de fréquence doit être programmé de la manière suivante :
- dans mon cas (le caractère G et non D), doit être envoyé au synthétiseur pour lui signifier qu'on va lui envoyer le rapport de division N (N = Freq/Pas). -> 8bits
- Puis les informations du rapport de division. -> 32bits

Ex : N=1500 (dec) donne 5DC (hex)
Pour une transmission sur 32 bits en Little Endian, on aura : DC 05 00 00
Il nous faudra donc envoyer le caractère G (47 en hex)+ rapport de division = 47 DC 05 00 00
La fonction que j'écris doit donc envoyer chaque octet comme défini ci-dessus.

[A voir en vidéo sur Futura]

[Jack]

Ok, c'est plus clair.
Quelques remarques sur la fonction:
unsigned long N_Div = Freq_MHz / (1/2);
tu prends des risques car il s'agit d'entiers et 1/2 va être égal à 0 du coup. Pourquoi ne pas multiplier par 2 au lieu de diviser par 1/2?

unsigned char Set_Freq = 'G';
SPI1_Write(Set_Freq);
Autant écrire SPI1_Write('G');

unsigned char Little_End[4];
Pourquoi utiliser un tableau? Ca serait plus simple ainsi:

    for (int i=0;i<4;i++)
    {
        SPI_Write(N_Div % 256);  // LSB de N_Div
        N_Div = N_Div / 256; // ou bien N_Div = N_Div >> 8;
    }

[invite19d0a581]

Effectivement, ce n'est pas très logique (je vais mettre des commentaires, pour expliquer pourquoi *2 ...).
Par contre je ne comprend pas pourquoi réaliser une comparaison bit à bit avec la valeur décimale 256. Est ce que le code ci-dessous peut convenir :

void Creer_Freq (unsigned long Freq_MHz)
{
    unsigned long N_Div = Freq_MHz * 2;       
        
    SPI1_Write('G');
    
    unsigned long n = 0x000F;
    for (int i=0;i<4;i++)
    {
        SPI_Write(N_Div % n);
        n = n << 8;
    }
}

[Jack]

Par contre je ne comprend pas pourquoi réaliser une comparaison bit à bit avec la valeur décimale 256

Quelle comparaison bit à bit? Le reste de la division par 256 va donner l'octet de poids faible recherché.

n = n << 8;

Non, car si tu ne vas bien garder que les 8 bits qui t'intéressent, il ne seront pas à la bonne place (0x00001200 est différent de 0x00000012 par exemple)