Controller une PLL

Bonjour à tous,
Je dispose d’une PLL ADF4153A que j’aimerais programmer en utilisant une communication SPI.
J’ai trouvé sur internet des débuts de piste. J’ai quelques notions en arduino, mais pas plus que ça.

Pour cela je dois réaliser les étapes suivantes :
Étape 1 : Remplir le registre de bruit avec des 0.
Étape 2 : Remplir à nouveau le registre de bruit avec les
paramètres désirés.
Étape 3 : Remplir le registre de contrôle en mettant son
troisième bit (nommé DB2) à 1.
Étape 4 : Remplir le registre R (son dernier bit, DB23, devant
être à 0).
Étape 5 : Remplir le registre N.
Étape 6 : Désactiver le bit DB2 du registre de contrôle en le
plaçant à 0.

Voici le role des différents registre :
Registre N : Permet de régler la valeur du diviseur par N
(cette valeur peut être fractionnelle, le registre disposant d’une
partie dédiée à la partie entière et l’autre à la partie décimale).
Registre R : Permet de remplir le diviseur par R ainsi que le
module utilisé (le module, associé à la valeur décimale du diviseur
par N et la fréquence de comparaison, conditionne l’espacement
entre deux canaux lorsque l’on utilise la PLL au sein d’un oscillateur
local par exemple, et que l’on désire changer de canal utilisateur).
Registre CONTROL : Permet de régler certains paramètres,
tels que le Power-Down mode, ou le courant délivré par la pompe
de charge (en divisant la valeur fixée par la résistance mentionnée
dans le tableau précédent).
Registre NOISE AND SPUR : Permet d’optimiser le bruit en
choisissant de réduire le niveau de la robe de bruit, ou le nombres
de raies parasites présentes en sortie.

J’ai deja commencé un code qui est le suivant:

#include <SPI.h>

const char RegR = 0x0028; //24 BITS
const char RegN = 0x0028; //24 BITS
const char RegC = 0x0028; //24 BITS
const char RegNOISE = 0x0028; //24 BITS

int nb = 3;

int latchPin = 8; //Enb
int clockPin = 13; //Clk
int dataPin = 11; //Data

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  

}

void loop() {
  // put your main code here, to run repeatedly:

}

void sendRegR(unsigned long RegR, unsigned char nb){
  unsigned char tampon;
  unsigned char i=nb;
  do
{
    tampon = (unsigned char)(RegR >> ((i-1)*8));
    shiftOut(dataPin, clockPin, MSBFIRST, tampon);
    i--;
  }
while(i>0);
digitalWrite(latchPin, HIGH);
}

void sendRegN(unsigned long RegN, unsigned char nb){
  unsigned char tampon;
  unsigned char i=nb;
  do
{
    tampon = (unsigned char)(RegN >> ((i-1)*8));
    shiftOut(dataPin, clockPin, MSBFIRST, tampon);
    i--;
  }
while(i>0);
digitalWrite(latchPin, HIGH);
}

void sendRegC(unsigned long RegC, unsigned char nb){
  unsigned char tampon;
  unsigned char i=nb;
  do
{
    tampon = (unsigned char)(RegC >> ((i-1)*8));
    shiftOut(dataPin, clockPin, MSBFIRST, tampon);
    i--;
  }
while(i>0);
digitalWrite(latchPin, HIGH);
}

void sendRegNOISE(unsigned long RegNOISE, unsigned char nb){
  unsigned char tampon;
  unsigned char i=nb;
  do
{
    tampon = (unsigned char)(RegNOISE >> ((i-1)*8));
    shiftOut(dataPin, clockPin, MSBFIRST, tampon);
    i--;
  }
while(i>0);
digitalWrite(latchPin, HIGH);
}

Il y’a un truc que je ne comprend pas, c’est comment je donne les valeurs à mes différents registre ?
Là j’ai juste dis que chaque registre étaient sur 24 bits.

Merci de votre aide et bonne journée.

Aprés je suis également parti sur cette piste

#include <SPI.h>

const int  le=13; 

void setup() {
  Serial.begin(9600);
  RegNoise();
  RegN();
  RegC();
  RegR();
  

}

void loop() {
  // put your main code here, to run repeatedly:

}

int RegNoise(){
  pinMode(le,OUTPUT);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  digitalWrite(le, LOW);
  SPI.transfer (B00000000);
  digitalWrite(le,HIGH);
  delay(100);
}

int RegNoise(){
  pinMode(le,OUTPUT);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  digitalWrite(le, LOW);
  SPI.transfer (B00000000);
  digitalWrite(le,HIGH);
  delay(100);
}

int RegC(){
  pinMode(le,OUTPUT);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  digitalWrite(le, LOW);
  SPI.transfer (B00000100);
  digitalWrite(le,HIGH);
  delay(100);
}

int RegR(){
  pinMode(le,OUTPUT);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  digitalWrite(le, LOW);
  SPI.transfer (B00001000);
  digitalWrite(le,HIGH);
  delay(100);
}
  
int RegN(){
  pinMode(le,OUTPUT);
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  digitalWrite(le, LOW);
  SPI.transfer (0x12C);
  digitalWrite(le,HIGH);
  delay(100);
}

Ai-je un bon début, ou je suis à côté de la plaque ?

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.