bachi / libad9915

Download as
Browse Code »

Commit e41d5220b5a139824483e540c0dbaf6473260c43

Authored by bachi
1 parent 6ebbf4da4d
Exists in master

ad9915.c : nettoyage des commentaires et du superflu(initialisation a 0 etc

Showing 1 changed file with 23 additions and 266 deletions Inline Diff

/* 1 1 /*
SPI : initialisation du dds et communication SPI 2 2 SPI : initialisation du dds et communication SPI
*/ 3 3 */
#include"ad9915.h" 4 4 #include"ad9915.h"
#include "spi.h" 5 5 #include "spi.h"
#include "ddsFreq.h" 6 6 #include "ddsFreq.h"
7 7
#define debug 8 8 #define debug
//fonction reset 9 9 //fonction reset
void sendReset(int f_dds) 10 10 void sendReset(int f_dds)
{ 11 11 {
char reset='2'; 12 12 write(f_dds,"2",1);
write(f_dds,&reset,sizeof(reset)); //reset 13
sleep(0.1); 14
} 15 13 }
16 14
//fonction ioupdate 17 15 //fonction ioupdate
void sendIOUpdate(int f_dds) 18 16 void sendIOUpdate(int f_dds)
{ 19 17 {
char update='1'; 20 18 write(f_dds,"1",1);
write(f_dds,&update,sizeof(update)); //reset 21
sleep(0.1); 22
} 23 19 }
24 20
//fonction write register 25 21 //fonction write register
void writeRegister (int fd, unsigned char addr, unsigned char d3, unsigned char d2, unsigned char d1, unsigned char d0) 26 22 void writeRegister (int fd, unsigned char addr, unsigned char d3, unsigned char d2, unsigned char d1, unsigned char d0)
{ 27 23 {
unsigned char tx[5]={0}; 28 24 unsigned char tx[5]={0};
tx[0]=addr; 29 25 tx[0]=addr;
tx[1]=d3; 30 26 tx[1]=d3;
tx[2]=d2; 31 27 tx[2]=d2;
tx[3]=d1; 32 28 tx[3]=d1;
tx[4]=d0; 33 29 tx[4]=d0;
//spi_put_multiple envoie le vecteur dans cet ordre 34 30 //spi_put_multiple envoie le vecteur dans cet ordre
//[tx0]-[tx1]-[tx2] -> adresse->bit poids Fort->bit poids faible 35 31 //[tx0]-[tx1]-[tx2] -> adresse->bit poids Fort->bit poids faible
spi_put_multiple(fd,tx,5,NULL,0); 36 32 spi_put_multiple(fd,tx,5,NULL,0);
} 37 33 }
38 34
//fonction read register 39 35 //fonction read register
40 36
void readRegister (int fd,unsigned char addr, uint32_t *readword) 41 37 void readRegister (int fd,unsigned char addr, uint32_t *readword)
{ 42 38 {
unsigned char tx[1] = {0}; 43 39 unsigned char tx[1] = {0};
unsigned char rx[4] = {0}; 44 40 unsigned char rx[4] = {0};
addr = addr|0x80;//instruction byte for the read : 1000 0000 | byte_adress 45 41 addr = addr|0x80;//instruction byte for the read : 1000 0000 | byte_adress
tx[0]=addr; 46 42 tx[0]=addr;
spi_put_multiple(fd,tx,1,rx,4); 47 43 spi_put_multiple(fd,tx,1,rx,4);
//printf("TX:%x RX:%x %x %x %x\n",tx[0],rx[0],rx[1],rx[2],rx[3]); 48 44 //printf("TX:%x RX:%x %x %x %x\n",tx[0],rx[0],rx[1],rx[2],rx[3]);
*readword = 0x00000000; 49 45 *readword = 0x00000000;
*readword = *readword|(rx[0]<<24); 50 46 *readword = *readword|(rx[0]<<24);
*readword = *readword|(rx[1]<<16); 51 47 *readword = *readword|(rx[1]<<16);
*readword = *readword|(rx[2]<<8); 52 48 *readword = *readword|(rx[2]<<8);
*readword = *readword|rx[3]; 53 49 *readword = *readword|rx[3];
} 54 50 }
55 51
//fonction read register 56 52 //fonction read register
void readRegisterIni (int fd, unsigned char addr) 57 53 void readRegisterIni (int fd, unsigned char addr)
{ 58 54 {
unsigned char tx[1] = {0}; 59 55 unsigned char tx[1] = {0};
unsigned char rx[4] = {0}; 60 56 unsigned char rx[4] = {0};
addr = addr|0x80; 61 57 addr = addr|0x80;
tx[0]=addr; 62 58 tx[0]=addr;
spi_put_multiple(fd,tx,1,rx,4); 63 59 spi_put_multiple(fd,tx,1,rx,4);
printf("TX:%x RX:%x %x %x %x\n",tx[0],rx[0],rx[1],rx[2],rx[3]); 64 60 printf("TX:%x RX:%x %x %x %x\n",tx[0],rx[0],rx[1],rx[2],rx[3]);
// sendIOUpdate (f_dds); //Send the update to set the control registers 65 61 // sendIOUpdate (f_dds); //Send the update to set the control registers
} 66 62 }
67 63
//initialisation du dds 68 64 //initialisation du dds
void initializeDDS (int fd, int f_dds) 69 65 void initializeDDS (int fd, int f_dds)
{ 70 66 {
sendReset(f_dds); 71 67 sendReset(f_dds);
writeRegister(fd,CFRAddress[0],CFR1Start[0], CFR1Start[1], CFR1Start[2], CFR1Start[3]); 72 68 writeRegister(fd,CFRAddress[0],CFR1Start[0], CFR1Start[1], CFR1Start[2], CFR1Start[3]);
sendIOUpdate (f_dds); //Send the update to set the control registers 73 69 sendIOUpdate (f_dds); //Send the update to set the control registers
writeRegister(fd,CFRAddress[1], CFR2Start[0], CFR2Start[1], CFR2Start[2], CFR2Start[3]); 74 70 writeRegister(fd,CFRAddress[1], CFR2Start[0], CFR2Start[1], CFR2Start[2], CFR2Start[3]);
sendIOUpdate (f_dds); 75 71 sendIOUpdate (f_dds);
writeRegister(fd,CFRAddress[2], CFR3Start[0], CFR3Start[1], CFR3Start[2], CFR3Start[3]); 76 72 writeRegister(fd,CFRAddress[2], CFR3Start[0], CFR3Start[1], CFR3Start[2], CFR3Start[3]);
sendIOUpdate (f_dds); 77 73 sendIOUpdate (f_dds);
writeRegister(fd,CFRAddress[3], CFR4Start[0], CFR4Start[1], CFR4Start[2], CFR4Start[3]); 78 74 writeRegister(fd,CFRAddress[3], CFR4Start[0], CFR4Start[1], CFR4Start[2], CFR4Start[3]);
sendIOUpdate (f_dds); 79 75 sendIOUpdate (f_dds);
writeRegister(fd,USR0Address, 0xA2, 0x00, 0x08, 0x00); 80 76 writeRegister(fd,USR0Address, 0xA2, 0x00, 0x08, 0x00);
sendIOUpdate (f_dds); 81 77 sendIOUpdate (f_dds);
} 82 78 }
83 79
//calibration du dac 84 80 //calibration du dac
void calibrateDAC (int fd, int f_dds) 85 81 void calibrateDAC (int fd, int f_dds)
{ 86 82 {
writeRegister(fd,CFRAddress[3], DACCalEnable[0], DACCalEnable[1], DACCalEnable[2], DACCalEnable[3]); 87 83 writeRegister(fd,CFRAddress[3], DACCalEnable[0], DACCalEnable[1], DACCalEnable[2], DACCalEnable[3]);
sendIOUpdate (f_dds); 88 84 sendIOUpdate (f_dds);
writeRegister(fd,CFRAddress[3], CFR4Start[0], CFR4Start[1], CFR4Start[2], CFR4Start[3]); 89 85 writeRegister(fd,CFRAddress[3], CFR4Start[0], CFR4Start[1], CFR4Start[2], CFR4Start[3]);
sendIOUpdate (f_dds); 90 86 sendIOUpdate (f_dds);
} 91 87 }
92 88
void modulusSetup(int fd, int f_dds) 93 89 void modulusSetup(int fd, int f_dds)
{ 94 90 {
writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x0a); //OSK enable //0x08 95 91 writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x0a); //OSK enable //0x08
//writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x08); //OSK enable de base 96
sendIOUpdate (f_dds); 97 92 sendIOUpdate (f_dds);
writeRegister(fd,0x01,0x00, 0x89, 0x09, 0x00); //enable program modulus and digital ramp 98 93 writeRegister(fd,0x01,0x00, 0x89, 0x09, 0x00); //enable program modulus and digital ramp
sendIOUpdate (f_dds); 99 94 sendIOUpdate (f_dds);
} 100 95 }
101 96
void basicSetup(int fd, int f_dds,uint16_t ampWord, uint16_t phaseWord) 102 97 void basicSetup(int fd, int f_dds,uint16_t ampWord, uint16_t phaseWord)
{ 103 98 {
writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x08); //OSK enable 104 99 writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x08); //OSK enable
sendIOUpdate (f_dds); 105 100 sendIOUpdate (f_dds);
writeRegister(fd,0x01,0x00, 0x89, 0x09, 0x00); //enable program modulus and digital ramp 106 101 writeRegister(fd,0x01,0x00, 0x89, 0x09, 0x00); //enable program modulus and digital ramp
sendIOUpdate (f_dds); 107 102 sendIOUpdate (f_dds);
writeRegister(fd,0x04,0x19, 0x99, 0x99, 0x99); //ftw 108 103 writeRegister(fd,0x04,0x19, 0x99, 0x99, 0x99); //ftw
sendIOUpdate (f_dds); 109 104 sendIOUpdate (f_dds);
writeRegister(fd,0x05,0xC0, 0x00, 0x00, 0x00); //A 110 105 writeRegister(fd,0x05,0xC0, 0x00, 0x00, 0x00); //A
sendIOUpdate (f_dds); 111 106 sendIOUpdate (f_dds);
writeRegister(fd,0x06,0x00, 0x00, 0x00, 0x05); //B 112 107 writeRegister(fd,0x06,0x00, 0x00, 0x00, 0x05); //B
sendIOUpdate (f_dds); 113 108 sendIOUpdate (f_dds);
//writeRegister(fd,0x0c, 0x0F, 0xFF, 0x00, 0x00); // amp (12b) ph(16) 114 109 writeRegister(fd,0x0c, (uint8_t)((ampWord>>8) & 0x0F), (uint8_t)(ampWord & 0xFF), (uint8_t)((phaseWord>>8) & 0xFF), (uint8_t)(phaseWord & 0xFF)); // amp (12b) ph(16)
writeRegister(fd,0x0c, (uint8_t)((ampWord>>8) & 0x0F), (uint8_t)(ampWord & 0xFF), (uint8_t)((phaseWord>>8) & 0xFF), (uint8_t)(phaseWord & 0xFF)); // amp (12b) ph(16) 115
sendIOUpdate (f_dds); 116 110 sendIOUpdate (f_dds);
} 117 111 }
118 112
void setFreqMM(int fd, int f_dds, unsigned int ftw, unsigned int A, unsigned int B) 119 113 void setFreqMM(int fd, int f_dds, unsigned int ftw, unsigned int A, unsigned int B)
{ 120 114 {
//uint16_t phaseWord = 0x7400; 121
//uint16_t ampWord = (uint16_t)strtol(argv[4],NULL,0) & 0x0FFF ; //masque en 2 122
//uint16_t ampWord = 0x00000FFF; 123
//uint32_t phaseAmpWord = phaseWord | ampWord<<16; 124
125
//writeRegister(fd,0x00,0x00, 0x01, 0x01, 0x08); //OSK enable 126
//sendIOUpdate(f_dds); 127
//writeRegister(fd,0x01,0x00, 0x89, 0x09, 0x00); //enable program modulus and digital ramp 128
//sendIOUpdate(f_dds); 129
writeRegister(fd,0x04,ftw>>24&0xFF, ftw>>16&0xFF, ftw>>8&0xFF, ftw&0xFF); //ftw 130 115 writeRegister(fd,0x04,ftw>>24&0xFF, ftw>>16&0xFF, ftw>>8&0xFF, ftw&0xFF); //ftw
sendIOUpdate(f_dds); 131 116 sendIOUpdate(f_dds);
writeRegister(fd,0x05,A>>24&0xFF,A>>16&0xFF, A>>8&0xFF, A&0xFF); //A 132 117 writeRegister(fd,0x05,A>>24&0xFF,A>>16&0xFF, A>>8&0xFF, A&0xFF); //A
sendIOUpdate(f_dds); 133 118 sendIOUpdate(f_dds);
writeRegister(fd,0x06,B>>24&0xFF,B>>16&0xFF, B>>8&0xFF, B&0xFF); //B 134 119 writeRegister(fd,0x06,B>>24&0xFF,B>>16&0xFF, B>>8&0xFF, B&0xFF); //B
sendIOUpdate(f_dds); 135 120 sendIOUpdate(f_dds);
// writeRegister(fd,0x0c, phaseAmpWord>>24&0xFF, phaseAmpWord>>16&0xFF,phaseAmpWord>>8&0xFF,phaseAmpWord&0xFF); // amp (12b) ph(16) 136
//sendIOUpdate(f_dds); 137
} 138 121 }
139 122
void setAmpPhaseWord(int fd, int f_dds,unsigned int phaseAmpWord) 140 123 void setAmpPhaseWord(int fd, int f_dds,unsigned int phaseAmpWord)
{ 141 124 {
writeRegister(fd,0x0c, phaseAmpWord>>24&0xFF, phaseAmpWord>>16&0xFF,phaseAmpWord>>8&0xFF,phaseAmpWord&0xFF); // amp (12b) ph(16) 142 125 writeRegister(fd,0x0c, phaseAmpWord>>24&0xFF, phaseAmpWord>>16&0xFF,phaseAmpWord>>8&0xFF,phaseAmpWord&0xFF); // amp (12b) ph(16)
sendIOUpdate(f_dds); 143 126 sendIOUpdate(f_dds);
} 144 127 }
145 128
/* 146
void getAmpPhaseWord(int fd) 147
{ 148
// unsigned char rx[5]={0}; 149
unsigned char* pt; 150
readRegister(fd,0x0c,rx); // amp (12b) ph(16) 151
rx[0]=*pt; 152
rx[1]=*(pt+1); 153
rx[2]=*(pt+2); 154
rx[3]=*(pt+3); 155
rx[4]=*(pt+4); 156
printf("%c %c %c %c %c", rx[0], rx[1], rx[2], rx[3], rx[4]); 157
} 158
*/ 159
void checkSize(void) 160 129 void checkSize(void)
{ 161 130 {
printf("int : %d\n",sizeof(unsigned int)); 162 131 printf("int : %d\n",sizeof(unsigned int));
} 163 132 }
164 133
int openAndSetDdsFreq( char * device, char * gpio_update, double f_clk, double f_out, uint16_t ampWord, uint16_t phaseWord) 165 134 int openAndSetDdsFreq( char * device, char * gpio_update, double f_clk, double f_out, uint16_t ampWord, uint16_t phaseWord)
{ 166 135 {
#ifdef debug 167 136 #ifdef debug
printf("device=%s\tgpio_update=%s\tf_clk=%e\tf_out=%e\tampWord=%d\tphaseWord=%d\n\n",device,gpio_update,f_clk,f_out,ampWord,phaseWord); 168 137 printf("device=%s\tgpio_update=%s\tf_clk=%e\tf_out=%e\tampWord=%d\tphaseWord=%d\n\n",device,gpio_update,f_clk,f_out,ampWord,phaseWord);
#else 169 138 #else
printf("device=%s\tgpio_update=%s\tf_clk=%e\tf_out=%e\tampWord=%d\tphaseWord=%d\n\n",device,gpio_update,f_clk,f_out,ampWord,phaseWord); 170 139 printf("device=%s\tgpio_update=%s\tf_clk=%e\tf_out=%e\tampWord=%d\tphaseWord=%d\n\n",device,gpio_update,f_clk,f_out,ampWord,phaseWord);
int fd=configureSpi(device); //ex #define FILENAME2 "/dev/spidev0.0" 171 140 int fd=configureSpi(device); //ex #define FILENAME2 "/dev/spidev0.0"
printf("fd(funct)=%d\n",fd); 172 141 printf("fd(funct)=%d\n",fd);
setMode(fd,SPI_MODE_0); 173 142 setMode(fd,SPI_MODE_0);
if (fd <= 0){ 174 143 if (fd <= 0){
printf("ERREUR : ouverture périphérique SPI %s\n",device); 175 144 printf("ERREUR : ouverture périphérique SPI %s\n",device);
return EXIT_FAILURE; 176 145 return EXIT_FAILURE;
} 177 146 }
int f_dds=open(gpio_update,O_RDWR); //ex #define UPDATE2 "/sys/dds/gpio24/updateOn" 178 147 int f_dds=open(gpio_update,O_RDWR); //ex #define UPDATE2 "/sys/dds/gpio24/updateOn"
printf("f_dds(funct)=%d\n",f_dds); 179 148 printf("f_dds(funct)=%d\n",f_dds);
if (f_dds <= 0){ 180 149 if (f_dds <= 0){
printf("ERREUR : ouverture ");printf(gpio_update);printf("\n"); 181 150 printf("ERREUR : ouverture ");printf(gpio_update);printf("\n");
printf("Chargez le module ddsIOupdateX\n"); 182 151 printf("Chargez le module ddsIOupdateX\n");
return EXIT_FAILURE; 183 152 return EXIT_FAILURE;
} 184 153 }
setddsFreq(fd,f_dds,f_out,f_clk); 185 154 setddsFreq(fd,f_dds,f_out,f_clk);
//debug 186 155 //debug
phaseWord = 0x0000; 187 156 phaseWord = 0x0000;
ampWord=0x0FFF; 188 157 ampWord=0x0FFF;
uint32_t phaseAmpWord = phaseWord | ampWord<<16; 189 158 uint32_t phaseAmpWord = phaseWord | ampWord<<16;
setAmpPhaseWord(fd, f_dds, phaseAmpWord); 190 159 setAmpPhaseWord(fd, f_dds, phaseAmpWord);
#endif 191 160 #endif
return EXIT_SUCCESS; 192 161 return EXIT_SUCCESS;
} 193 162 }
194 163
int setDdsFreqFull ( int fd, int f_dds, double f_clk, double f_out, uint16_t ampWord, uint16_t phaseWord) 195 164 int setDdsFreqFull ( int fd, int f_dds, double f_clk, double f_out, uint16_t ampWord, uint16_t phaseWord)
{ 196 165 {
setddsFreq(fd,f_dds,f_out,f_clk); 197 166 setddsFreq(fd,f_dds,f_out,f_clk);
#ifdef debug 198 167 #ifdef debug
phaseWord = 0x0000; 199 168 phaseWord = 0x0000;
ampWord=0x0FFF; 200 169 ampWord=0x0FFF;
#endif 201 170 #endif
uint32_t phaseAmpWord = phaseWord | ampWord<<16; 202 171 uint32_t phaseAmpWord = phaseWord | ampWord<<16;
setAmpPhaseWord(fd, f_dds, phaseAmpWord); 203 172 setAmpPhaseWord(fd, f_dds, phaseAmpWord);
204 173
return EXIT_SUCCESS; 205 174 return EXIT_SUCCESS;
} 206 175 }
207 176
void sendCtrlUp(int fp) 208 177 void sendCtrlUp(int fp)
{ 209 178 {
char DRCTLOn='0';//pente positive 210 179 //pente positive
write(fp,&DRCTLOn,sizeof(DRCTLOn)); // 211 180 write(fp,"0",1);
sleep(0.1); 212
} 213 181 }
214 182
void sendCtrlDown(int fp) 215 183 void sendCtrlDown(int fp)
{ 216 184 {
char DRCTLOn='2';//pente negative 217 185 //pente negative
write(fp,&DRCTLOn,sizeof(DRCTLOn)); //reset 218 186 write(fp,"2",1);
sleep(0.1); 219
} 220 187 }
221 188
void sendHold(int fp) 222 189 void sendHold(int fp)
{ 223 190 {
char DRHOLDOn ='1';//rampe bloquée 224 191 //rampe bloquee
write(fp,&DRHOLDOn,sizeof(DRHOLDOn)); //reset 225 192 write(fp,"1",1);
sleep(0.1); 226
} 227 193 }
228 194
void sendUnhold(int fp) 229 195 void sendUnhold(int fp)
{ 230 196 {
char DRHOLDOn ='3';//rampe debloquée 231 197 //rampe debloquee
write(fp,&DRHOLDOn,sizeof(DRHOLDOn)); //reset 232 198 write(fp,"3",1); //reset
sleep(0.1); 233
} 234 199 }
235 200
236 201
int testRampFreq(int fd, int f_dds, int fp) 237 202 int testRampFreq(int fd, int f_dds, int fp)
{ 238 203 {
239 204
240 205
//3-Rampe de pente positive + debloquage 241 206 //3-Rampe de pente positive + debloquage
sendCtrlDown(fp);//rampe up 242 207 sendCtrlDown(fp);//rampe up
sendUnhold(fp); 243 208 sendUnhold(fp);
244 209
sendReset(f_dds); 245 210 sendReset(f_dds);
//Initialize_DDS (fd, f_dds); 246 211 //Initialize_DDS (fd, f_dds);
247 212
//0- paramètre de bases 248 213 //0- paramètre de bases
writeRegister(fd,0x00,0x00,0x01,0x01,0x0a);//OSKenable+Read&write 249 214 writeRegister(fd,0x00,0x00,0x01,0x01,0x0a);//OSKenable+Read&write
sendIOUpdate(f_dds); 250 215 sendIOUpdate(f_dds);
readRegisterIni(fd,0x00); 251 216 readRegisterIni(fd,0x00);
252 217
writeRegister(fd,0x01,0x00, 0x00, 0x09, 0x00); // enable amp ramp 253 218 writeRegister(fd,0x01,0x00, 0x00, 0x09, 0x00); // enable amp ramp
sendIOUpdate(f_dds); 254 219 sendIOUpdate(f_dds);
readRegisterIni(fd,0x00); 255 220 readRegisterIni(fd,0x00);
256 221
//1- Donner une frequence f_dds de 1.1e7 Hz sachant que f_clk=1e9 Hz; 257
// => Le mot a donner est (p.19) : FTW=(f_dds/f_clk)*2³² 258
// FTW = 42949672.96 = 42 949 673. = 0x028f5c29 259
// 1.1e7 =0x02d0e560 260
261 222
// 2d0e560 262
263
//Calibrate_DAC (fd,f_dds); 264
265
266
267
writeRegister(fd,0x0b,0x02,0xd0,0xe5,0x60);//mot de frequence 268 223 writeRegister(fd,0x0b,0x02,0xd0,0xe5,0x60);//mot de frequence
sendIOUpdate(f_dds); 269 224 sendIOUpdate(f_dds);
writeRegister(fd,0x0c,0x0F,0xFF,0x00,0x00); //mot de amp et de phase : amp max, phase nulle 270 225 writeRegister(fd,0x0c,0x0F,0xFF,0x00,0x00); //mot de amp et de phase : amp max, phase nulle
sendIOUpdate(f_dds); 271 226 sendIOUpdate(f_dds);
272 227
printf("Les mots de frequences, d'amplitudes et de phases sont envoyes\n"); 273 228 printf("Les mots de frequences, d'amplitudes et de phases sont envoyes\n");
printf("Lecture registre de frequence: 0x0b\n"); 274 229 printf("Lecture registre de frequence: 0x0b\n");
readRegisterIni(fd,0x0b); 275 230 readRegisterIni(fd,0x0b);
printf("Lecture registre de amp et phase: 0x0c\n"); 276 231 printf("Lecture registre de amp et phase: 0x0c\n");
readRegisterIni(fd,0x0c); 277 232 readRegisterIni(fd,0x0c);
278 233
Calibrate_DAC (fd,f_dds); 279 234 calibrateDAC (fd,f_dds);
printf("\n\n ----------------------- \n\n"); 280 235 printf("\n\n ----------------------- \n\n");
281 236
282 237
/* 283
//2- Taille des dt 284
285
writeRegister(fd,0x08,0xFF,0xFF,0xFF,0xFF); //+dt max, -dt max (+dt = -dt) 286
sendIOUpdate(f_dds); 287
288
printf("Les mots de dt sont envoyes\n"); 289
printf("Lecture dans le registre 0x08 : taille dt\n"); 290
readRegisterIni (fd,0x08); 291
292
293
294
295
printf("\n\n ----------------------- \n\n"); 296
297
298
//3- STEP SIZE :dphi 299
300
// en theorie dphi =2.25e-28 degrees 301
writeRegister(fd,0x06,0x00,0x00,0x00,0x01); 302
sendIOUpdate(f_dds); 303
304
writeRegister(fd,0x07,0x00,0x00,0x00,0x01); 305
sendIOUpdate(f_dds); 306
307
//printf("\n\n ----------------------- \n\n"); 308
printf("Les mots de dphi sont envoyes\n"); 309
printf("Lecture dans les registres 0x06 et 0x07 : taille dt\n"); 310
readRegisterIni (fd,0x06); 311
readRegisterIni (fd,0x07); 312
313
printf("\n\n ----------------------- \n\n"); 314
//4- Ecrire les extremums de la rampe 315
316
writeRegister(fd,0x04,0x00,0x00,0x00,0x01);//0 rad 317
sendIOUpdate(f_dds); 318
writeRegister(fd,0x05,0xFF,0xFF,0xFF,0xFF);//2*pi rad 319
sendIOUpdate(f_dds); 320
321
printf("Les mots des frontieres sont envoyes\n"); 322
printf("Lecture dans les registres 0x04 et 0x05 : taille dt\n"); 323
readRegisterIni (fd,0x04); 324
readRegisterIni (fd,0x05); 325
326
327
//3-Rampe de pente positive ou négative 328
// Send_CTRL_UP(fp);//rampe up 329
330
331
//4-ecriture dans le registre 0x01 332
writeRegister(fd,0x01,0x00, 0xa8, 0x09, 0x00); // enable amp ramp 333
sendIOUpdate(f_dds); 334
335
printf("Lecture dans le registre 0x01 : \n"); 336
readRegisterIni (fd,0x01); 337
// printf("Les mots de dt sont envoyes\n"); 338
printf("Lecture dans le registre 0x08 : taille dt\n"); 339
readRegisterIni (fd,0x08); 340
341
342
*/ 343
return EXIT_SUCCESS; 344 238 return EXIT_SUCCESS;
} 345 239 }
346 240
//---------------rajout 8/1 347 241 //---------------rajout 8/1
348 242
int putAmpWord(int fd, int f_dds, double amplitude) 349 243 int putAmpWord(int fd, int f_dds, double amplitude)
{ 350 244 {
uint16_t PhaseWord = 0x0000; 351 245 uint16_t PhaseWord = 0x0000;
uint16_t AmpWord = 0x0000; 352 246 uint16_t AmpWord = 0x0000;
uint32_t ReadPhaseAmpWord=0x00000000; 353 247 uint32_t ReadPhaseAmpWord=0x00000000;
354 248
AmpWord = rint(amplitude*(pow(2.0,12.0)-1)/100); 355 249 AmpWord = rint(amplitude*(pow(2.0,12.0)-1)/100);
356 250
readRegister(fd,0x0c,&ReadPhaseAmpWord); 357 251 readRegister(fd,0x0c,&ReadPhaseAmpWord);
358 252
PhaseWord = ReadPhaseAmpWord&0xFFFF; 359 253 PhaseWord = ReadPhaseAmpWord&0xFFFF;
360 254
writeRegister(fd,0x0c,AmpWord>>8&0xFF,AmpWord&0xFF,PhaseWord>>8&0xFF,PhaseWord&0xFF); 361 255 writeRegister(fd,0x0c,AmpWord>>8&0xFF,AmpWord&0xFF,PhaseWord>>8&0xFF,PhaseWord&0xFF);
sendIOUpdate(f_dds); 362 256 sendIOUpdate(f_dds);
363 257
return 0; 364 258 return 0;
} 365 259 }
366 260
367 261
int putPhaseWord(int fd, int f_dds, double phase) 368 262 int putPhaseWord(int fd, int f_dds, double phase)
{ 369 263 {
uint16_t PhaseWord = 0x0000; 370 264 //uint16_t PhaseWord = 0x0000;
uint16_t AmpWord = 0x0000; 371 265 //uint16_t AmpWord = 0x0000;
uint32_t ReadPhaseAmpWord=0x00000000; 372 266 uint32_t ReadPhaseAmpWord=0x00000000;
373 267
PhaseWord = rint(phase*(pow(2.0,16.0)-1)/360); 374 268 uint16_t PhaseWord = rint(phase*(pow(2.0,16.0)-1)/360);
375 269
readRegister(fd,0x0c,&ReadPhaseAmpWord); 376 270 readRegister(fd,0x0c,&ReadPhaseAmpWord);
377 271
AmpWord = ReadPhaseAmpWord>>16&0xFFFF; 378 272 uint16_t AmpWord = ReadPhaseAmpWord>>16&0xFFFF;
379 273
writeRegister(fd,0x0c,AmpWord>>8&0xFF,AmpWord&0xFF,PhaseWord>>8&0xFF,PhaseWord&0xFF); 380 274 writeRegister(fd,0x0c,AmpWord>>8&0xFF,AmpWord&0xFF,PhaseWord>>8&0xFF,PhaseWord&0xFF);
sendIOUpdate(f_dds); 381 275 sendIOUpdate(f_dds);
382 276
return 0; 383 277 return 0;
} 384 278 }
385 279
int putFrequencyWord(int fd, int f_dds, double fclk,double fout)//Attention uniquement valable pour fclk = 1 GHz 386 280 int putFrequencyWord(int fd, int f_dds, double fclk,double fout)//Attention uniquement valable pour fclk = 1 GHz
{ 387 281 {
388 282
uint32_t FTWR = 0x00000000; 389 283 //uint32_t FTWR = 0x00000000;
FTWR = rint((fout/fclk)*pow(2.0,32.0)); 390 284 uint32_t FTWR = rint((fout/fclk)*pow(2.0,32.0));
writeRegister(fd,0x0b,FTWR>>24&0xFF,FTWR>>16&0xFF,FTWR>>8&0xFF,FTWR&0xFF);//mot de frequence 391 285 writeRegister(fd,0x0b,FTWR>>24&0xFF,FTWR>>16&0xFF,FTWR>>8&0xFF,FTWR&0xFF);//mot de frequence
sendIOUpdate(f_dds); 392 286 sendIOUpdate(f_dds);
393 287
return 0; 394 288 return 0;
} 395 289 }
396 290
397 291
int putFrequencyAmpPhaseWord(int fd, int f_dds, double fout, double fclk,double amp, double phase)//n'existe pas dans le mode profile enable 398 292 int putFrequencyAmpPhaseWord(int fd, int f_dds, double fout, double fclk,double amp, double phase)//n'existe pas dans le mode profile enable
{ 399 293 {
400 294
uint32_t FTWR = 0x00000000; 401 295 //uint32_t FTWR = 0x00000000;
402 296
FTWR = rint((fout/fclk)*pow(2.0,32.0)); 403 297 uint32_t FTWR = rint((fout/fclk)*pow(2.0,32.0));
404 298
writeRegister(fd,0x0b,FTWR>>24&0xFF,FTWR>>16&0xFF,FTWR>>8&0xFF,FTWR&0xFF);//mot de frequence 405 299 writeRegister(fd,0x0b,FTWR>>24&0xFF,FTWR>>16&0xFF,FTWR>>8&0xFF,FTWR&0xFF);//mot de frequence
406 300
sendIOUpdate(f_dds); 407 301 sendIOUpdate(f_dds);
408 302
// writeRegister(fd,0x0c,0x0F,0xFF,0x00,0x00); //mot de amp et de phase : amp max, phase nulle 409
// sendIOUpdate(f_dds); 410
411
putPhaseWord(fd,f_dds,phase); 412 303 putPhaseWord(fd,f_dds,phase);
putAmpWord(fd,f_dds,amp); 413 304 putAmpWord(fd,f_dds,amp);
414 305
return 0; 415 306 return 0;
} 416 307 }
417 308
418 309
int initialisationProfileMode (int fd,int f_dds) 419 310 int initialisationProfileMode (int fd,int f_dds)
{ 420 311 {
421 312
sendReset(f_dds); //les registres sont maintenant par defaut 422 313 sendReset(f_dds); //les registres sont maintenant par defaut
writeRegister(fd,0x00,0x00,0x01,0x01,0x0a); //OSK+SDIO input only//ok 423 314 writeRegister(fd,0x00,0x00,0x01,0x01,0x0a); //OSK+SDIO input only//ok
sendIOUpdate(f_dds); 424 315 sendIOUpdate(f_dds);
writeRegister(fd,0x01,0x00,0x80,0x09,0x00); // profile mode enable very important 425 316 writeRegister(fd,0x01,0x00,0x80,0x09,0x00); // profile mode enable very important
sendIOUpdate(f_dds); 426 317 sendIOUpdate(f_dds);
writeRegister(fd,0x02,0x00,0x00,0x19,0x1c); // default 427 318 writeRegister(fd,0x02,0x00,0x00,0x19,0x1c); // default
sendIOUpdate(f_dds); 428 319 sendIOUpdate(f_dds);
writeRegister(fd,0x03,0x01,0x05,0x21,0x20); // calibration 1/2 :enable 429 320 writeRegister(fd,0x03,0x01,0x05,0x21,0x20); // calibration 1/2 :enable
sendIOUpdate(f_dds); 430 321 sendIOUpdate(f_dds);
writeRegister(fd,0x03,0x00,0x05,0x21,0x20); // calibration 2/2 :desenable 431 322 writeRegister(fd,0x03,0x00,0x05,0x21,0x20); // calibration 2/2 :desenable
sendIOUpdate(f_dds); 432 323 sendIOUpdate(f_dds);
433 324
return 0; 434 325 return 0;
} 435 326 }
436 327
437 328
438 329
//------------------- FIN RAJOUT 8/1 439 330 //------------------- FIN RAJOUT 8/1
440 331
441 332
//-------------------------FONCTIONS RAMPES HARDWARE 442 333 //-------------------------FONCTIONS RAMPES HARDWARE
443 334
//1-rampe de frequence 444 335 //1-rampe de frequence
445 336
//rampe simple de fréquence 446 337 //rampe simple de fréquence
int frequencySweep (int fd, int f_dds,double fclk,double dfUp, double dfDown, double FreqMax,double FreqMin, double DeltaTimeUp, double DeltaTimeDown) 447 338 int frequencySweep (int fd, int f_dds,double fclk,double dfUp, double dfDown, double FreqMax,double FreqMin, double DeltaTimeUp, double DeltaTimeDown)
{ 448 339 {
//calcul de N => N=DeltaF/df = DeltaT/dt 449 340 //calcul de N => N=DeltaF/df = DeltaT/dt
450 341
//1-fmax > fmin 451 342 //1-fmax > fmin
double DeltaFreq = FreqMax-FreqMin; 452 343 double DeltaFreq = FreqMax-FreqMin;
if(FreqMax<FreqMin) 453 344 if(FreqMax<FreqMin)
{ 454 345 {
printf("FreqMax should be > FreqMin\n"); 455 346 printf("FreqMax should be > FreqMin\n");
printf("Can't Start the ramp\n"); 456 347 printf("Can't Start the ramp\n");
return -1; 457 348 return -1;
} 458 349 }
459 350
//2- Calcul du nombre de points de la rampe 460 351 //2- Calcul du nombre de points de la rampe
int NumberPointsUp = DeltaFreq/dfUp; 461 352 int NumberPointsUp = DeltaFreq/dfUp;
int NumberPointsDown = DeltaFreq/dfDown; 462 353 int NumberPointsDown = DeltaFreq/dfDown;
463 354
//3- En déduire la valeur de dtUp et dtDown 464 355 //3- En déduire la valeur de dtUp et dtDown
double dtUp = DeltaTimeUp/NumberPointsUp; 465 356 double dtUp = DeltaTimeUp/NumberPointsUp;
double dtDown = DeltaTimeDown/NumberPointsDown; 466 357 double dtDown = DeltaTimeDown/NumberPointsDown;
467 358
double dtmin = 24/fclk; 468 359 double dtmin = 24/fclk;
double dtmax = dtmin*(pow(2.0,16.0)-1); 469 360 double dtmax = dtmin*(pow(2.0,16.0)-1);
470 361
//Check Up 471 362 //Check Up
if(dtUp<dtmin) 472 363 if(dtUp<dtmin)
{ 473 364 {
printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp); 474 365 printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp);
printf("Can't start the ramp\n"); 475 366 printf("Can't start the ramp\n");
return -1; 476 367 return -1;
} 477 368 }
478 369
if(dtUp>dtmax) 479 370 if(dtUp>dtmax)
{ 480 371 {
printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp); 481 372 printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp);
printf("Can't start the ramp\n"); 482 373 printf("Can't start the ramp\n");
return -1; 483 374 return -1;
} 484 375 }
485 376
//Check Down 486 377 //Check Down
if(dtDown<dtmin) 487 378 if(dtDown<dtmin)
{ 488 379 {
printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown); 489 380 printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown);
printf("Can't start the ramp\n"); 490 381 printf("Can't start the ramp\n");
return -1; 491 382 return -1;
} 492 383 }
493 384
if(dtDown>dtmax) 494 385 if(dtDown>dtmax)
{ 495 386 {
printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown); 496 387 printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown);
printf("Can't start the ramp\n"); 497 388 printf("Can't start the ramp\n");
return -1; 498 389 return -1;
} 499 390 }
500 391
501 392
//4 - Put word in register 502 393 //4 - Put word in register
503 394
504 395
//4.1 Limit register 505 396 //4.1 Limit register
uint32_t FTWRmin = rint((FreqMin/fclk)*pow(2.0,32.0)); 506 397 uint32_t FTWRmin = rint((FreqMin/fclk)*pow(2.0,32.0));
writeRegister(fd,0x04,FTWRmin>>24&0xFF,FTWRmin>>16&0xFF,FTWRmin>>8&0xFF,FTWRmin&0xFF);//mot de frequence 507 398 writeRegister(fd,0x04,FTWRmin>>24&0xFF,FTWRmin>>16&0xFF,FTWRmin>>8&0xFF,FTWRmin&0xFF);//mot de frequence
sendIOUpdate(f_dds); 508 399 sendIOUpdate(f_dds);
509 400
uint32_t FTWRmax = rint((FreqMax/fclk)*pow(2.0,32.0)); 510 401 uint32_t FTWRmax = rint((FreqMax/fclk)*pow(2.0,32.0));
writeRegister(fd,0x05,FTWRmax>>24&0xFF,FTWRmax>>16&0xFF,FTWRmax>>8&0xFF,FTWRmax&0xFF);//mot de frequence 511 402 writeRegister(fd,0x05,FTWRmax>>24&0xFF,FTWRmax>>16&0xFF,FTWRmax>>8&0xFF,FTWRmax&0xFF);//mot de frequence
sendIOUpdate(f_dds); 512 403 sendIOUpdate(f_dds);
513 404
514 405
//4.2 dfUP et dfDown 515 406 //4.2 dfUP et dfDown
double df_up = DeltaFreq/NumberPointsUp; 516 407 double df_up = DeltaFreq/NumberPointsUp;
double df_down = DeltaFreq/NumberPointsDown; 517 408 double df_down = DeltaFreq/NumberPointsDown;
518 409
uint32_t Word_df_up = rint(df_up*pow(2.0,32.0)/fclk); 519 410 uint32_t Word_df_up = rint(df_up*pow(2.0,32.0)/fclk);
uint32_t Word_df_down = rint(df_down*pow(2.0,32.0)/fclk); 520 411 uint32_t Word_df_down = rint(df_down*pow(2.0,32.0)/fclk);
521 412
writeRegister(fd,0x06,Word_df_up>>24&0xFF,Word_df_up>>16&0xFF,Word_df_up>>8&0xFF,Word_df_up&0xFF); //df_up 522 413 writeRegister(fd,0x06,Word_df_up>>24&0xFF,Word_df_up>>16&0xFF,Word_df_up>>8&0xFF,Word_df_up&0xFF); //df_up
sendIOUpdate(f_dds); 523 414 sendIOUpdate(f_dds);
writeRegister(fd,0x07,Word_df_down>>24&0xFF,Word_df_down>>16&0xFF,Word_df_down>>8&0xFF,Word_df_down&0xFF);//df_down 524 415 writeRegister(fd,0x07,Word_df_down>>24&0xFF,Word_df_down>>16&0xFF,Word_df_down>>8&0xFF,Word_df_down&0xFF);//df_down
sendIOUpdate(f_dds); 525 416 sendIOUpdate(f_dds);
526 417
527 418
//4.3 dtUp et dtDown 528 419 //4.3 dtUp et dtDown
529 420
uint16_t Word_dt_up = 0x0000; 530 421 uint16_t Word_dt_up = 0x0000;
uint16_t Word_dt_down = 0x0000; 531 422 uint16_t Word_dt_down = 0x0000;
532 423
Word_dt_up = rint(dtUp*fclk/24); 533 424 Word_dt_up = rint(dtUp*fclk/24);
Word_dt_down = rint(dtDown*fclk/24); 534 425 Word_dt_down = rint(dtDown*fclk/24);
535 426
writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt 536 427 writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt
sendIOUpdate(f_dds); 537 428 sendIOUpdate(f_dds);
538 429
//5 Start of the ramp 539 430 //5 Start of the ramp
540 431
writeRegister(fd,0x01,0x00,0x08,0x09,0x00); //rampe simple 541 432 writeRegister(fd,0x01,0x00,0x08,0x09,0x00); //rampe simple
sendIOUpdate(f_dds); 542 433 sendIOUpdate(f_dds);
return 0; 543 434 return 0;
544 435
545 436
546 437
return EXIT_SUCCESS; 547 438 return EXIT_SUCCESS;
548 439
} 549 440 }
550 441
551 442
//rampe continue de fréquence 552 443 //rampe continue de fréquence
int continueFrequencySweep (int fd, int f_dds,double fclk,double dfUp, double dfDown, double FreqMax,double FreqMin, double DeltaTimeUp, double DeltaTimeDown) 553 444 int continueFrequencySweep (int fd, int f_dds,double fclk,double dfUp, double dfDown, double FreqMax,double FreqMin, double DeltaTimeUp, double DeltaTimeDown)
{ 554 445 {
//calcul de N => N=DeltaF/df = DeltaT/dt 555 446 //calcul de N => N=DeltaF/df = DeltaT/dt
556 447
//1-fmax > fmin 557 448 //1-fmax > fmin
double DeltaFreq = FreqMax-FreqMin; 558 449 double DeltaFreq = FreqMax-FreqMin;
if(FreqMax<FreqMin) 559 450 if(FreqMax<FreqMin)
{ 560 451 {
printf("FreqMax should be > FreqMin\n"); 561 452 printf("FreqMax should be > FreqMin\n");
printf("Can't Start the ramp\n"); 562 453 printf("Can't Start the ramp\n");
return -1; 563 454 return -1;
} 564 455 }
565 456
//2- Calcul du nombre de points de la rampe 566 457 //2- Calcul du nombre de points de la rampe
int NumberPointsUp = DeltaFreq/dfUp; 567 458 int NumberPointsUp = DeltaFreq/dfUp;
int NumberPointsDown = DeltaFreq/dfDown; 568 459 int NumberPointsDown = DeltaFreq/dfDown;
569 460
//3- En déduire la valeur de dtUp et dtDown 570 461 //3- En déduire la valeur de dtUp et dtDown
double dtUp = DeltaTimeUp/NumberPointsUp; 571 462 double dtUp = DeltaTimeUp/NumberPointsUp;
double dtDown = DeltaTimeDown/NumberPointsDown; 572 463 double dtDown = DeltaTimeDown/NumberPointsDown;
573 464
double dtmin = 24/fclk; 574 465 double dtmin = 24/fclk;
double dtmax = dtmin*(pow(2.0,16.0)-1); 575 466 double dtmax = dtmin*(pow(2.0,16.0)-1);
576 467
//Check Up 577 468 //Check Up
if(dtUp<dtmin) 578 469 if(dtUp<dtmin)
{ 579 470 {
printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp); 580 471 printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp);
printf("Can't start the ramp\n"); 581 472 printf("Can't start the ramp\n");
return -1; 582 473 return -1;
} 583 474 }
584 475
if(dtUp>dtmax) 585 476 if(dtUp>dtmax)
{ 586 477 {
printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp); 587 478 printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp);
printf("Can't start the ramp\n"); 588 479 printf("Can't start the ramp\n");
return -1; 589 480 return -1;
} 590 481 }
591 482
//Check Down 592 483 //Check Down
if(dtDown<dtmin) 593 484 if(dtDown<dtmin)
{ 594 485 {
printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown); 595 486 printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown);
printf("Can't start the ramp\n"); 596 487 printf("Can't start the ramp\n");
return -1; 597 488 return -1;
} 598 489 }
599 490
if(dtDown>dtmax) 600 491 if(dtDown>dtmax)
{ 601 492 {
printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown); 602 493 printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown);
printf("Can't start the ramp\n"); 603 494 printf("Can't start the ramp\n");
return -1; 604 495 return -1;
} 605 496 }
606 497
607 498
//4 - Put word in register 608 499 //4 - Put word in register
609 500
610 501
//4.1 Limit register 611 502 //4.1 Limit register
uint32_t FTWRmin = rint((FreqMin/fclk)*pow(2.0,32.0)); 612 503 uint32_t FTWRmin = rint((FreqMin/fclk)*pow(2.0,32.0));
writeRegister(fd,0x04,FTWRmin>>24&0xFF,FTWRmin>>16&0xFF,FTWRmin>>8&0xFF,FTWRmin&0xFF);//mot de frequence 613 504 writeRegister(fd,0x04,FTWRmin>>24&0xFF,FTWRmin>>16&0xFF,FTWRmin>>8&0xFF,FTWRmin&0xFF);//mot de frequence
sendIOUpdate(f_dds); 614 505 sendIOUpdate(f_dds);
615 506
uint32_t FTWRmax = rint((FreqMax/fclk)*pow(2.0,32.0)); 616 507 uint32_t FTWRmax = rint((FreqMax/fclk)*pow(2.0,32.0));
writeRegister(fd,0x05,FTWRmax>>24&0xFF,FTWRmax>>16&0xFF,FTWRmax>>8&0xFF,FTWRmax&0xFF);//mot de frequence 617 508 writeRegister(fd,0x05,FTWRmax>>24&0xFF,FTWRmax>>16&0xFF,FTWRmax>>8&0xFF,FTWRmax&0xFF);//mot de frequence
sendIOUpdate(f_dds); 618 509 sendIOUpdate(f_dds);
619 510
620 511
//4.2 dfUP et dfDown 621 512 //4.2 dfUP et dfDown
double df_up = DeltaFreq/NumberPointsUp; 622 513 double df_up = DeltaFreq/NumberPointsUp;
double df_down = DeltaFreq/NumberPointsDown; 623 514 double df_down = DeltaFreq/NumberPointsDown;
624 515
uint32_t Word_df_up = rint(df_up*pow(2.0,32.0)/fclk); 625 516 uint32_t Word_df_up = rint(df_up*pow(2.0,32.0)/fclk);
uint32_t Word_df_down = rint(df_down*pow(2.0,32.0)/fclk); 626 517 uint32_t Word_df_down = rint(df_down*pow(2.0,32.0)/fclk);
627 518
writeRegister(fd,0x06,Word_df_up>>24&0xFF,Word_df_up>>16&0xFF,Word_df_up>>8&0xFF,Word_df_up&0xFF); //df_up 628 519 writeRegister(fd,0x06,Word_df_up>>24&0xFF,Word_df_up>>16&0xFF,Word_df_up>>8&0xFF,Word_df_up&0xFF); //df_up
sendIOUpdate(f_dds); 629 520 sendIOUpdate(f_dds);
writeRegister(fd,0x07,Word_df_down>>24&0xFF,Word_df_down>>16&0xFF,Word_df_down>>8&0xFF,Word_df_down&0xFF);//df_down 630 521 writeRegister(fd,0x07,Word_df_down>>24&0xFF,Word_df_down>>16&0xFF,Word_df_down>>8&0xFF,Word_df_down&0xFF);//df_down
sendIOUpdate(f_dds); 631 522 sendIOUpdate(f_dds);
632 523
633 524
//4.3 dtUp et dtDown 634 525 //4.3 dtUp et dtDown
635 526
uint16_t Word_dt_up = 0x0000; 636 527 uint16_t Word_dt_up = 0x0000;
uint16_t Word_dt_down = 0x0000; 637 528 uint16_t Word_dt_down = 0x0000;
638 529
Word_dt_up = rint(dtUp*fclk/24); 639 530 Word_dt_up = rint(dtUp*fclk/24);
Word_dt_down = rint(dtDown*fclk/24); 640 531 Word_dt_down = rint(dtDown*fclk/24);
641 532
writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt 642 533 writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt
sendIOUpdate(f_dds); 643 534 sendIOUpdate(f_dds);
644 535
//5 Start of the ramp 645 536 //5 Start of the ramp
646 537
writeRegister(fd,0x01,0x00,0x8e,0x29,0x00); //rampe triangulaire 647 538 writeRegister(fd,0x01,0x00,0x8e,0x29,0x00); //rampe triangulaire
sendIOUpdate(f_dds); 648 539 sendIOUpdate(f_dds);
return 0; 649 540 return 0;
650 541
651 542
652 543
return EXIT_SUCCESS; 653 544 return EXIT_SUCCESS;
654 545
} 655 546 }
656 547
//2-rampe d'amplitude 657 548 //2-rampe d'amplitude
658 549
int amplitudeSweep (int fd, int f_dds,double fclk,double dAUp, double dADown, double AMax,double AMin, double DeltaTimeUp, double DeltaTimeDown) 659 550 int amplitudeSweep (int fd, int f_dds,double fclk,double dAUp, double dADown, double AMax,double AMin, double DeltaTimeUp, double DeltaTimeDown)
{ 660 551 {
661 552
662 553
//calcul de N => N=DeltaF/df = DeltaT/dt 663 554 //calcul de N => N=DeltaF/df = DeltaT/dt
664 555
//1-Amax > Amin 665 556 //1-Amax > Amin
double DeltaAmp = AMax-AMin; 666 557 double DeltaAmp = AMax-AMin;
if(AMax<AMin) 667 558 if(AMax<AMin)
{ 668 559 {
printf("AMax should be > AMin\n"); 669 560 printf("AMax should be > AMin\n");
printf("Can't Start the ramp\n"); 670 561 printf("Can't Start the ramp\n");
return -1; 671 562 return -1;
} 672 563 }
673 564
674 565
//2- Calcul du nombre de points de la rampe 675 566 //2- Calcul du nombre de points de la rampe
int NumberPointsUp = DeltaAmp/dAUp; 676 567 int NumberPointsUp = DeltaAmp/dAUp;
int NumberPointsDown = DeltaAmp/dADown; 677 568 int NumberPointsDown = DeltaAmp/dADown;
678 569
//3- En déduire la valeur de dtUp et dtDown 679 570 //3- En déduire la valeur de dtUp et dtDown
double dtUp = DeltaTimeUp/NumberPointsUp; 680 571 double dtUp = DeltaTimeUp/NumberPointsUp;
double dtDown = DeltaTimeDown/NumberPointsDown; 681 572 double dtDown = DeltaTimeDown/NumberPointsDown;
682 573
double dtmin = 24/fclk; 683 574 double dtmin = 24/fclk;
double dtmax = dtmin*(pow(2.0,16.0)-1); 684 575 double dtmax = dtmin*(pow(2.0,16.0)-1);
685 576
//Check Up 686 577 //Check Up
if(dtUp<dtmin) 687 578 if(dtUp<dtmin)
{ 688 579 {
printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp); 689 580 printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp);
printf("Can't start the ramp\n"); 690 581 printf("Can't start the ramp\n");
return -1; 691 582 return -1;
} 692 583 }
693 584
if(dtUp>dtmax) 694 585 if(dtUp>dtmax)
{ 695 586 {
printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp); 696 587 printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp);
printf("Can't start the ramp\n"); 697 588 printf("Can't start the ramp\n");
return -1; 698 589 return -1;
} 699 590 }
700 591
//Check Down 701 592 //Check Down
if(dtDown<dtmin) 702 593 if(dtDown<dtmin)
{ 703 594 {
printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown); 704 595 printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown);
printf("Can't start the ramp\n"); 705 596 printf("Can't start the ramp\n");
return -1; 706 597 return -1;
} 707 598 }
708 599
if(dtDown>dtmax) 709 600 if(dtDown>dtmax)
{ 710 601 {
printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown); 711 602 printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown);
printf("Can't start the ramp\n"); 712 603 printf("Can't start the ramp\n");
return -1; 713 604 return -1;
} 714 605 }
715 606
716 607
717 608
//check if DeltaAmp is enouth 718 609 //check if DeltaAmp is enouth
double enouthUP=0.5*NumberPointsUp*100/4095; 719 610 double enouthUP=0.5*NumberPointsUp*100/4095;
double enouthDOWN=0.5*NumberPointsDown*100/4095; 720 611 double enouthDOWN=0.5*NumberPointsDown*100/4095;
721 612
int borneUP = rint(enouthUP); 722 613 int borneUP = rint(enouthUP);
int borneDown = rint(enouthDOWN); 723 614 int borneDown = rint(enouthDOWN);
724 615
if(DeltaAmp<=enouthUP) 725 616 if(DeltaAmp<=enouthUP)
{ 726 617 {
printf("The amplitude difference should be > %d\n, decrease Number Points for positive slope",borneUP); 727 618 printf("The amplitude difference should be > %d\n, decrease Number Points for positive slope",borneUP);
//return -1; 728
} 729 619 }
730 620
if(DeltaAmp<=enouthDOWN) 731 621 if(DeltaAmp<=enouthDOWN)
{ 732 622 {
printf("The amplitude difference should be > %d\n, decrease Number Points for negative slope",borneDown); 733 623 printf("The amplitude difference should be > %d\n, decrease Number Points for negative slope",borneDown);
//return -1; 734
} 735 624 }
736 625
737 626
//4 - Put word in register 738 627 //4 - Put word in register
739 628
740 629
//4.1 Limit register 741 630 //4.1 Limit register
uint32_t WordAmin = rint(AMin*4095/100); 742 631 uint32_t WordAmin = rint(AMin*4095/100);
uint32_t WordAmax= rint(AMax*4095/100); 743 632 uint32_t WordAmax= rint(AMax*4095/100);
744 633
writeRegister(fd,0x04,WordAmin>>24&0xFF,WordAmin>>16&0xFF,WordAmin>>8&0xFF,WordAmin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2 745 634 writeRegister(fd,0x04,WordAmin>>24&0xFF,WordAmin>>16&0xFF,WordAmin>>8&0xFF,WordAmin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2
sendIOUpdate(f_dds); 746 635 sendIOUpdate(f_dds);
writeRegister(fd,0x05,WordAmax>>24&0xFF,WordAmax>>16&0xFF,WordAmax>>8&0xFF,WordAmax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0 747 636 writeRegister(fd,0x05,WordAmax>>24&0xFF,WordAmax>>16&0xFF,WordAmax>>8&0xFF,WordAmax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0
sendIOUpdate(f_dds); 748 637 sendIOUpdate(f_dds);
749 638
750 639
//4.2 dAUP et dADown 751 640 //4.2 dAUP et dADown
752 641
uint32_t Word_dA_up = rint(dAUp*4095/100); 753 642 uint32_t Word_dA_up = rint(dAUp*4095/100);
uint32_t Word_dA_down = rint(dADown*4095/100); 754 643 uint32_t Word_dA_down = rint(dADown*4095/100);
755 644
writeRegister(fd,0x06,Word_dA_up>>24&0xFF,Word_dA_up>>16&0xFF,Word_dA_up>>8&0xFF,Word_dA_up&0xFF); //dA_up 756 645 writeRegister(fd,0x06,Word_dA_up>>24&0xFF,Word_dA_up>>16&0xFF,Word_dA_up>>8&0xFF,Word_dA_up&0xFF); //dA_up
sendIOUpdate(f_dds); 757 646 sendIOUpdate(f_dds);
writeRegister(fd,0x07,Word_dA_down>>24&0xFF,Word_dA_down>>16&0xFF,Word_dA_down>>8&0xFF,Word_dA_down&0xFF);//dA_down 758 647 writeRegister(fd,0x07,Word_dA_down>>24&0xFF,Word_dA_down>>16&0xFF,Word_dA_down>>8&0xFF,Word_dA_down&0xFF);//dA_down
sendIOUpdate(f_dds); 759 648 sendIOUpdate(f_dds);
760 649
761 650
//4.3 dtUp et dtDown 762 651 //4.3 dtUp et dtDown
763 652
uint16_t Word_dt_up = rint(dtUp*fclk/24); 764 653 uint16_t Word_dt_up = rint(dtUp*fclk/24);
uint16_t Word_dt_down = rint(dtDown*fclk/24); 765 654 uint16_t Word_dt_down = rint(dtDown*fclk/24);
766 655
writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt 767 656 writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt
sendIOUpdate(f_dds); 768 657 sendIOUpdate(f_dds);
769 658
//5 Start of the ramp 770 659 //5 Start of the ramp
771 660
writeRegister(fd,0x01,0x00,0x28,0x09,0x00); //rampe simple montante 772 661 writeRegister(fd,0x01,0x00,0x28,0x09,0x00); //rampe simple montante
//writeRegister(fd,0x01,0x00,0xAE,0x29,0x00); //rampe continue 773 662 //writeRegister(fd,0x01,0x00,0xAE,0x29,0x00); //rampe continue
sendIOUpdate(f_dds); 774 663 sendIOUpdate(f_dds);
775 664
return EXIT_SUCCESS; 776 665 return EXIT_SUCCESS;
} 777 666 }
778 667
int continueAmplitudeSweep (int fd, int f_dds,double fclk,double dAUp, double dADown, double AMax,double AMin, double DeltaTimeUp, double DeltaTimeDown) 779 668 int continueAmplitudeSweep (int fd, int f_dds,double fclk,double dAUp, double dADown, double AMax,double AMin, double DeltaTimeUp, double DeltaTimeDown)
{ 780 669 {
781 670
782 671
//calcul de N => N=DeltaF/df = DeltaT/dt 783 672 //calcul de N => N=DeltaF/df = DeltaT/dt
784 673
//1-Amax > Amin 785 674 //1-Amax > Amin
double DeltaAmp = AMax-AMin; 786 675 double DeltaAmp = AMax-AMin;
if(AMax<AMin) 787 676 if(AMax<AMin)
{ 788 677 {
printf("AMax should be > AMin\n"); 789 678 printf("AMax should be > AMin\n");
printf("Can't Start the ramp\n"); 790 679 printf("Can't Start the ramp\n");
return -1; 791 680 return -1;
} 792 681 }
793 682
794 683
//2- Calcul du nombre de points de la rampe 795 684 //2- Calcul du nombre de points de la rampe
int NumberPointsUp = DeltaAmp/dAUp; 796 685 int NumberPointsUp = DeltaAmp/dAUp;
int NumberPointsDown = DeltaAmp/dADown; 797 686 int NumberPointsDown = DeltaAmp/dADown;
798 687
//3- En déduire la valeur de dtUp et dtDown 799 688 //3- En déduire la valeur de dtUp et dtDown
double dtUp = DeltaTimeUp/NumberPointsUp; 800 689 double dtUp = DeltaTimeUp/NumberPointsUp;
double dtDown = DeltaTimeDown/NumberPointsDown; 801 690 double dtDown = DeltaTimeDown/NumberPointsDown;
802 691
double dtmin = 24/fclk; 803 692 double dtmin = 24/fclk;
double dtmax = dtmin*(pow(2.0,16.0)-1); 804 693 double dtmax = dtmin*(pow(2.0,16.0)-1);
805 694
//Check Up 806 695 //Check Up
if(dtUp<dtmin) 807 696 if(dtUp<dtmin)
{ 808 697 {
printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp); 809 698 printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp);
printf("Can't start the ramp\n"); 810 699 printf("Can't start the ramp\n");
return -1; 811 700 return -1;
} 812 701 }
813 702
if(dtUp>dtmax) 814 703 if(dtUp>dtmax)
{ 815 704 {
printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp); 816 705 printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp);
printf("Can't start the ramp\n"); 817 706 printf("Can't start the ramp\n");
return -1; 818 707 return -1;
} 819 708 }
820 709
//Check Down 821 710 //Check Down
if(dtDown<dtmin) 822 711 if(dtDown<dtmin)
{ 823 712 {
printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown); 824 713 printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown);
printf("Can't start the ramp\n"); 825 714 printf("Can't start the ramp\n");
return -1; 826 715 return -1;
} 827 716 }
828 717
if(dtDown>dtmax) 829 718 if(dtDown>dtmax)
{ 830 719 {
printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown); 831 720 printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown);
printf("Can't start the ramp\n"); 832 721 printf("Can't start the ramp\n");
return -1; 833 722 return -1;
} 834 723 }
835 724
836 725
837 726
//check if DeltaAmp is enouth 838 727 //check if DeltaAmp is enouth
double enouthUP=0.5*NumberPointsUp*100/4095; 839 728 double enouthUP=0.5*NumberPointsUp*100/4095;
double enouthDOWN=0.5*NumberPointsDown*100/4095; 840 729 double enouthDOWN=0.5*NumberPointsDown*100/4095;
841 730
int borneUP = rint(enouthUP); 842 731 int borneUP = rint(enouthUP);
int borneDown = rint(enouthDOWN); 843 732 int borneDown = rint(enouthDOWN);
844 733
if(DeltaAmp<=enouthUP) 845 734 if(DeltaAmp<=enouthUP)
{ 846 735 {
printf("The amplitude difference should be > %d\n, decrease Number Points for positive slope",borneUP); 847 736 printf("The amplitude difference should be > %d\n, decrease Number Points for positive slope",borneUP);
//return -1; 848 737 //return -1;
} 849 738 }
850 739
if(DeltaAmp<=enouthDOWN) 851 740 if(DeltaAmp<=enouthDOWN)
{ 852 741 {
printf("The amplitude difference should be > %d\n, decrease Number Points for negative slope",borneDown); 853 742 printf("The amplitude difference should be > %d\n, decrease Number Points for negative slope",borneDown);
//return -1; 854 743 //return -1;
} 855 744 }
856 745
857 746
//4 - Put word in register 858 747 //4 - Put word in register
859 748
860 749
//4.1 Limit register 861 750 //4.1 Limit register
uint32_t WordAmin = rint(AMin*4095/100); 862 751 uint32_t WordAmin = rint(AMin*4095/100);
uint32_t WordAmax= rint(AMax*4095/100); 863 752 uint32_t WordAmax= rint(AMax*4095/100);
864 753
writeRegister(fd,0x04,WordAmin>>24&0xFF,WordAmin>>16&0xFF,WordAmin>>8&0xFF,WordAmin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2 865 754 writeRegister(fd,0x04,WordAmin>>24&0xFF,WordAmin>>16&0xFF,WordAmin>>8&0xFF,WordAmin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2
sendIOUpdate(f_dds); 866 755 sendIOUpdate(f_dds);
writeRegister(fd,0x05,WordAmax>>24&0xFF,WordAmax>>16&0xFF,WordAmax>>8&0xFF,WordAmax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0 867 756 writeRegister(fd,0x05,WordAmax>>24&0xFF,WordAmax>>16&0xFF,WordAmax>>8&0xFF,WordAmax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0
sendIOUpdate(f_dds); 868 757 sendIOUpdate(f_dds);
869 758
870 759
//4.2 dAUP et dADown 871 760 //4.2 dAUP et dADown
872 761
uint32_t Word_dA_up = rint(dAUp*4095/100); 873 762 uint32_t Word_dA_up = rint(dAUp*4095/100);
uint32_t Word_dA_down = rint(dADown*4095/100); 874 763 uint32_t Word_dA_down = rint(dADown*4095/100);
875 764
writeRegister(fd,0x06,Word_dA_up>>24&0xFF,Word_dA_up>>16&0xFF,Word_dA_up>>8&0xFF,Word_dA_up&0xFF); //dA_up 876 765 writeRegister(fd,0x06,Word_dA_up>>24&0xFF,Word_dA_up>>16&0xFF,Word_dA_up>>8&0xFF,Word_dA_up&0xFF); //dA_up
sendIOUpdate(f_dds); 877 766 sendIOUpdate(f_dds);
writeRegister(fd,0x07,Word_dA_down>>24&0xFF,Word_dA_down>>16&0xFF,Word_dA_down>>8&0xFF,Word_dA_down&0xFF);//dA_down 878 767 writeRegister(fd,0x07,Word_dA_down>>24&0xFF,Word_dA_down>>16&0xFF,Word_dA_down>>8&0xFF,Word_dA_down&0xFF);//dA_down
sendIOUpdate(f_dds); 879 768 sendIOUpdate(f_dds);
880 769
881 770
//4.3 dtUp et dtDown 882 771 //4.3 dtUp et dtDown
883 772
uint16_t Word_dt_up = rint(dtUp*fclk/24); 884 773 uint16_t Word_dt_up = rint(dtUp*fclk/24);
uint16_t Word_dt_down = rint(dtDown*fclk/24); 885 774 uint16_t Word_dt_down = rint(dtDown*fclk/24);
886 775
writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt 887 776 writeRegister(fd,0x08,Word_dt_down>>8&0xFF,Word_dt_down&0xFF,Word_dt_up>>8&0xFF,Word_dt_up&0xFF); // il y a 2 dt
sendIOUpdate(f_dds); 888 777 sendIOUpdate(f_dds);
889 778
//5 Start of the ramp 890 779 //5 Start of the ramp
891 780
//writeRegister(fd,0x01,0x00,0x28,0x09,0x00); //rampe simple montante 892 781 //writeRegister(fd,0x01,0x00,0x28,0x09,0x00); //rampe simple montante
writeRegister(fd,0x01,0x00,0xAE,0x29,0x00); //rampe continue 893 782 writeRegister(fd,0x01,0x00,0xAE,0x29,0x00); //rampe continue
sendIOUpdate(f_dds); 894 783 sendIOUpdate(f_dds);
895 784
return EXIT_SUCCESS; 896 785 return EXIT_SUCCESS;
} 897 786 }
898 787
899 788
//3-rampe de ĥase 900 789 //3-rampe de ĥase
901 790
int phaseSweep (int fd, int f_dds,double fclk,double dphiUp, double dphiDown, double PhiMax,double PhiMin, double DeltaTimeUp, double DeltaTimeDown) 902 791 int phaseSweep (int fd, int f_dds,double fclk,double dphiUp, double dphiDown, double PhiMax,double PhiMin, double DeltaTimeUp, double DeltaTimeDown)
{ 903 792 {
904 793
905 794
//calcul de N => N=Deltaphi/dphi = DeltaT/dt 906 795 //calcul de N => N=Deltaphi/dphi = DeltaT/dt
907 796
//1-phimax > phimin 908 797 //1-phimax > phimin
double DeltaPhi = PhiMax-PhiMin; 909 798 double DeltaPhi = PhiMax-PhiMin;
if(PhiMax<PhiMin) 910 799 if(PhiMax<PhiMin)
{ 911 800 {
printf("PhiMax should be > PhiMin\n"); 912 801 printf("PhiMax should be > PhiMin\n");
printf("Can't Start the ramp\n"); 913 802 printf("Can't Start the ramp\n");
return -1; 914 803 return -1;
} 915 804 }
916 805
917 806
//2- Calcul du nombre de points de la rampe 918 807 //2- Calcul du nombre de points de la rampe
int NumberPointsUp = DeltaPhi/dphiUp; 919 808 int NumberPointsUp = DeltaPhi/dphiUp;
int NumberPointsDown = DeltaPhi/dphiDown; 920 809 int NumberPointsDown = DeltaPhi/dphiDown;
921 810
printf("NumberPointsUp = %d\n",NumberPointsUp); 922 811 printf("NumberPointsUp = %d\n",NumberPointsUp);
printf("NumberPointsDown = %d\n",NumberPointsDown); 923 812 printf("NumberPointsDown = %d\n",NumberPointsDown);
924 813
//3- En déduire la valeur de dtUp et dtDown 925 814 //3- En déduire la valeur de dtUp et dtDown
double dtUp = DeltaTimeUp/NumberPointsUp; 926 815 double dtUp = DeltaTimeUp/NumberPointsUp;
double dtDown = DeltaTimeDown/NumberPointsDown; 927 816 double dtDown = DeltaTimeDown/NumberPointsDown;
928 817
double dtmin = 24/fclk; 929 818 double dtmin = 24/fclk;
double dtmax = dtmin*(pow(2.0,16.0)-1); 930 819 double dtmax = dtmin*(pow(2.0,16.0)-1);
931 820
//Check Up 932 821 //Check Up
if(dtUp<dtmin) 933 822 if(dtUp<dtmin)
{ 934 823 {
printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp); 935 824 printf("During of ramp UP should be > %f s\n",dtmin*NumberPointsUp);
printf("Can't start the ramp\n"); 936 825 printf("Can't start the ramp\n");
return -1; 937 826 return -1;
} 938 827 }
939 828
if(dtUp>dtmax) 940 829 if(dtUp>dtmax)
{ 941 830 {
printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp); 942 831 printf("During of ramp UP should be < %f\n",dtmax*NumberPointsUp);
printf("Can't start the ramp\n"); 943 832 printf("Can't start the ramp\n");
return -1; 944 833 return -1;
} 945 834 }
946 835
//Check Down 947 836 //Check Down
if(dtDown<dtmin) 948 837 if(dtDown<dtmin)
{ 949 838 {
printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown); 950 839 printf("During of ramp DOWN should be > %f s\n",dtmin*NumberPointsDown);
printf("Can't start the ramp\n"); 951 840 printf("Can't start the ramp\n");
return -1; 952 841 return -1;
} 953 842 }
954 843
if(dtDown>dtmax) 955 844 if(dtDown>dtmax)
{ 956 845 {
printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown); 957 846 printf("During of ramp DOWN should be < %f\n",dtmax*NumberPointsDown);
printf("Can't start the ramp\n"); 958 847 printf("Can't start the ramp\n");
return -1; 959 848 return -1;
} 960 849 }
961 850
962 851
963
//check if DeltaAmp is enouth 964
/* 965
double enouthUP=0.5*NumberPointsUp*100/4095; 966
double enouthDOWN=0.5*NumberPointsDown*100/4095; 967
968
int borneUP = rint(enouthUP); 969
int borneDown = rint(enouthDOWN); 970
971
if(DeltaAmp<=enouthUP) 972
{ 973
printf("The amplitude difference should be > %d\n, decrease Number Points for positive slope",borneUP); 974
//return -1; 975
} 976
977
if(DeltaAmp<=enouthDOWN) 978
{ 979
printf("The amplitude difference should be > %d\n, decrease Number Points for negative slope",borneDown); 980
//return -1; 981
} 982
983
*/ 984
985
//4 - Put word in register 986
987
988
//4.1 Limit register 989 852 //4.1 Limit register
uint32_t WordPhimin = rint(PhiMin*65535/360); 990 853 uint32_t WordPhimin = rint(PhiMin*65535/360);
uint32_t WordPhimax= rint(PhiMax*65535/360); 991 854 uint32_t WordPhimax= rint(PhiMax*65535/360);
992 855
993 856
printf("WordPhimin = %.32x\n",WordPhimin); 994 857 printf("WordPhimin = %.32x\n",WordPhimin);
printf("WordPhimax = %.32x\n",WordPhimax); 995 858 printf("WordPhimax = %.32x\n",WordPhimax);
996 859
997 860
writeRegister(fd,0x04,WordPhimin>>24&0xFF,WordPhimin>>16&0xFF,WordPhimin>>8&0xFF,WordPhimin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2 998 861 writeRegister(fd,0x04,WordPhimin>>24&0xFF,WordPhimin>>16&0xFF,WordPhimin>>8&0xFF,WordPhimin&0xFF); //min => lim-(Amp ) = 0x800 = Amax/2
sendIOUpdate(f_dds); 999 862 sendIOUpdate(f_dds);
writeRegister(fd,0x05,WordPhimax>>24&0xFF,WordPhimax>>16&0xFF,WordPhimax>>8&0xFF,WordPhimax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0 1000 863 writeRegister(fd,0x05,WordPhimax>>24&0xFF,WordPhimax>>16&0xFF,WordPhimax>>8&0xFF,WordPhimax&0xFF);//max => lim+(Amp) = 0xFFF= Amax0
sendIOUpdate(f_dds); 1001 864 sendIOUpdate(f_dds);
1002 865
1003 866
//4.2 dphiUP et dphiDown 1004 867 //4.2 dphiUP et dphiDown
1005 868
// uint32_t Word_dphi_up = rint(dphiUp*(pow(2.0,29.0)-1)/45); 1006
// uint32_t Word_dphi_down = rint(dphiDown*(pow(2.0,29.0)-1)/45); 1007
uint32_t Word_dphi_up = rint(dphiUp*(65535/360)); 1008 869 uint32_t Word_dphi_up = rint(dphiUp*(65535/360));
uint32_t Word_dphi_down = rint(dphiDown*(65535/360)); 1009 870 uint32_t Word_dphi_down = rint(dphiDown*(65535/360));
1010 871
printf("Word_dphi_up = %.32x\n",Word_dphi_up); 1011 872 printf("Word_dphi_up = %.32x\n",Word_dphi_up);
printf("Word_dphi_down = %.32x\n",Word_dphi_down); 1012 873 printf("Word_dphi_down = %.32x\n",Word_dphi_down);
1013 874
/* 1014
writeRegister(fd,0x06,Word_dphi_up>>16&0xFF,Word_dphi_up>>8&0xFF,Word_dphi_up>>0&0xFF,Word_dphi_up&0xFF); //dphi_up 1015
sendIOUpdate(f_dds); 1016
writeRegister(fd,0x07,Word_dphi_down>>16&0xFF,Word_dphi_down>>8&0xFF,Word_dphi_down>>0&0xFF,Word_dphi_down&0xFF);//dphi_down 1017
sendIOUpdate(f_dds); 1018
1019 875
*/ 1020
1021
1022
writeRegister(fd,0x06,Word_dphi_up>>24&0xFF,Word_dphi_up>>16&0xFF,Word_dphi_up>>8&0xFF,Word_dphi_up&0xFF); //dA_up 1023 876 writeRegister(fd,0x06,Word_dphi_up>>24&0xFF,Word_dphi_up>>16&0xFF,Word_dphi_up>>8&0xFF,Word_dphi_up&0xFF); //dA_up
sendIOUpdate(f_dds); 1024 877 sendIOUpdate(f_dds);
writeRegister(fd,0x07,Word_dphi_down>>24&0xFF,Word_dphi_down>>16&0xFF,Word_dphi_down>>8&0xFF,Word_dphi_down&0xFF);//dA_down 1025 878 writeRegister(fd,0x07,Word_dphi_down>>24&0xFF,Word_dphi_down>>16&0xFF,Word_dphi_down>>8&0xFF,Word_dphi_down&0xFF);//dA_down
sendIOUpdate(f_dds); 1026 879 sendIOUpdate(f_dds);
1027 880
1028 881
//4.3 dtUp et dtDown 1029 882 //4.3 dtUp et dtDown
1030 883
uint16_t Word_dt_up = rint(dtUp*fclk/24); 1031 884 uint16_t Word_dt_up = rint(dtUp*fclk/24);
uint16_t Word_dt_down = rint(dtDown*fclk/24); 1032 885 uint16_t Word_dt_down = rint(dtDown*fclk/24);