Khởi động cho ch
Vòng lặp chính
t cho máy thu
Hình 56. Giải thuật đề xuất cho máy thu
chế độ thu:
Khởi tạo I/O Khởi động chế độ thu
Thay đổi tham số
Giải điều chế tín hiệu Xử lý tín hiệu tọa Hiển thị thông tin tọa
Thiết lập tham số thu:
Thiết lập bộ giải điều chế tương quan
Để tối ưu hóa độ nhạy thu, dải thông của bộ tách sóng tương quan được tính như sau:
Trong đó:
o DEMOD CLK: là tần số xung clock đưa vào bộ tách sóng o K: hệ số được xác định theo từng sơ đồ giải điều chế Với 2FSK thì:
Với 3FSK:
Với 4FSK:
Thiết lập bộ lọc trước giải điều chế
Từ tần số cắt cần thiết của bộ lọc ta tính được giá trị thiết lập như sau:
Tần số cắt tính theo dải thông 3dB.
o Với 2FSK tần số cắt = 0.75 x tốc độ bit o Với 3FSK tần số cắt = 1 x tốc độ bit
Kết luận
1. Luận văn đã tìm hiểu một cách tổng quan hoạt động của hệ thống thông tin trên biển, đồng thời trình bày cơ sở kỹ thuật siêu cao tần và kỹ thuật phối hợp trở kháng dùng cho thiết kế mạch điện siêu cao tần thu phát UHF.
2. Luận văn trình bày các kết quả thiết kế và mô phỏng các công đoạn thiết kế tuyến thu trong đó có bộ khuếch đại tạp âm thấp UHF.
3. Luận văn đã thiết kế chế tạo đồng bộ hệ thống thu phát băng hẹp dải tần UHF, bao gồm từ bộ khuếch đại cao tần tạp âm thấp, đồng bộ với bộ thu phát tích hợp trên một vi mạch ADF7021. Vi mạch ADF7021 có khả năng thay đổi tần số số làm việc, lựa chọn độ nhạy và công suất phát và có khả năng điều chế số với các loại điều chế khác nhau.
4. Luận văn đã tiến hành đo kiểm, đánh giá các tham số của hệ thống được chế tạo, đáp ứng các yêu cầu sử dụng trong hệ thống thông tin UHF.
5. Luận văn đang từng bước hoàn thiện phần mềm nhúng điều khiển chuyển đổi tần số, chuyển đổi công suất phát và thay đổi phương thức điều chế kết hợp thông tin định vị từ GPS linh hoạt.Chương trình điều khiển ADF7021 viết bằng ngôn ngữ C được trình bày trong phần phụ lục.
Tuy mới chỉ đạt được những kết quả còn rất khiêm tốn nhưng đây là bước đầu quan trọng để em có thêm tự tin tìm hiểu và nâng tầm nghiên cứu trong lĩnh vực thông tin liên lạc.
Việc thực hiện luận văn đã giúp em nắm vững hơn các kiến thức về kỹ thuật siêu cao tần, được sử dụng, tiếp cận những phần mềm, công cụ hiện đại và những module dùng trong các hệ thống thực tế.
TÀI LIỆU THAM KHẢO Tiếng Việt
[1] GS.TSKH Phan Anh. Giáo trình lý thuyết và kỹ thuật siêu cao tần, Bộ môn Thông tin vô tuyến, Khoa Điện tử - Viễn thông, Trường Đại Học Công Nghệ.
[2] GS.TSKH Phan Anh. Trường điện từ và truyền sóng, NXB Đại Học Quốc Gia Hà Nội, Hà Nội.
[3] Ths Vũ Tuấn Anh. Luận văn cao học, Trung tâm nghiên cứu Điện tử - Viễn thông, Trường Đại Học Công Nghệ.
[4] TS Đỗ Trung Kiên, luận án tiến sĩ, bộ môn Vật lý vô tuyến – ĐHKHTN - ĐHQGHN
[5] Giáo trình công nghệ thông tin vệ tinh, Tập đoàn bưu chính viễn thông. [6] Phạm Minh Việt. Kỹ thuật siêu cao tần, NXB Khoa học kỹ thuật, Hà Nội.
[7] PGS.TS Trần Quang Vinh – Ths. Chử Văn An, Nguyên lý kỹ thuật điện tử, NXB giáo dục, Hà Nội.
Tiếng Anh
[8] David M.Pozar, Microwave engineering, John Wiley & Sons, Inc. [9] Guillermo Gonzalez, Microwave transistor amplifiers, Prentice Hall.
[10] W. Alan Davis, Radio Frequency Circuit Design, John Wiley & Sons, Inc.
[11] Kai chang, Encyclopedia of RF and Microwave Enginneering, John Wiley & Sons, Inc.
PHỤ LỤC
Chương trình điều khiển ADF7021 viết bằng ngôn ngữ C
adf7021.h #ifndef _ADF7021_H_ #define _ADF7021_H_
#if defined(BBSTANDARD)
#define ADF_PORT_SWD PORTE #define ADF_PORT_IN_SWD PINE #define ADF_PORT_DIR_SWD DDRE #define ADF_SWD 6
#define ADF_PORT_SCLK PORTC #define ADF_PORT_IN_SCLK PINC #define ADF_PORT_DIR_SCLK DDRC #define ADF_SCLK 7
#define ADF_PORT_SREAD PORTC #define ADF_PORT_IN_SREAD PINC #define ADF_PORT_DIR_SREAD DDRC #define ADF_SREAD 6
#define ADF_PORT_SDATA PORTB #define ADF_PORT_IN_SDATA PINB #define ADF_PORT_DIR_SDATA DDRB #define ADF_SDATA 6
#define ADF_PORT_SLE PORTB #define ADF_PORT_IN_SLE PINB #define ADF_PORT_DIR_SLE DDRB #define ADF_SLE 5
#define ADF_PORT_MUXOUT PORTD #define ADF_PORT_IN_MUXOUT PIND #define ADF_PORT_DIR_MUXOUT DDRD #define ADF_MUXOUT 6
#define ADF_PORT_CE PORTD #define ADF_PORT_IN_CE PIND #define ADF_PORT_DIR_CE DDRD #define ADF_CE 7
#elif defined(BBMICRO)
#define ADF_PORT_SWD PORTB #define ADF_PORT_IN_SWD PINB #define ADF_PORT_DIR_SWD DDRB #define ADF_SWD 5
#define ADF_PORT_DIR_SCLK DDRC #define ADF_SCLK 2
#define ADF_PORT_SREAD PORTC #define ADF_PORT_IN_SREAD PINC #define ADF_PORT_DIR_SREAD DDRC #define ADF_SREAD 4
#define ADF_PORT_SDATA PORTC #define ADF_PORT_IN_SDATA PINC #define ADF_PORT_DIR_SDATA DDRC #define ADF_SDATA 5
#define ADF_PORT_SLE PORTC #define ADF_PORT_IN_SLE PINC #define ADF_PORT_DIR_SLE DDRC #define ADF_SLE 6
#define ADF_PORT_MUXOUT PORTD #define ADF_PORT_IN_MUXOUT PIND #define ADF_PORT_DIR_MUXOUT DDRD #define ADF_MUXOUT 1
#define ADF_PORT_CE PORTD #define ADF_PORT_IN_CE PIND #define ADF_PORT_DIR_CE DDRD #define ADF_CE 5 #endif typedefunion { unsignedlong whole_reg; struct{ unsignedint lower; unsignedint upper; } word; unsignedchar byte[4]; } adf_reg_t; typedefstruct{ struct{ double data_rate; double mod_index; unsignedlong freq; } desired; struct{ double data_rate; double mod_index; unsignedlong freq; unsignedint freq_dev; } real; union{ adf_reg_t r0_reg; struct{ unsignedchar address_bits :4; unsignedint frac_n :15; unsignedint int_n :8; unsignedchar rx_on :1; unsignedchar uart_mode :1; unsignedchar muxout :3; } r0; };
union{ adf_reg_t r2_reg; struct{ unsignedchar address_bits :4; unsignedchar modulation_scheme :3; unsignedchar pa_enable :1; unsignedchar pa_ramp :3; unsignedchar pa_bias :2; unsignedchar power_amplifier :6; unsignedint tx_frequency_deviation :9; unsignedchar tx_data_invert :2; unsignedchar rcosine_alpha :1; } r2; }; union{ adf_reg_t r3_reg; struct{ unsignedchar address_bits :4; unsignedchar bbos_clk_divide:2; unsignedchar dem_clk_divide :4; unsignedchar cdr_clk_divide :8; unsignedchar seq_clk_divide :8; unsignedchar agc_clk_divide :6; } r3; }; union{ adf_reg_t r4_reg; struct{ unsignedchar address_bits :4; unsignedchar demod_scheme :3; unsignedchar dot_product :1; unsignedchar rx_invert :2; unsignedint disc_bw :10; unsignedint post_demod_bw :10; unsignedchar if_bw :2; } r4; }; union{ adf_reg_t r5_reg; struct{ unsignedchar address_bits :4; unsignedchar if_cal_coarse :1; unsignedint if_filter_divider :9; unsignedchar if_filter_adjust :6; unsignedchar ir_phase_adjust_mag :4; unsignedchar ir_phase_adjust_direction :1; unsignedchar ir_gain_adjust_mac :5; unsignedchar ir_gain_adjust_iq :1; unsignedchar ir_gain_adjust_updn :1; } r5; }; union{ adf_reg_t r6_reg; struct{ unsignedchar address_bits :4; unsignedchar if_fine_cal :1; unsignedchar if_cal_lower_tone :8; unsignedchar if_cal_upper_tone :8; unsignedchar if_cal_dwell_time :7; unsignedchar ir_cal_source_drive :2; unsignedchar ir_cal_source_div_2 :1;
}; } adf_conf_t; typedefstruct{ unsignedlong adf_xtal; union{ adf_reg_t r1_reg; struct{ unsignedchar address_bits :4; unsignedchar r_counter :3; unsignedchar clockout_divide :4; unsignedchar xtal_doubler :1; unsignedchar xosc_enable :1; unsignedchar xtal_bias :2; unsignedchar cp_current :2; unsignedchar vco_enable :1; unsignedchar rf_divide_by_2 :1; unsignedchar vco_bias :4; unsignedchar vco_adjust :2; unsignedchar vco_inductor :1; } r1; }; union{ adf_reg_t r10_reg; struct{ unsignedchar address_bits :4; unsignedchar afc_en :1; unsignedint afc_scaling_factor :12; unsignedchar ki :4; unsignedchar kp :3; unsignedchar afc_range :8; } r10; }; union{ adf_reg_t r12_reg; struct{ unsignedchar address_bits :4; unsignedchar lock_thres_mode :2; unsignedchar swd_mode :2; unsignedchar packet_length :8; } r12; }; union{ adf_reg_t r14_reg; struct{ unsignedchar address_bits :4; unsignedchar test_tdac_en :1; unsignedint test_dac_offset :16; unsignedchar test_dac_gain :4; unsignedchar pulse_ext :2; unsignedchar leak_factor :3; unsignedchar ed_peak_resp :2; } r14; }; union{ adf_reg_t r15_reg; struct{ unsignedchar address_bits :4; unsignedchar rx_test_mode :4; unsignedchar tx_test_mode :3; unsignedchar sd_test_mode :3; unsignedchar cp_test_mode :3;
unsignedchar clk_mux :3; unsignedchar pll_test_mode :4; unsignedchar analog_test_mode :4; unsignedchar force_ld_high :1; unsignedchar reg1_pd :1; unsignedchar cal_override :2; } r15; }; } adf_sysconf_t;
void adf_write_reg(adf_reg_t *reg);
adf_reg_t adf_read_reg(unsignedint readback_config);
void adf_set_power_on(unsignedlong adf_xtal);
void adf_set_power_off(void);
void adf_init_rx_mode(unsignedint data_rate, uint8_t mod_index,unsignedlong freq, uint8_t if_bw);
void adf_init_tx_mode(unsignedint data_rate, uint8_t mod_index,unsignedlong freq);
void adf_set_rx_mode(void);
void adf_set_tx_mode(void);
void adf_afc_on(unsignedchar range,unsignedchar ki,unsignedchar kp);
void adf_afc_off(void);
void adf_set_tx_power(char pasetting);
#define ADF_SYNC_WORD_LEN_12 0 #define ADF_SYNC_WORD_LEN_16 1 #define ADF_SYNC_WORD_LEN_20 2 #define ADF_SYNC_WORD_LEN_24 3 #define ADF_SYNC_WORD_ERROR_TOLERANCE_0 0 #define ADF_SYNC_WORD_ERROR_TOLERANCE_1 1 #define ADF_SYNC_WORD_ERROR_TOLERANCE_2 2 #define ADF_SYNC_WORD_ERROR_TOLERANCE_3 3 void adf_set_rx_sync_word(unsignedlong word,unsignedchar len,unsignedchar error_tolerance); void adf_set_threshold_free(void); #define ADF_TEST_TX_MODE_CARRIER_ONLY 1 #define ADF_TEST_TX_MODE_TONE_HIGH 2 #define ADF_TEST_TX_MODE_TONE_LOW 3 #define ADF_TEST_TX_MODE_PATTERN_1010 4 #define ADF_TEST_TX_MODE_PATTERN_PN9 5 #define ADF_TEST_TX_MODE_SYNC_BYTE 6
void adf_test_tx(int mode);
void adf_test_off(void);
unsignedint adf_readback_version(void);
signedint adf_readback_rssi(void);
signedint adf_readback_afc(void);
signedint adf_readback_temp(void);
float adf_readback_voltage(void);
void adf_configure(void);
void adf_reset(void);
adf7021.c #include <math.h> #include <stdio.h> #include <stdlib.h> #include <interrupt.h> #include "adf7021.h" #include "main.h" #include "ptt.h" #include "led.h"
static adf_conf_t rx_conf, tx_conf;
static adf_sysconf_t sys_conf;
static uint32_t adf_current_syncword;
externstruct bluebox_config conf;
enum{ ADF_OFF, ADF_ON, ADF_TX, ADF_RX } adf_state; enum{ ADF_PA_OFF, ADF_PA_ON } adf_pa_state;
void adf_write_reg(adf_reg_t *reg) {
signedchar i, j;
unsignedchar byte;
ADF_PORT_SLE &=~_BV(ADF_SLE);
ADF_PORT_SCLK &=~_BV(ADF_SCLK);
/* Clock data out MSbit first */
for(i =3; i >=0; i--){
byte= reg->byte[i];
for(j =8; j >0; j--){
ADF_PORT_SCLK &=~_BV(ADF_SCLK);
if(byte &0x80)
ADF_PORT_SDATA |= _BV(ADF_SDATA);
else
ADF_PORT_SDATA &=~_BV(ADF_SDATA);
ADF_PORT_SCLK |= _BV(ADF_SCLK);
byte+= byte; }
ADF_PORT_SCLK &=~_BV(ADF_SCLK); }
/* Strobe the latch */
ADF_PORT_SLE |= _BV(ADF_SLE);
ADF_PORT_SLE |= _BV(ADF_SLE);
ADF_PORT_SDATA &=~_BV(ADF_SDATA);
ADF_PORT_SDATA &=~_BV(ADF_SLE); }
adf_reg_t adf_read_reg(unsignedint readback_config) {
adf_reg_t register_value;
signedchar i, j;
/* Write readback and ADC control value */
register_value.whole_reg =((readback_config &0x1F)<<4);
/* Address the readback setup register */ register_value.whole_reg |=7;
adf_write_reg(®ister_value);
register_value.whole_reg =0;
/* Read back value */
ADF_PORT_SDATA &=~_BV(ADF_SDATA);
ADF_PORT_SCLK &=~_BV(ADF_SCLK);
ADF_PORT_SLE |= _BV(ADF_SLE);
/* Clock in first bit and discard (DB16 is not used) */ ADF_PORT_SCLK |= _BV(ADF_SCLK);
unsignedchar byte =0;
ADF_PORT_SCLK &=~_BV(ADF_SCLK);
/* Clock in data MSbit first */
for(i=1; i>=0; i--){
for(j=8; j>0; j--){
ADF_PORT_SCLK |= _BV(ADF_SCLK);
byte+= byte;
if(ADF_PORT_IN_SREAD & _BV(ADF_SREAD))
byte|=1;
ADF_PORT_SCLK &=~_BV(ADF_SCLK); }
register_value.byte[i]= byte; }
ADF_PORT_SCLK |= _BV(ADF_SCLK);
ADF_PORT_SLE &=~_BV(ADF_SLE);
ADF_PORT_SCLK &=~_BV(ADF_SCLK);
return register_value; }
void adf_set_power_on(unsignedlong adf_xtal) {
/* Store locally the oscillator frequency */ sys_conf.adf_xtal = adf_xtal;
/* Ensure the ADF GPIO port is correctly initialised */ ADF_PORT_DIR_SWD &=~_BV(ADF_SWD);
ADF_PORT_DIR_SCLK |= _BV(ADF_SCLK);
ADF_PORT_DIR_SREAD &=~_BV(ADF_SREAD);
ADF_PORT_DIR_SDATA |= _BV(ADF_SDATA);
ADF_PORT_DIR_SLE |= _BV(ADF_SLE);
ADF_PORT_DIR_MUXOUT &=~_BV(ADF_MUXOUT);
ADF_PORT_DIR_CE |= _BV(ADF_CE);
ADF_PORT_CE |= _BV(ADF_CE);
/* write R1, Turn on Internal VCO */ sys_conf.r1.address_bits =1;
sys_conf.r1.xtal_doubler =0; sys_conf.r1.xosc_enable =1; sys_conf.r1.xtal_bias =3; sys_conf.r1.cp_current =3; sys_conf.r1.vco_enable =1; sys_conf.r1.rf_divide_by_2 =1; sys_conf.r1.vco_bias =15; sys_conf.r1.vco_adjust =1; sys_conf.r1.vco_inductor =0;
adf_write_reg(&sys_conf.r1_reg);
/* write R15, set CLK_MUX to enable SPI */ sys_conf.r15.address_bits =15; sys_conf.r15.rx_test_mode =0; sys_conf.r15.tx_test_mode =0; sys_conf.r15.sd_test_mode =0; sys_conf.r15.cp_test_mode =0; sys_conf.r15.clk_mux =7; sys_conf.r15.pll_test_mode =0; sys_conf.r15.analog_test_mode =0; sys_conf.r15.force_ld_high =0; sys_conf.r15.reg1_pd =0; sys_conf.r15.cal_override =0;
adf_write_reg(&sys_conf.r15_reg);
/* write R14, enable test DAC */ sys_conf.r14.address_bits =14; sys_conf.r14.test_tdac_en =0; sys_conf.r14.test_dac_offset =0; sys_conf.r14.test_dac_gain =0; sys_conf.r14.pulse_ext =0; sys_conf.r14.leak_factor =0; sys_conf.r14.ed_peak_resp =0;
adf_write_reg(&sys_conf.r14_reg);
adf_state = ADF_ON;
adf_pa_state = ADF_PA_OFF; }
void adf_set_power_off() {
/* Turn off chip enable */ ADF_PORT_CE &=~_BV(ADF_CE);
adf_state = ADF_OFF;
adf_pa_state = ADF_PA_OFF; }
void adf_find_clocks(adf_conf_t *conf) {
/* Find desired F.dev. */
unsignedchar tx_freq_dev =(unsignedchar) round(((double)conf-
>desired.mod_index *0.5* conf->desired.data_rate *65536.0)/(0.5*
sys_conf.adf_xtal));
double freq_dev =(tx_freq_dev * sys_conf.adf_xtal)/65536.0;
/* Find K */
unsignedint k = round(100000/(freq_dev));
/* Run a variable optimisation for Demod clock divider */
int i_dem;
double demod_clk, data_rate_real;
unsignedint cdr_clk_divide, disc_bw;
for(i_dem =1; i_dem <15; i_dem++){
demod_clk =(double) sys_conf.adf_xtal / i_dem;
disc_bw =round((k * demod_clk)/400000);
cdr_clk_divide =round(demod_clk /((double)conf->desired.data_rate
*32));
if(disc_bw >660)
continue;
if(cdr_clk_divide >255)
continue;
data_rate_real =(sys_conf.adf_xtal /((double) i_dem *(double)
cdr_clk_divide *32.0));
residual= abs((unsignedint) data_rate_real - conf->desired.data_rate);
/* Search for a new winner */
if(w_residual > residual){
w_residual = residual;
conf->r3.dem_clk_divide = i_dem; }
}
/* Demodulator clock */
demod_clk =(double) sys_conf.adf_xtal / conf->r3.dem_clk_divide;
/* CDR clock */
conf->r3.cdr_clk_divide =(unsignedint) round(demod_clk /((double)conf- >desired.data_rate *32));
/* Data rate and freq. deviation */
conf->real.data_rate =(sys_conf.adf_xtal /((double) conf->r3.dem_clk_divide
*(double) conf->r3.cdr_clk_divide *32.0));
conf->real.freq_dev =(unsignedchar) round(((double)conf->desired.mod_index
*0.5* conf->real.data_rate *65536.0)/(0.5* sys_conf.adf_xtal));
/* Discriminator bandwidth */
conf->r4.disc_bw = round((k * demod_clk)/400000);
/* Post demodulation bandwidth */
conf->r4.post_demod_bw = round(((conf->real.data_rate
*0.75)*3.141592654*2048.0)/ demod_clk); /* K odd or even */ if(k &1){ if(((k +1)/2)&1){ conf->r4.rx_invert =2; conf->r4.dot_product =1; }else{ conf->r4.rx_invert =0; conf->r4.dot_product =1; } }else{ if((k /2)&1){ conf->r4.rx_invert =2; conf->r4.dot_product =0; }else{
conf->r4.dot_product =0; }
} }
void adf_init_rx_mode(unsignedint data_rate, uint8_t mod_index,unsignedlong freq, uint8_t if_bw)
{
/* Calculate the RX clocks */
rx_conf.desired.data_rate = data_rate;
rx_conf.desired.mod_index = mod_index;
rx_conf.desired.freq = freq;
adf_find_clocks(&rx_conf);
/* Setup RX Clocks */
rx_conf.r3.seq_clk_divide =round(sys_conf.adf_xtal /100000.0);
rx_conf.r3.agc_clk_divide =round((rx_conf.r3.seq_clk_divide *
sys_conf.adf_xtal)/10000.0);
rx_conf.r3.bbos_clk_divide =2;// 16 rx_conf.r3.address_bits =3;
/* IF filter calibration */
rx_conf.r5.if_filter_divider =(sys_conf.adf_xtal /50000);
rx_conf.r5.if_cal_coarse =1;
rx_conf.r5.address_bits =5;
/* write R0, turn on PLL */
double n =((freq-100000)/(sys_conf.adf_xtal *0.5));
unsignedlong n_int = floor(n);
unsignedlong n_frac = round((n - floor(n))*32768);
rx_conf.r0.rx_on =1;
rx_conf.r0.uart_mode =1;
rx_conf.r0.muxout =2;
rx_conf.r0.int_n = n_int;
rx_conf.r0.frac_n = n_frac;
rx_conf.r0.address_bits =0;
/* write R4, turn on demodulation */ rx_conf.r4.demod_scheme =1;
rx_conf.r4.if_bw = if_bw;// 0 = 12.5, 1 = 18.75, 2 = 25 KHz rx_conf.r4.address_bits =4;
}
void adf_init_tx_mode(unsignedint data_rate, uint8_t mod_index,unsignedlong freq)
{
/* Calculate the RX clocks */
tx_conf.desired.data_rate = data_rate;
tx_conf.desired.mod_index = mod_index;
tx_conf.desired.freq = freq;
adf_find_clocks(&tx_conf);
/* Setup default R3 values */
tx_conf.r3.seq_clk_divide =round(sys_conf.adf_xtal /100000.0);
tx_conf.r3.agc_clk_divide =round((tx_conf.r3.seq_clk_divide *
sys_conf.adf_xtal)/10000.0);
tx_conf.r3.bbos_clk_divide =2;// 16 tx_conf.r3.address_bits =3;
/* write R0, turn on PLL */
unsignedlong n_int = floor(n);
unsignedlong n_frac = round((n - floor(n))*32768);
tx_conf.r0.rx_on =0;
tx_conf.r0.uart_mode =1;
tx_conf.r0.muxout =2;
tx_conf.r0.int_n = n_int;
tx_conf.r0.frac_n = n_frac;
tx_conf.r0.address_bits =0;
/* Set the calcualted frequency deviation */
tx_conf.r2.tx_frequency_deviation = tx_conf.real.freq_dev;
/* Set PA and modulation type */
tx_conf.r2.power_amplifier = conf.pa_setting;// 0 = OFF, 63 = MAX (WARNING NON LINEAR)
tx_conf.r2.pa_bias =3;// 0 = 5uA, 1 = 7uA, 2 = 9uA, 3 = 11 uA tx_conf.r2.pa_ramp =7;// 0 = OFF, 1 = LOWEST, 7 = HIGHEST tx_conf.r2.pa_enable =1;// 0 = OFF, 1 = ON
tx_conf.r2.modulation_scheme =1;// 0 = FSK, 1 = GFSK, 5 = RCFSK tx_conf.r2.address_bits =2;
/* Ensure rewrite of PA register */ adf_pa_state = ADF_PA_OFF; }
void adf_afc_on(unsignedchar range,unsignedchar ki,unsignedchar kp) {
/* write R10, turn AFC on */ sys_conf.r10.afc_en =1;
sys_conf.r10.afc_scaling_factor =524;/* (2^24 * 500 / XTAL_FREQ) */ sys_conf.r10.ki = ki;
sys_conf.r10.kp =kp;
sys_conf.r10.afc_range = range;
sys_conf.r10.address_bits =10;
adf_write_reg(&sys_conf.r10_reg); }
void adf_afc_off(void) {
sys_conf.r10.afc_en =0;
adf_write_reg(&sys_conf.r10_reg); }
void adf_set_tx_power(char pasetting) {
tx_conf.r2.power_amplifier = pasetting;
adf_write_reg(&tx_conf.r2_reg); }
void adf_set_rx_sync_word(unsignedlong word,unsignedchar len,unsignedchar error_tolerance)
{
adf_reg_t register_value;
/* write R11, configure sync word detect */ adf_current_syncword = word;
register_value.whole_reg =11;
register_value.whole_reg |= word <<8;
register_value.whole_reg |= error_tolerance <<6;
/* write R12, start sync word detect */ adf_set_threshold_free();
}
void adf_set_threshold_free(void) {
/* write R12, start sync word detect */ sys_conf.r12.packet_length =255;
sys_conf.r12.swd_mode =1;
sys_conf.r12.lock_thres_mode =1;
sys_conf.r12.address_bits =12;
adf_write_reg(&sys_conf.r12_reg); }
void adf_set_rx_mode(void) {
if(adf_state == ADF_TX){
if(rx_conf.r3_reg.whole_reg != tx_conf.r3_reg.whole_reg)
adf_write_reg(&rx_conf.r3_reg);
adf_write_reg(&rx_conf.r0_reg); }else{
adf_write_reg(&rx_conf.r3_reg);
adf_write_reg(&rx_conf.r5_reg);
adf_write_reg(&rx_conf.r0_reg);
adf_write_reg(&rx_conf.r4_reg); }
led_off(LED_TRANSMIT);
ptt_low(conf.ptt_delay_low);
adf_state = ADF_RX; }
void adf_set_tx_mode(void) {
/* Turn on PA the first time we transmit */
if(adf_pa_state == ADF_PA_OFF){
adf_write_reg(&tx_conf.r2_reg);
adf_pa_state = ADF_PA_ON; }
ptt_high(conf.ptt_delay_high);
led_on(LED_TRANSMIT);
if(adf_state == ADF_RX){
if(rx_conf.r3_reg.whole_reg != tx_conf.r3_reg.whole_reg)
adf_write_reg(&tx_conf.r3_reg);
adf_write_reg(&tx_conf.r0_reg); }else{
adf_write_reg(&tx_conf.r3_reg);
adf_write_reg(&tx_conf.r0_reg); }
adf_state = ADF_TX; }
unsignedint adf_readback_version(void)
{
adf_reg_t readback = adf_read_reg(0x1C);
return readback.word.lower; }
signedint adf_readback_rssi(void) {
unsignedchar gain_correction[]={86,0,0,0,58,38,24,0,0,0,0,0,0,0,0,0};
adf_reg_t readback = adf_read_reg(0x14);
char rssi = readback.byte[0]&0x7F;
int gc =(readback.word.lower &0x780)>>7;
double dbm =((rssi + gain_correction[gc])*0.5)-130;
return round(dbm); }
int adf_readback_afc(void) {
adf_reg_t readback = adf_read_reg(0x10);
return100000- round(readback.word.lower *((uint32_t)XTAL_FREQ >>18)); }
signedint adf_readback_temp(void)
{
/* Enable ADC */
adf_reg_t register_value;
register_value.whole_reg =8;
register_value.whole_reg &=1<<8;
adf_reg_t readback = adf_read_reg(0x16);
return round(-40+((68.4-(readback.byte[0]&0x7F))*9.32)); }
float adf_readback_voltage(void)
{
/* Enable ADC */
adf_reg_t register_value;
register_value.whole_reg =8;
register_value.whole_reg &=1<<8;
adf_write_reg(®ister_value);
adf_reg_t readback = adf_read_reg(0x15);
return(readback.byte[0]&0x7F)/21.1; }
void adf_test_tx(int mode) {
adf_reg_t register_value;
register_value.whole_reg =15;
register_value.whole_reg |= mode <<8;
adf_write_reg(®ister_value); }
void adf_test_off(void) {
adf_reg_t register_value;
register_value.whole_reg =15;
adf_write_reg(®ister_value);
adf_state = ADF_RX; }
void adf_configure(void) {
adf_init_rx_mode(conf.bitrate, conf.modindex, conf.rx_freq,
conf.if_bw);
adf_init_tx_mode(conf.bitrate, conf.modindex, conf.tx_freq);
adf_afc_on(conf.afc_range, conf.afc_ki, conf.afc_kp);
adf_set_rx_mode(); }
void adf_reset(void) { adf_test_off(); adf_set_power_off(); delay_ms(100); adf_set_power_on(XTAL_FREQ); adf_configure(); }