LTlib LaurTec Library  4.0.1
Open Source C Library for Microchip Microcontrollers based on XC8 Compiler
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
AD9833.c
Go to the documentation of this file.
1 /*******************************************************************************
2 
3 Author : Dario Di Turi
4 Version : 1.2
5 Date : 08/12/2012
6 
7 Last Update: Mauro Laurenti
8 Last Update: 15/12/2014
9 
10 ********************************************************
11 SOFTWARE LICENSE AGREEMENT
12 ********************************************************
13 
14 The usage of the supplied software imply the acceptance of the following license.
15 
16 The software supplied herewith by Dario Di Turi (the Author) is intended for
17 use solely and exclusively on Microchip PIC Microcontroller (registered mark).
18 The software is owned by the Author, and is protected under applicable
19 copyright laws. All rights are reserved.
20 Any use in violation of the foregoing restrictions may subject the
21 user to criminal sanctions under applicable laws, as well as to civil liability
22 for the breach of the terms and conditions of this license.
23 Commercial use is forbidden without a written acknowledgement with the Author.
24 Personal or educational use is allowed if the application containing the
25 following software doesn't aim to commercial use or monetary earning of any kind.
26 
27 THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES,
28 WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
29 TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
30 PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE AUTHOR SHALL NOT,
31 IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
32 CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
33 *************************************************************/
34 
35 #ifdef __XC8
36  #include <xc.h>
37 #endif
38 
39 #include "AD9833.h"
40 
41 unsigned int K;
42 unsigned int register_word;
43 unsigned int tuning_freq;
44 
45 
46 //*********************************************
47 // write_register
48 //*********************************************
49 void AD9833_write_data(unsigned int data){
50 
51  //FSYNC low, load word into the device
52  FSYNC=0;
53 
54  //MSB data
55  while(AD9833_SPI_write_byte(data>>8));
56 
57  //LSB data
58  while(AD9833_SPI_write_byte(data));
59 
60  //FSYNC high, load word completed
61  FSYNC=1;
62 }
63 
64 
65 //*********************************************
66 // compose_AD9833_control_word
67 //*********************************************
68 unsigned int AD9833_compose_control_word(unsigned char function_type){
69 
70 
71  // Write frequency register
72  if(function_type==0){
73  register_word=register_word | 0b0010000000000000;
74  return(register_word);
75  }
76 
77  // Sinusoidal waveform
78  if(function_type==1){
79  register_word=register_word & 0b1111111111000000;
80  return(register_word);
81  }
82 
83  // Triangular waveform
84  if(function_type==2){
85  register_word=register_word & 0b1111111111000000;
86  register_word=register_word | 0b0000000000000010;
87  return(register_word);
88  }
89 
90  // Square waveform
91  if(function_type==3){
92  register_word=register_word & 0b1111111111000000;
93  register_word=register_word | 0b0000000000101000;
94  return(register_word);
95 
96  }
97  // FREQ0 out
98  if(function_type==4){
99  register_word=register_word & 0b1111011111111111;
100  return(register_word);
101 
102  }
103  // FREQ1 out
104  if(function_type==5){
105  register_word=register_word & 0b1111011111111111;
106  register_word=register_word | 0b0000100000000000;
107  return(register_word);
108 
109  }
110  // PHASE0 out
111  if(function_type==6){
112  register_word=register_word & 0b1111101111111111;
113  return(register_word);
114 
115  }
116  // PHASE1 out
117  if(function_type==7){
118  register_word=register_word & 0b1111101111111111;
119  register_word=register_word | 0b0000010000000000;
120  return(register_word);
121 
122  }
123  // Write LSB frequency register
124  if(function_type==8){
125  register_word=register_word & 0b0000111111111111;
126  return(register_word);
127 
128  }
129  // Sleep mode
130  if(function_type==9){
131  register_word=register_word & 0b1111111100111111;
132  register_word=register_word | 0b0000010011000000;
133  return(register_word);
134 
135  }
136  // Power ON
137  if(function_type==10){
138  register_word=register_word & 0b1111111100111111;
139  return(register_word);
140 
141  }
142 
143  // This return is never executed but it removes a compiler warning.
144  return (0);
145 }
146 
147 
148 //*********************************************
149 // AD9833_initialize
150 //*********************************************
151 void AD9833_initialize (unsigned char fmclk){
152 
154 
158 
159  register_word=0x0000;
160  tuning_freq=0x0000;
161 
162  K=268435456/(fmclk*100000); //2^28/(fmclk*100000)
163 
169 
170 
174 
175 }
176 
177 
178 //*********************************************
179 // AD9833_set_frequency
180 //*********************************************
181 void AD9833_set_frequency (unsigned long freq_value, unsigned char frequency_register){
182 
183  unsigned long freq_reg_value;
184  unsigned int freq_reg_value_l,freq_reg_value_h;
185  unsigned int control_word;
186 
187  freq_reg_value = (freq_value/10) * K; //2^28/(fmclk)
188 
189  freq_reg_value = freq_reg_value << 2;
190  freq_reg_value_l = freq_reg_value;
191  freq_reg_value_h = freq_reg_value >> 16;
192  freq_reg_value_l = freq_reg_value_l >> 2;
193 
194  // Save the LSB frequency register for the tuning function
195  tuning_freq=freq_reg_value_l;
196 
197  // Write into FREQ0 register
198  if(frequency_register==0){
199 
200  freq_reg_value_l = freq_reg_value_l & 0x7FFF; //0b0111,1111,1111,1111
201  freq_reg_value_l = freq_reg_value_l | 0x4000; //0b0100,0000,0000,0000
202 
203  freq_reg_value_h = freq_reg_value_h & 0x7FFF;
204  freq_reg_value_h = freq_reg_value_h | 0x4000;
205  }
206 
207  // Write into FREQ1 register
208  if(frequency_register==1){
209 
210  freq_reg_value_l = freq_reg_value_l & 0xBFFF; //0b1011,1111,1111,1111
211  freq_reg_value_l = freq_reg_value_l | 0x8000; //0b1000,0000,0000,0000
212 
213  freq_reg_value_h = freq_reg_value_h & 0xBFFF;
214  freq_reg_value_h = freq_reg_value_h | 0x8000;
215  }
216 
217  control_word = AD9833_compose_control_word(0);
218  AD9833_write_data (control_word);
219  AD9833_write_data (freq_reg_value_l);
220  AD9833_write_data (freq_reg_value_h);
221 
222 }
223 
224 
225 //*********************************************
226 // AD9833_tuning_frequency
227 //*********************************************
228 void AD9833_tuning_frequency (unsigned char tuning_step, unsigned char direction,unsigned char frequency_register ){
229 
230  unsigned int control_word;
231 
232  //tuning DOWN
233  if(direction==0){
234 
235  tuning_freq=tuning_freq-tuning_step;
236  }
237  //tuning UP
238  if(direction==1){
239 
240  tuning_freq=tuning_freq+tuning_step;
241  }
242  // Write into FREQ0 register
243  if(frequency_register==0){
244 
245  tuning_freq = tuning_freq & 0x7FFF; //0b0111,1111,1111,1111
246  tuning_freq = tuning_freq | 0x4000; //0b0100,0000,0000,0000
247 
248  }
249 
250  // Write into FREQ1 register
251  if(frequency_register==1){
252 
253  tuning_freq = tuning_freq & 0xBFFF; //0b1011,1111,1111,1111
254  tuning_freq = tuning_freq | 0x8000; //0b1000,0000,0000,0000
255 
256  }
257 
258  control_word = AD9833_compose_control_word(8);
259  AD9833_write_data (control_word);
261 
262 }
263 
264 //*********************************************
265 // AD9833_set_phase
266 //*********************************************
267 void AD9833_set_phase (unsigned long phase_value, unsigned char phase_register){
268 
269  unsigned int phase_reg;
270 
271  phase_value=(phase_value*1137)/1000;
272 
273  phase_reg=phase_value;
274 
275  // Write into PHASE0 register
276  if(phase_register==0){
277 
278  phase_reg=phase_reg & 0xFFF; //0b0000111111111111
279  phase_reg=phase_reg | 0xC000; //0b1100000000000000
280  }
281 
282  // Write into PHASE1 register
283  if(phase_register==1){
284 
285  phase_reg=phase_reg & 0xFFF; //0b0000111111111111
286  phase_reg=phase_reg | 0xE000; //0b1110000000000000
287  }
288 
289  AD9833_write_data (phase_reg);
290 
291 }
292 
293 //*********************************************
294 // AD9833_set_function
295 //*********************************************
296 void AD9833_set_function (unsigned char function_type){
297 
298  unsigned int function;
299 
300  switch(function_type){
301 
302  case AD9833_SIN:
303  function = AD9833_compose_control_word(1);
304  AD9833_write_data (function);
305  break;
306 
307  case AD9833_TRIANGLE:
308  function = AD9833_compose_control_word(2);
309  AD9833_write_data (function);
310  break;
311 
312  case AD9833_SQUARE:
313  function = AD9833_compose_control_word(3);
314  AD9833_write_data (function);
315  break;
316 
318  function = AD9833_compose_control_word(4);
319  AD9833_write_data (function);
320  break;
321 
323  function = AD9833_compose_control_word(5);
324  AD9833_write_data (function);
325  break;
326 
327  case AD9833_PHASE0_OUT:
328  function = AD9833_compose_control_word(6);
329  AD9833_write_data (function);
330  break;
331 
332  case AD9833_PHASE1_OUT:
333  function = AD9833_compose_control_word(7);
334  AD9833_write_data (function);
335  break;
336 
337  case AD9833_SLEEP_MODE:
338  function = AD9833_compose_control_word(9);
339  AD9833_write_data (function);
340  break;
341 
342  case AD9833_POWER_ON:
343  function = AD9833_compose_control_word(10);
344  AD9833_write_data (function);
345  break;
346  }
347 }
348 
349 
350 
351