1 |
/******************************************************************** |
1 |
/******************************************************************** |
2 |
FileName: user.c |
2 |
FileName: user.c |
3 |
Dependencies: See INCLUDES section |
3 |
Dependencies: See INCLUDES section |
4 |
Processor: PIC18 or PIC24 USB Microcontrollers |
4 |
Processor: PIC18 or PIC24 USB Microcontrollers |
5 |
Hardware: The code is natively intended to be used on the following |
5 |
Hardware: The code is natively intended to be used on the following |
6 |
hardware platforms: PICDEM FS USB Demo Board, |
6 |
hardware platforms: PICDEM FS USB Demo Board, |
7 |
PIC18F87J50 FS USB Plug-In Module, or |
7 |
PIC18F87J50 FS USB Plug-In Module, or |
8 |
Explorer 16 + PIC24 USB PIM. The firmware may be |
8 |
Explorer 16 + PIC24 USB PIM. The firmware may be |
9 |
modified for use on other USB platforms by editing the |
9 |
modified for use on other USB platforms by editing the |
10 |
HardwareProfile.h file. |
10 |
HardwareProfile.h file. |
11 |
Complier: Microchip C18 (for PIC18) or C30 (for PIC24) |
11 |
Complier: Microchip C18 (for PIC18) or C30 (for PIC24) |
12 |
* Company: Microchip Technology, Inc. |
12 |
* Company: Microchip Technology, Inc. |
13 |
* |
13 |
* |
14 |
* Software License Agreement |
14 |
* Software License Agreement |
15 |
|
15 |
|
16 |
The software supplied herewith by Microchip Technology Incorporated |
16 |
The software supplied herewith by Microchip Technology Incorporated |
17 |
(the Company) for its PIC® Microcontroller is intended and |
17 |
(the Company) for its PIC® Microcontroller is intended and |
18 |
supplied to you, the Companys customer, for use solely and |
18 |
supplied to you, the Companys customer, for use solely and |
19 |
exclusively on Microchip PIC Microcontroller products. The |
19 |
exclusively on Microchip PIC Microcontroller products. The |
20 |
software is owned by the Company and/or its supplier, and is |
20 |
software is owned by the Company and/or its supplier, and is |
21 |
protected under applicable copyright laws. All rights are reserved. |
21 |
protected under applicable copyright laws. All rights are reserved. |
22 |
* Any use in violation of the foregoing restrictions may subject the |
22 |
* Any use in violation of the foregoing restrictions may subject the |
23 |
* user to criminal sanctions under applicable laws, as well as to |
23 |
* user to criminal sanctions under applicable laws, as well as to |
24 |
* civil liability for the breach of the terms and conditions of this |
24 |
* civil liability for the breach of the terms and conditions of this |
25 |
* license. |
25 |
* license. |
26 |
* |
26 |
* |
27 |
* THIS SOFTWARE IS PROVIDED IN AN AS IS CONDITION. NO WARRANTIES, |
27 |
* THIS SOFTWARE IS PROVIDED IN AN AS IS CONDITION. NO WARRANTIES, |
28 |
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED |
28 |
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED |
29 |
* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A |
29 |
* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A |
30 |
* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, |
30 |
* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT, |
31 |
* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR |
31 |
* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR |
32 |
CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. |
32 |
CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. |
33 |
|
33 |
|
34 |
******************************************************************** |
34 |
******************************************************************** |
35 |
File Description: |
35 |
File Description: |
36 |
|
36 |
|
37 |
Change History: |
37 |
Change History: |
38 |
Rev Date Description |
38 |
Rev Date Description |
39 |
1.0 11/19/2004 Initial release |
39 |
1.0 11/19/2004 Initial release |
40 |
2.1 02/26/2007 Updated for simplicity and to use common |
40 |
2.1 02/26/2007 Updated for simplicity and to use common |
41 |
coding style |
41 |
coding style |
42 |
********************************************************************/ |
42 |
********************************************************************/ |
43 |
|
43 |
|
44 |
/** INCLUDES *******************************************************/ |
44 |
/** INCLUDES *******************************************************/ |
45 |
#include "usb.h" |
45 |
#include "usb.h" |
46 |
|
46 |
|
47 |
#include "HardwareProfile.h" |
47 |
#include "HardwareProfile.h" |
48 |
#include "user.h" |
48 |
#include "user.h" |
49 |
#include "usbavrcmd.h" |
49 |
#include "usbavrcmd.h" |
50 |
#include <math.h> |
50 |
#include <math.h> |
51 |
#include <stdlib.h> |
51 |
#include <stdlib.h> |
52 |
#include <string.h> |
52 |
#include <string.h> |
53 |
#include <ctype.h> |
53 |
#include <ctype.h> |
54 |
|
54 |
|
55 |
#if defined(__18CXX) |
55 |
#if defined(__18CXX) |
56 |
#include <delays.h> |
56 |
#include <delays.h> |
57 |
#include <i2c.h> |
57 |
#include <i2c.h> |
58 |
#include <eep.h> |
58 |
#include <eep.h> |
59 |
#elif defined(__PIC32MX__) |
59 |
#elif defined(__PIC32MX__) |
60 |
#include <peripheral/i2c.h> |
60 |
#include <peripheral/i2c.h> |
61 |
#include <dee_emulation/dee_emulation_pic32.h> |
61 |
#include <dee_emulation/dee_emulation_pic32.h> |
62 |
#endif |
62 |
#endif |
63 |
|
63 |
|
64 |
#if defined (UBW) |
64 |
#if defined (UBW) |
65 |
#pragma romdata dataEEPROM=0xF00000 |
65 |
#pragma romdata dataEEPROM=0xF00000 |
66 |
// F_CAL_DONE, 4 bytes cal data, F_INIT_FREQ, 4 bytes freq, F_SMOOTH, 2 bytes |
66 |
// F_CAL_DONE, 4 bytes cal data, F_INIT_FREQ, 4 bytes freq, F_SMOOTH, 2 bytes |
67 |
// F_SUB_MUL, 4 bytes sub and 4 bytes mul |
67 |
// F_SUB_MUL, 4 bytes sub and 4 bytes mul |
68 |
// F_CROSS_OVER, 16 bytes or 8 words of 7 cross over points and 1 flag for BPF |
68 |
// F_CROSS_OVER, 16 bytes or 8 words of 7 cross over points and 1 flag for BPF |
69 |
// followed by 16 bytes or 8 words of 7 cross over points and 1 flag for LPF |
69 |
// followed by 16 bytes or 8 words of 7 cross over points and 1 flag for LPF |
70 |
// F_BLINK_LED, 1 byte boolean |
70 |
// F_BLINK_LED, 1 byte boolean |
71 |
rom unsigned char init_data[] = {0xff, 0,0,0,0, 0xff, 0,0,0,0, 0xff, 0,0, |
71 |
rom unsigned char init_data[] = {0xff, 0,0,0,0, 0xff, 0,0,0,0, 0xff, 0,0, |
72 |
0xff, 0,0,0,0,0,0,0,0, |
72 |
0xff, 0,0,0,0,0,0,0,0, |
73 |
0xff, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, |
73 |
0xff, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, |
74 |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
74 |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
75 |
TRUE}; |
75 |
TRUE}; |
76 |
#endif |
76 |
#endif |
77 |
|
77 |
|
78 |
/** V A R I A B L E S ********************************************************/ |
78 |
/** V A R I A B L E S ********************************************************/ |
79 |
#pragma udata |
79 |
#pragma udata |
80 |
BYTE old_SW; |
80 |
BYTE old_SW; |
81 |
|
81 |
|
82 |
|
82 |
|
83 |
BYTE i2c_adr; |
83 |
BYTE i2c_adr; |
84 |
BYTE command; |
84 |
BYTE command; |
85 |
BYTE replybuf[8]; |
85 |
BYTE replybuf[8]; |
86 |
WORD wCount; |
86 |
WORD wCount; |
87 |
BYTE abpf_flag; |
87 |
BYTE abpf_flag; |
88 |
|
88 |
|
89 |
COMMAND_BUFFER_t command_buffer[COMMAND_BUFFER_SIZE]; |
89 |
COMMAND_BUFFER_t command_buffer[COMMAND_BUFFER_SIZE]; |
90 |
BYTE current_command_in, current_command_out; |
90 |
BYTE current_command_in, current_command_out; |
91 |
BYTE command_count; |
91 |
BYTE command_count; |
92 |
|
92 |
|
93 |
avr_freq_t avr_freq, fcryst_freq; // avr freq [MHz]*2^21 |
93 |
avr_freq_t avr_freq, fcryst_freq; // avr freq [MHz]*2^21 |
94 |
// fcryst freq [Mhz]*2^24 |
94 |
// fcryst freq [Mhz]*2^24 |
95 |
unsigned short R137, R135 = 0; |
95 |
unsigned short R137, R135 = 0; |
96 |
unsigned char registers[6]; |
96 |
unsigned char registers[6]; |
97 |
unsigned char tempBuf[8]; |
97 |
unsigned char tempBuf[8]; |
98 |
unsigned char counter; |
98 |
unsigned char counter; |
99 |
double delta_rfreq; |
99 |
double delta_rfreq; |
100 |
double rfreq, Old_rfreq; |
100 |
double rfreq, Old_rfreq; |
101 |
double fcryst_double, Old_freq_double, Smooth_double; |
101 |
double fcryst_double, Old_freq_double, Smooth_double; |
102 |
|
102 |
|
103 |
double set_frequency; |
103 |
double set_frequency; |
104 |
avr_freq_t f_mul; |
104 |
avr_freq_t f_mul; |
105 |
offset_t f_sub; |
105 |
offset_t f_sub; |
106 |
unsigned char validCombo; |
106 |
unsigned char validCombo; |
107 |
|
107 |
|
108 |
|
108 |
|
109 |
|
109 |
|
110 |
#if defined(__18F14K50) || defined(__18F13K50) || defined(__18LF14K50) || defined(__18LF13K50) |
110 |
#if defined(__18F14K50) || defined(__18F13K50) || defined(__18LF14K50) || defined(__18LF13K50) |
111 |
#pragma udata usbram2 |
111 |
#pragma udata usbram2 |
112 |
#elif defined(__18F2455) || defined(__18F2550) || defined(__18F4455) || defined(__18F4550)\ |
112 |
#elif defined(__18F2455) || defined(__18F2550) || defined(__18F4455) || defined(__18F4550)\ |
113 |
|| defined(__18F4450) || defined(__18F2450)\ |
113 |
|| defined(__18F4450) || defined(__18F2450)\ |
114 |
|| defined(__18F2458) || defined(__18F2453) || defined(__18F4558) || defined(__18F4553) |
114 |
|| defined(__18F2458) || defined(__18F2453) || defined(__18F4558) || defined(__18F4553) |
115 |
#pragma udata USB_VARIABLES=0x500 |
115 |
#pragma udata USB_VARIABLES=0x500 |
116 |
#else |
116 |
#else |
117 |
#pragma udata |
117 |
#pragma udata |
118 |
#endif |
118 |
#endif |
119 |
|
119 |
|
120 |
|
120 |
|
121 |
#pragma udata |
121 |
#pragma udata |
122 |
|
122 |
|
123 |
BOOL blinkStatusValid = TRUE; |
123 |
BOOL blinkStatusValid = TRUE; |
124 |
|
124 |
|
125 |
|
125 |
|
126 |
/** P R I V A T E P R O T O T Y P E S ***************************************/ |
126 |
/** P R I V A T E P R O T O T Y P E S ***************************************/ |
127 |
|
127 |
|
128 |
void BlinkUSBStatus(void); |
128 |
void BlinkUSBStatus(void); |
129 |
BOOL SwitchIsPressed(void); |
129 |
BOOL SwitchIsPressed(void); |
130 |
void ServiceRequests(void); |
130 |
void ServiceRequests(void); |
131 |
|
131 |
|
132 |
|
132 |
|
133 |
|
133 |
|
134 |
|
134 |
|
135 |
|
135 |
|
136 |
/** D E C L A R A T I O N S **************************************************/ |
136 |
/** D E C L A R A T I O N S **************************************************/ |
137 |
#pragma code |
137 |
#pragma code |
138 |
|
138 |
|
139 |
float Cross2Switch(WORD_VAL val){ // convert from 11.5 bit format in [Mhz] |
139 |
float Cross2Switch(WORD_VAL val){ // convert from 11.5 bit format in [Mhz] |
140 |
float whole, fraction; |
140 |
float whole, fraction; |
141 |
whole = (float) (val.Val >> 5); |
141 |
whole = (float) (val.Val >> 5); |
142 |
fraction = ((float) (val.Val & 0x001f)) / 32.0; |
142 |
fraction = ((float) (val.Val & 0x001f)) / 32.0; |
143 |
return (whole + fraction); |
143 |
return (whole + fraction); |
144 |
} |
144 |
} |
145 |
|
145 |
|
146 |
WORD_VAL Switch2Cross(float val){ // convert from float to 11.5 bit format [Mhz] |
146 |
WORD_VAL Switch2Cross(float val){ // convert from float to 11.5 bit format [Mhz] |
147 |
WORD_VAL w; |
147 |
WORD_VAL w; |
148 |
unsigned int i; |
148 |
unsigned int i; |
149 |
i = val; |
149 |
i = val; |
150 |
w.Val = i * 32.0; |
150 |
w.Val = i * 32.0; |
151 |
w.Val += (val - (float) i) * 32.0; |
151 |
w.Val += (val - (float) i) * 32.0; |
152 |
return (w); |
152 |
return (w); |
153 |
} |
153 |
} |
154 |
|
154 |
|
155 |
|
155 |
|
156 |
void UserInit(void) |
156 |
void UserInit(void) |
157 |
{ |
157 |
{ |
158 |
WORD_VAL w; |
158 |
WORD_VAL w; |
159 |
|
159 |
|
160 |
//#if defined (UBW) |
160 |
//#if defined (UBW) |
161 |
// unsigned char i; |
161 |
// unsigned char i; |
162 |
//#elif |
162 |
//#elif |
163 |
unsigned int i; |
163 |
unsigned int i; |
164 |
unsigned int value; |
164 |
unsigned int value; |
165 |
//#endif |
165 |
//#endif |
166 |
|
166 |
|
167 |
#if defined(UBW) |
167 |
#if defined(UBW) |
168 |
// Port A - RA0 BPF_S0, RA1 BPF_S1, RA2 RXTX, RA3-5 LPF0-2 |
168 |
// Port A - RA0 BPF_S0, RA1 BPF_S1, RA2 RXTX, RA3-5 LPF0-2 |
169 |
LATA = 0x00; |
169 |
LATA = 0x00; |
170 |
TRISA = 0x00; // 00000000 |
170 |
TRISA = 0x00; // 00000000 |
171 |
|
171 |
|
172 |
// Turn all analog inputs into digital inputs |
172 |
// Turn all analog inputs into digital inputs |
173 |
ADCON1 = 0x0F; |
173 |
ADCON1 = 0x0F; |
174 |
// Turn off the ADC |
174 |
// Turn off the ADC |
175 |
ADCON0bits.ADON = 0; |
175 |
ADCON0bits.ADON = 0; |
176 |
CMCON = 0x07; // Comparators as digital inputs |
176 |
CMCON = 0x07; // Comparators as digital inputs |
177 |
// RB0-1 for i2c, RB6-7 Paddle dit/dah, RB2-5 LPF 3-6 |
177 |
// RB0-1 for i2c, RB6-7 Paddle dit/dah, RB2-5 LPF 3-6 |
178 |
LATB = 0x00; |
178 |
LATB = 0x00; |
179 |
TRISB = 0xc3; // 11000011 |
179 |
TRISB = 0xc3; // 11000011 |
180 |
INTCON2bits.RBPU = 0; // enable RB weak internal pullup |
180 |
INTCON2bits.RBPU = 0; // enable RB weak internal pullup |
181 |
// Make all of PORTC inputs |
181 |
// Make all of PORTC inputs |
182 |
LATC = 0x00; |
182 |
LATC = 0x00; |
183 |
TRISC = 0xFF; |
183 |
TRISC = 0xFF; |
184 |
|
184 |
|
185 |
mInitAllLEDs(); |
185 |
mInitAllLEDs(); |
186 |
mInitSwitch(); |
186 |
mInitSwitch(); |
187 |
old_SW = UserSW; |
187 |
old_SW = UserSW; |
188 |
|
188 |
|
189 |
#elif defined(UBW32) |
189 |
#elif defined(UBW32) |
190 |
|
190 |
|
191 |
// gO through each I/O register, setting them all to digital i/o |
191 |
// gO through each I/O register, setting them all to digital i/o |
192 |
// and making none of them open drain and turning off all pullups and |
192 |
// and making none of them open drain and turning off all pullups and |
193 |
// setting all of the latches to zero. We have PORTA through PORTG on |
193 |
// setting all of the latches to zero. We have PORTA through PORTG on |
194 |
// this chip. That's 7 total. |
194 |
// this chip. That's 7 total. |
195 |
|
195 |
|
196 |
|
196 |
|
197 |
LATA = 0x0000; |
197 |
LATA = 0x0000; |
198 |
TRISA = 0x0000; |
198 |
TRISA = 0x0000; |
199 |
ODCA = 0x0000; |
199 |
ODCA = 0x0000; |
200 |
LATB = 0x0000; |
200 |
LATB = 0x0000; |
201 |
TRISB = 0x0000; |
201 |
TRISB = 0x0000; |
202 |
ODCB = 0x0000; |
202 |
ODCB = 0x0000; |
203 |
LATC = 0x0000; |
203 |
LATC = 0x0000; |
204 |
TRISC = 0x0000; |
204 |
TRISC = 0x0000; |
205 |
ODCC = 0x0000; |
205 |
ODCC = 0x0000; |
206 |
LATD = 0x0000; |
206 |
LATD = 0x0000; |
207 |
TRISD = 0x0000; |
207 |
TRISD = 0x0000; |
208 |
ODCD = 0x0000; |
208 |
ODCD = 0x0000; |
209 |
LATE = 0x0000; |
209 |
LATE = 0x0000; |
210 |
TRISE = 0x0000; |
210 |
TRISE = 0x0000; |
211 |
ODCE = 0x0000; |
211 |
ODCE = 0x0000; |
212 |
LATF = 0x0000; |
212 |
LATF = 0x0000; |
213 |
TRISF = 0x0030; // RF4-5 paddle input |
213 |
TRISF = 0x0030; // RF4-5 paddle input |
214 |
ODCF = 0x0000; |
214 |
ODCF = 0x0000; |
215 |
CNPUE = 0x060000; // Pull up on CNPUE17-18, corresponding to RF4-5 |
215 |
CNPUE = 0x060000; // Pull up on CNPUE17-18, corresponding to RF4-5 |
216 |
LATG = 0x0000; |
216 |
LATG = 0x0000; |
217 |
TRISG = 0x0000; |
217 |
TRISG = 0x0000; |
218 |
ODCG = 0x0000; |
218 |
ODCG = 0x0000; |
219 |
|
219 |
|
220 |
//Initialize all of the LED pins |
220 |
//Initialize all of the LED pins |
221 |
mInitAllLEDs(); |
221 |
mInitAllLEDs(); |
222 |
|
222 |
|
223 |
mInitAllSwitches(); |
223 |
mInitAllSwitches(); |
224 |
old_SW = UserSW; |
224 |
old_SW = UserSW; |
225 |
|
225 |
|
226 |
// Initialize Data EEPROM Emulation |
226 |
// Initialize Data EEPROM Emulation |
227 |
if (DataEEInit()) { |
227 |
if (DataEEInit()) { |
228 |
mLED_4_On(); // Error occured |
228 |
mLED_4_On(); // Error occured |
229 |
} |
229 |
} |
230 |
else { |
230 |
else { |
231 |
mLED_4_Off(); |
231 |
mLED_4_Off(); |
232 |
}; |
232 |
}; |
233 |
|
233 |
|
234 |
#endif |
234 |
#endif |
235 |
|
235 |
|
236 |
i2c_adr = DEFAULT_I2C_ADDRESS; |
236 |
i2c_adr = DEFAULT_I2C_ADDRESS; |
237 |
|
237 |
|
238 |
// check for previous calibration, which sets fcryst, the actual crystal freq |
238 |
// check for previous calibration, which sets fcryst, the actual crystal freq |
239 |
#if defined (UBW) |
239 |
#if defined (UBW) |
240 |
if (Read_b_eep(F_CAL_DONE) != F_CAL_DONE_VALUE){ // cal not done before, use default |
240 |
if (Read_b_eep(F_CAL_DONE) != F_CAL_DONE_VALUE){ // cal not done before, use default |
241 |
fcryst_freq.qw = (double) DEFAULT_FCRYST * (double) (1L << 24); // 114.285 Mhz |
241 |
fcryst_freq.qw = (double) DEFAULT_FCRYST * (double) (1L << 24); // 114.285 Mhz |
242 |
} |
242 |
} |
243 |
else { // cal done before, read into fcryst |
243 |
else { // cal done before, read into fcryst |
244 |
for (i=0; i<4; i++) fcryst_freq.bytes[i] = Read_b_eep(i + F_CAL_DONE +1); |
244 |
for (i=0; i<4; i++) fcryst_freq.bytes[i] = Read_b_eep(i + F_CAL_DONE +1); |
245 |
}; |
245 |
}; |
246 |
|
246 |
|
247 |
#elif defined (UBW32) |
247 |
#elif defined (UBW32) |
248 |
DataEERead(&value, F_CAL_DONE); |
248 |
DataEERead(&value, F_CAL_DONE); |
249 |
if ( value != F_CAL_DONE_VALUE){ // cal not done before, use default |
249 |
if ( value != F_CAL_DONE_VALUE){ // cal not done before, use default |
250 |
fcryst_freq.qw = (double) DEFAULT_FCRYST * (double) (1L << 24); // 114.285 Mhz |
250 |
fcryst_freq.qw = (double) DEFAULT_FCRYST * (double) (1L << 24); // 114.285 Mhz |
251 |
} |
251 |
} |
252 |
else { // cal done before, read into fcryst |
252 |
else { // cal done before, read into fcryst |
253 |
DataEERead(&value, (F_CAL_DONE +1)); |
253 |
DataEERead(&value, (F_CAL_DONE +1)); |
254 |
fcryst_freq.qw = value; |
254 |
fcryst_freq.qw = value; |
255 |
}; |
255 |
}; |
256 |
#endif |
256 |
#endif |
257 |
|
257 |
|
258 |
// Now that fcryst is checked, set it first so that it can be used by startup freq setting |
258 |
// Now that fcryst is checked, set it first so that it can be used by startup freq setting |
259 |
|
259 |
|
260 |
fcryst_double = (double) fcryst_freq.qw / (double) (1L << 24); |
260 |
fcryst_double = (double) fcryst_freq.qw / (double) (1L << 24); |
261 |
validCombo = 1; |
261 |
validCombo = 1; |
262 |
command_count = 0; |
262 |
command_count = 0; |
263 |
current_command_in = 0; |
263 |
current_command_in = 0; |
264 |
current_command_out = 0; |
264 |
current_command_out = 0; |
265 |
Old_freq_double = 0; |
265 |
Old_freq_double = 0; |
266 |
|
266 |
|
267 |
// check for previous startup freq setting |
267 |
// check for previous startup freq setting |
268 |
#if defined (UBW) |
268 |
#if defined (UBW) |
269 |
if (Read_b_eep(F_INIT_FREQ) != F_INIT_FREQ_VALUE){ // not set before, use default |
269 |
if (Read_b_eep(F_INIT_FREQ) != F_INIT_FREQ_VALUE){ // not set before, use default |
270 |
avr_freq.qw = (double) DEFAULT_INIT_FREQ * (double) (1L << 21); |
270 |
avr_freq.qw = (double) DEFAULT_INIT_FREQ * (double) (1L << 21); |
271 |
} |
271 |
} |
272 |
else { // startup freq set before, read into avr |
272 |
else { // startup freq set before, read into avr |
273 |
for (i=0; i<4; i++) avr_freq.bytes[i] = Read_b_eep(i + F_INIT_FREQ +1); |
273 |
for (i=0; i<4; i++) avr_freq.bytes[i] = Read_b_eep(i + F_INIT_FREQ +1); |
274 |
}; |
274 |
}; |
275 |
|
275 |
|
276 |
#elif defined (UBW32) |
276 |
#elif defined (UBW32) |
277 |
DataEERead(&value, F_INIT_FREQ); |
277 |
DataEERead(&value, F_INIT_FREQ); |
278 |
if ( value != F_INIT_FREQ_VALUE){ // not set before, use default |
278 |
if ( value != F_INIT_FREQ_VALUE){ // not set before, use default |
279 |
avr_freq.qw = (double) DEFAULT_INIT_FREQ * (double) (1L << 21); |
279 |
avr_freq.qw = (double) DEFAULT_INIT_FREQ * (double) (1L << 21); |
280 |
} |
280 |
} |
281 |
else { // set before, read |
281 |
else { // set before, read |
282 |
DataEERead(&value, (F_INIT_FREQ +1)); |
282 |
DataEERead(&value, (F_INIT_FREQ +1)); |
283 |
avr_freq.qw = value; |
283 |
avr_freq.qw = value; |
284 |
}; |
284 |
}; |
285 |
|
285 |
|
286 |
#endif |
286 |
#endif |
287 |
|
287 |
|
288 |
|
288 |
|
289 |
|
289 |
|
290 |
// check for previous smooth setting |
290 |
// check for previous smooth setting |
291 |
#if defined (UBW) |
291 |
#if defined (UBW) |
292 |
if (Read_b_eep(F_SMOOTH) != F_SMOOTH_VALUE){ // not set before, use default |
292 |
if (Read_b_eep(F_SMOOTH) != F_SMOOTH_VALUE){ // not set before, use default |
293 |
Smooth_double = (double) DEFAULT_SMOOTH / 1000000L; // in ppm |
293 |
Smooth_double = (double) DEFAULT_SMOOTH / 1000000L; // in ppm |
294 |
} |
294 |
} |
295 |
else { // set before, read |
295 |
else { // set before, read |
296 |
for (i=0; i<2; i++) w.v[i] = Read_b_eep(i + F_SMOOTH +1); |
296 |
for (i=0; i<2; i++) w.v[i] = Read_b_eep(i + F_SMOOTH +1); |
297 |
Smooth_double = (double) w.Val / 1000000L; |
297 |
Smooth_double = (double) w.Val / 1000000L; |
298 |
}; |
298 |
}; |
299 |
|
299 |
|
300 |
#elif defined (UBW32) |
300 |
#elif defined (UBW32) |
301 |
DataEERead(&value, F_SMOOTH); |
301 |
DataEERead(&value, F_SMOOTH); |
302 |
if ( value != F_SMOOTH_VALUE){ // not set before, use default |
302 |
if ( value != F_SMOOTH_VALUE){ // not set before, use default |
303 |
Smooth_double = (double) DEFAULT_SMOOTH / 1000000L; |
303 |
Smooth_double = (double) DEFAULT_SMOOTH / 1000000L; |
304 |
} |
304 |
} |
305 |
else { // set before, read |
305 |
else { // set before, read |
306 |
DataEERead(&value, (F_SMOOTH +1)); |
306 |
DataEERead(&value, (F_SMOOTH +1)); |
307 |
w.Val = value; |
307 |
w.Val = value; |
308 |
Smooth_double = (double) w.Val / 1000000L; |
308 |
Smooth_double = (double) w.Val / 1000000L; |
309 |
} |
309 |
} |
310 |
#endif |
310 |
#endif |
311 |
|
311 |
|
312 |
// check for previous sub mul setting |
312 |
// check for previous sub mul setting |
313 |
#if defined (UBW) |
313 |
#if defined (UBW) |
314 |
if (Read_b_eep(F_SUB_MUL) != F_SUB_MUL_VALUE){ // not set before, use default |
314 |
if (Read_b_eep(F_SUB_MUL) != F_SUB_MUL_VALUE){ // not set before, use default |
315 |
f_sub.qw = (double) DEFAULT_SUB * (double) (1L << 21); |
315 |
f_sub.qw = (double) DEFAULT_SUB * (double) (1L << 21); |
316 |
f_mul.qw = (double) DEFAULT_MUL * (double) (1L << 21); |
316 |
f_mul.qw = (double) DEFAULT_MUL * (double) (1L << 21); |
317 |
} |
317 |
} |
318 |
else { // startup freq set before, read into avr |
318 |
else { // startup freq set before, read into avr |
319 |
for (i=0; i<4; i++) f_sub.bytes[i] = Read_b_eep(i + F_SUB_MUL +1); |
319 |
for (i=0; i<4; i++) f_sub.bytes[i] = Read_b_eep(i + F_SUB_MUL +1); |
320 |
for (i=0; i<4; i++) f_mul.bytes[i] = Read_b_eep(i + F_SUB_MUL +5); |
320 |
for (i=0; i<4; i++) f_mul.bytes[i] = Read_b_eep(i + F_SUB_MUL +5); |
321 |
}; |
321 |
}; |
322 |
|
322 |
|
323 |
#elif defined (UBW32) |
323 |
#elif defined (UBW32) |
324 |
DataEERead(&value, F_SUB_MUL); |
324 |
DataEERead(&value, F_SUB_MUL); |
325 |
if ( value != F_SUB_MUL_VALUE){ // not set before, use default |
325 |
if ( value != F_SUB_MUL_VALUE){ // not set before, use default |
326 |
f_sub.qw = (double) DEFAULT_SUB * (double) (1L << 21); |
326 |
f_sub.qw = (double) DEFAULT_SUB * (double) (1L << 21); |
327 |
f_mul.qw = (double) DEFAULT_MUL * (double) (1L << 21); |
327 |
f_mul.qw = (double) DEFAULT_MUL * (double) (1L << 21); |
328 |
} |
328 |
} |
329 |
else { // set before, read |
329 |
else { // set before, read |
330 |
DataEERead(&value, (F_SUB_MUL +1)); |
330 |
DataEERead(&value, (F_SUB_MUL +1)); |
331 |
f_sub.qw = value; |
331 |
f_sub.qw = value; |
332 |
DataEERead(&value, (F_SUB_MUL +2)); |
332 |
DataEERead(&value, (F_SUB_MUL +2)); |
333 |
f_mul.qw = value; |
333 |
f_mul.qw = value; |
334 |
}; |
334 |
}; |
335 |
|
335 |
|
336 |
#endif |
336 |
#endif |
337 |
|
337 |
|
338 |
|
338 |
|
339 |
|
339 |
|
340 |
|
340 |
|
341 |
|
341 |
|
342 |
// Check for Cross Over Points |
342 |
// Check for Cross Over Points |
343 |
#if defined (UBW) |
343 |
#if defined (UBW) |
344 |
if (Read_b_eep(F_CROSS_OVER) != F_CROSS_OVER_VALUE){ // not set before, use default |
344 |
if (Read_b_eep(F_CROSS_OVER) != F_CROSS_OVER_VALUE){ // not set before, use default |
345 |
|
345 |
|
346 |
#if defined (YAS) |
346 |
#if defined (YAS) |
347 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
347 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
348 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
348 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
349 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
349 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
350 |
FilterSwitchOver[3] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
350 |
FilterSwitchOver[3] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
351 |
FilterSwitchOver[4] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
351 |
FilterSwitchOver[4] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
352 |
FilterSwitchOver[5] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
352 |
FilterSwitchOver[5] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
353 |
FilterSwitchOver[6] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
353 |
FilterSwitchOver[6] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
354 |
#else |
354 |
#else |
355 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
355 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
356 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
356 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
357 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
357 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
358 |
#endif |
358 |
#endif |
359 |
for (i = 0; i < (NUM_BPF - 1); i++) FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
359 |
for (i = 0; i < (NUM_BPF - 1); i++) FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
360 |
FilterCrossOver[(NUM_BPF-1)].Val = 1; // Enabled |
360 |
FilterCrossOver[(NUM_BPF-1)].Val = 1; // Enabled |
361 |
abpf_flag = 1; |
361 |
abpf_flag = 1; |
362 |
|
362 |
|
363 |
#if defined (K5OOR) |
363 |
#if defined (K5OOR) |
364 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
364 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
365 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
365 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
366 |
LPFSwitchOver[2] = (7.45 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
366 |
LPFSwitchOver[2] = (7.45 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
367 |
LPFSwitchOver[3] = (15.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
367 |
LPFSwitchOver[3] = (15.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
368 |
LPFSwitchOver[4] = (21.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
368 |
LPFSwitchOver[4] = (21.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
369 |
LPFSwitchOver[5] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
369 |
LPFSwitchOver[5] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
370 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
370 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
371 |
#elif defined (ALEX) |
371 |
#elif defined (ALEX) |
372 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
372 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
373 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
373 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
374 |
LPFSwitchOver[2] = (9.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
374 |
LPFSwitchOver[2] = (9.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
375 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
375 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
376 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
376 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
377 |
LPFSwitchOver[5] = (20.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
377 |
LPFSwitchOver[5] = (20.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
378 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
378 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
379 |
#elif defined (MARC) |
379 |
#elif defined (MARC) |
380 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
380 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
381 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
381 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
382 |
LPFSwitchOver[2] = (8.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
382 |
LPFSwitchOver[2] = (8.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
383 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
383 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
384 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
384 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
385 |
LPFSwitchOver[5] = (18.2 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
385 |
LPFSwitchOver[5] = (18.2 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
386 |
LPFSwitchOver[6] = (21.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
386 |
LPFSwitchOver[6] = (21.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
387 |
#else |
387 |
#else |
388 |
#error "Must define an LPF configuration." |
388 |
#error "Must define an LPF configuration." |
389 |
#endif |
389 |
#endif |
390 |
|
390 |
|
391 |
for (i = 0; i < 7; i++) LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
391 |
for (i = 0; i < 7; i++) LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
392 |
LPFCrossOver[7].Val = 1; // Enabled |
392 |
LPFCrossOver[7].Val = 1; // Enabled |
393 |
} |
393 |
} |
394 |
else { // set before, read |
394 |
else { // set before, read |
395 |
for (i = 0; i < NUM_BPF; i++){ |
395 |
for (i = 0; i < NUM_BPF; i++){ |
396 |
w.v[0] = Read_b_eep(2 * i + F_CROSS_OVER +1); |
396 |
w.v[0] = Read_b_eep(2 * i + F_CROSS_OVER +1); |
397 |
w.v[1] = Read_b_eep(2 * i + 1 + F_CROSS_OVER + 1); |
397 |
w.v[1] = Read_b_eep(2 * i + 1 + F_CROSS_OVER + 1); |
398 |
FilterCrossOver[i].Val = w.Val; |
398 |
FilterCrossOver[i].Val = w.Val; |
399 |
}; |
399 |
}; |
400 |
|
400 |
|
401 |
abpf_flag = FilterCrossOver[(NUM_BPF-1)].v[0]; |
401 |
abpf_flag = FilterCrossOver[(NUM_BPF-1)].v[0]; |
402 |
|
402 |
|
403 |
for (i = 0; i < 8; i++){ |
403 |
for (i = 0; i < 8; i++){ |
404 |
w.v[0] = Read_b_eep(2 * i + F_CROSS_OVER +17); |
404 |
w.v[0] = Read_b_eep(2 * i + F_CROSS_OVER +17); |
405 |
w.v[1] = Read_b_eep(2 * i + 1 + F_CROSS_OVER + 17); |
405 |
w.v[1] = Read_b_eep(2 * i + 1 + F_CROSS_OVER + 17); |
406 |
LPFCrossOver[i].Val = w.Val; |
406 |
LPFCrossOver[i].Val = w.Val; |
407 |
}; |
407 |
}; |
408 |
|
408 |
|
409 |
} |
409 |
} |
410 |
|
410 |
|
411 |
#elif defined (UBW32) |
411 |
#elif defined (UBW32) |
412 |
DataEERead(&value, F_CROSS_OVER); |
412 |
DataEERead(&value, F_CROSS_OVER); |
413 |
if ( value != F_CROSS_OVER_VALUE){ // not set before, use default |
413 |
if ( value != F_CROSS_OVER_VALUE){ // not set before, use default |
414 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
414 |
FilterSwitchOver[0] = (2.4 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; // default BPF switchover points |
415 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
415 |
FilterSwitchOver[1] = (8.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
416 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
416 |
FilterSwitchOver[2] = (19.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
417 |
for (i = 0; i < 3; i++) FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
417 |
for (i = 0; i < 3; i++) FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
418 |
FilterCrossOver[3].Val = 1; // Enabled |
418 |
FilterCrossOver[3].Val = 1; // Enabled |
419 |
abpf_flag = 1; |
419 |
abpf_flag = 1; |
420 |
|
420 |
|
421 |
#if defined (K5OOR) |
421 |
#if defined (K5OOR) |
422 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
422 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
423 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
423 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
424 |
LPFSwitchOver[2] = (7.45 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
424 |
LPFSwitchOver[2] = (7.45 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
425 |
LPFSwitchOver[3] = (15.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
425 |
LPFSwitchOver[3] = (15.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
426 |
LPFSwitchOver[4] = (21.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
426 |
LPFSwitchOver[4] = (21.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
427 |
LPFSwitchOver[5] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
427 |
LPFSwitchOver[5] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
428 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
428 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
429 |
#elif defined (ALEX) |
429 |
#elif defined (ALEX) |
430 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
430 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
431 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
431 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
432 |
LPFSwitchOver[2] = (9.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
432 |
LPFSwitchOver[2] = (9.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
433 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
433 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
434 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
434 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
435 |
LPFSwitchOver[5] = (20.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
435 |
LPFSwitchOver[5] = (20.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
436 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
436 |
LPFSwitchOver[6] = (30.0 - DEFAULT_SUB) * DEFAULT_MUL* 4.0; |
437 |
#elif defined (MARC) |
437 |
#elif defined (MARC) |
438 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
438 |
LPFSwitchOver[0] = (2.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
439 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
439 |
LPFSwitchOver[1] = (4.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
440 |
LPFSwitchOver[2] = (8.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
440 |
LPFSwitchOver[2] = (8.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
441 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
441 |
LPFSwitchOver[3] = (11.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
442 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
442 |
LPFSwitchOver[4] = (14.5 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
443 |
LPFSwitchOver[5] = (18.2 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
443 |
LPFSwitchOver[5] = (18.2 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
444 |
LPFSwitchOver[6] = (21.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
444 |
LPFSwitchOver[6] = (21.0 - DEFAULT_SUB) * DEFAULT_MUL * 4.0; |
445 |
#else |
445 |
#else |
446 |
#error "Must define an LPF configuration." |
446 |
#error "Must define an LPF configuration." |
447 |
#endif |
447 |
#endif |
448 |
|
448 |
|
449 |
for (i = 0; i < 7; i++) LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
449 |
for (i = 0; i < 7; i++) LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
450 |
LPFCrossOver[7].Val = 1; // Enabled |
450 |
LPFCrossOver[7].Val = 1; // Enabled |
451 |
|
451 |
|
452 |
|
452 |
|
453 |
} |
453 |
} |
454 |
else { // set before, read |
454 |
else { // set before, read |
455 |
for (i=0; i< NUM_BPF; i++) { |
455 |
for (i=0; i< NUM_BPF; i++) { |
456 |
DataEERead(&value, (i + F_CROSS_OVER +1)); |
456 |
DataEERead(&value, (i + F_CROSS_OVER +1)); |
457 |
FilterCrossOver[i].Val = value; |
457 |
FilterCrossOver[i].Val = value; |
458 |
}; |
458 |
}; |
459 |
|
459 |
|
460 |
|
460 |
|
461 |
abpf_flag = FilterCrossOver[(NUM_BPF-1)].Val; |
461 |
abpf_flag = FilterCrossOver[(NUM_BPF-1)].Val; |
462 |
|
462 |
|
463 |
for (i=0; i<8; i++) { |
463 |
for (i=0; i<8; i++) { |
464 |
DataEERead(&value, (i + F_CROSS_OVER +9)); |
464 |
DataEERead(&value, (i + F_CROSS_OVER +9)); |
465 |
LPFCrossOver[i].Val = value; |
465 |
LPFCrossOver[i].Val = value; |
466 |
}; |
466 |
}; |
467 |
}; |
467 |
}; |
468 |
#endif // UBW32 |
468 |
#endif // UBW32 |
469 |
|
469 |
|
470 |
for (i = 0; i < (NUM_BPF-1); i++) FilterSwitchOver[i] = Cross2Switch(FilterCrossOver[i]); |
470 |
for (i = 0; i < (NUM_BPF-1); i++) FilterSwitchOver[i] = Cross2Switch(FilterCrossOver[i]); |
471 |
for (i = 0; i < 7; i++) LPFSwitchOver[i] = Cross2Switch(LPFCrossOver[i]); |
471 |
for (i = 0; i < 7; i++) LPFSwitchOver[i] = Cross2Switch(LPFCrossOver[i]); |
472 |
|
472 |
|
473 |
// End initialising filter switchover points |
473 |
// End initialising filter switchover points |
474 |
|
474 |
|
475 |
#if defined(UBW) |
475 |
#if defined(UBW) |
476 |
blinkStatusValid = Read_b_eep(F_BLINK_LED); |
476 |
blinkStatusValid = Read_b_eep(F_BLINK_LED); |
477 |
#elif defined (UBW32) |
477 |
#elif defined (UBW32) |
478 |
DataEERead(&value, F_BLINK_LED); |
478 |
DataEERead(&value, F_BLINK_LED); |
479 |
blinkStatusValid = value; |
479 |
blinkStatusValid = value; |
480 |
#endif |
480 |
#endif |
481 |
|
481 |
|
482 |
#if defined (UBW) |
482 |
#if defined (UBW) |
483 |
OpenI2C(MASTER, SLEW_ON);// Initialize I2C module |
483 |
OpenI2C(MASTER, SLEW_ON);// Initialize I2C module |
484 |
SSPADD = 48; //400kHz Baud clock(9) @16MHz |
484 |
SSPADD = 48; //400kHz Baud clock(9) @16MHz |
485 |
//100kHz Baud clock(39) @16MHz |
485 |
//100kHz Baud clock(39) @16MHz |
486 |
|
486 |
|
487 |
#elif defined (UBW32) |
487 |
#elif defined (UBW32) |
488 |
OpenI2C1(I2C_ON, ( GetPeripheralClock() / 400000UL - 2) ); |
488 |
OpenI2C1(I2C_ON, ( GetPeripheralClock() / 400000UL - 2) ); |
489 |
#endif |
489 |
#endif |
490 |
|
490 |
|
491 |
// IF we don't reset Si570 on startup, it will not hang if Si570 not connected |
491 |
// IF we don't reset Si570 on startup, it will not hang if Si570 not connected |
492 |
#if defined (INIT_SI570_ON_STARTUP) |
492 |
#if defined (INIT_SI570_ON_STARTUP) |
493 |
Reset_Si570(); |
493 |
Reset_Si570(); |
494 |
#endif |
494 |
#endif |
495 |
|
495 |
|
496 |
// check for previous startup freq setting, if set, then set Si570 to startup freq |
496 |
// check for previous startup freq setting, if set, then set Si570 to startup freq |
497 |
#if defined (UBW32) |
497 |
#if defined (UBW32) |
498 |
DataEERead(&value, F_INIT_FREQ); |
498 |
DataEERead(&value, F_INIT_FREQ); |
499 |
if ( value == F_INIT_FREQ_VALUE){ |
499 |
if ( value == F_INIT_FREQ_VALUE){ |
500 |
#else |
500 |
#else |
501 |
if (Read_b_eep(F_INIT_FREQ) == F_INIT_FREQ_VALUE){ |
501 |
if (Read_b_eep(F_INIT_FREQ) == F_INIT_FREQ_VALUE){ |
502 |
#endif |
502 |
#endif |
503 |
// avr_freq has been setup by the reading of the startup freq |
503 |
// avr_freq has been setup by the reading of the startup freq |
504 |
set_frequency = (double) avr_freq.qw / (double)(1L << 21); |
504 |
set_frequency = (double) avr_freq.qw / (double)(1L << 21); |
505 |
SetFrequency(set_frequency); |
505 |
SetFrequency(set_frequency); |
506 |
}; |
506 |
}; |
507 |
|
507 |
|
508 |
}//end UserInit |
508 |
}//end UserInit |
509 |
|
509 |
|
510 |
|
510 |
|
511 |
/****************************************************************************** |
511 |
/****************************************************************************** |
512 |
* Function: void ProcessIO(void) |
512 |
* Function: void ProcessIO(void) |
513 |
* |
513 |
* |
514 |
* PreCondition: None |
514 |
* PreCondition: None |
515 |
* |
515 |
* |
516 |
* Input: None |
516 |
* Input: None |
517 |
* |
517 |
* |
518 |
* Output: None |
518 |
* Output: None |
519 |
* |
519 |
* |
520 |
* Side Effects: None |
520 |
* Side Effects: None |
521 |
* |
521 |
* |
522 |
* Overview: This function is a place holder for other user routines. |
522 |
* Overview: This function is a place holder for other user routines. |
523 |
* It is a mixture of both USB and non-USB tasks. |
523 |
* It is a mixture of both USB and non-USB tasks. |
524 |
* |
524 |
* |
525 |
* Note: None |
525 |
* Note: None |
526 |
*****************************************************************************/ |
526 |
*****************************************************************************/ |
527 |
void ProcessIO(void) |
527 |
void ProcessIO(void) |
528 |
{ |
528 |
{ |
529 |
if (SwitchIsPressed()){ |
529 |
if (SwitchIsPressed()){ |
530 |
blinkStatusValid = !blinkStatusValid; // toggle blink led |
530 |
blinkStatusValid = !blinkStatusValid; // toggle blink led |
531 |
#if defined(UBW) |
531 |
#if defined(UBW) |
532 |
Write_b_eep(F_BLINK_LED, blinkStatusValid); |
532 |
Write_b_eep(F_BLINK_LED, blinkStatusValid); |
533 |
#elif defined(UBW32) |
533 |
#elif defined(UBW32) |
534 |
DataEEWrite(blinkStatusValid, F_BLINK_LED); |
534 |
DataEEWrite(blinkStatusValid, F_BLINK_LED); |
535 |
#endif |
535 |
#endif |
536 |
}; |
536 |
}; |
537 |
|
537 |
|
538 |
//Blink the LEDs according to the USB device status |
538 |
//Blink the LEDs according to the USB device status |
539 |
if(blinkStatusValid) BlinkUSBStatus(); |
539 |
if(blinkStatusValid) BlinkUSBStatus(); |
540 |
else mLED_Both_Off(); |
540 |
else mLED_Both_Off(); |
541 |
// User Application USB tasks |
541 |
// User Application USB tasks |
542 |
if((USBDeviceState < ADDRESS_STATE)||(USBSuspendControl==1)) return; |
542 |
if((USBDeviceState < ADDRESS_STATE)||(USBSuspendControl==1)) return; |
543 |
|
543 |
|
544 |
//respond to any USB commands that might have come over the bus |
544 |
//respond to any USB commands that might have come over the bus |
545 |
ServiceRequests(); |
545 |
ServiceRequests(); |
546 |
|
546 |
|
547 |
|
547 |
|
548 |
}//end ProcessIO |
548 |
}//end ProcessIO |
549 |
|
549 |
|
550 |
|
550 |
|
551 |
/****************************************************************************** |
551 |
/****************************************************************************** |
552 |
* Function: void ServiceRequests(void) |
552 |
* Function: void ServiceRequests(void) |
553 |
* |
553 |
* |
554 |
* PreCondition: None |
554 |
* PreCondition: None |
555 |
* |
555 |
* |
556 |
* Input: None |
556 |
* Input: None |
557 |
* |
557 |
* |
558 |
* Output: None |
558 |
* Output: None |
559 |
* |
559 |
* |
560 |
* Side Effects: USB traffic can be generated |
560 |
* Side Effects: USB traffic can be generated |
561 |
* |
561 |
* |
562 |
* Overview: This function takes in the commands from the PC from the |
562 |
* Overview: This function takes in the commands from the PC from the |
563 |
* application and executes the commands requested |
563 |
* application and executes the commands requested |
564 |
* |
564 |
* |
565 |
* Note: None |
565 |
* Note: None |
566 |
*****************************************************************************/ |
566 |
*****************************************************************************/ |
567 |
void ServiceRequests(void) |
567 |
void ServiceRequests(void) |
568 |
{ |
568 |
{ |
569 |
BYTE command_to_process; |
569 |
BYTE command_to_process; |
570 |
|
570 |
|
571 |
|
571 |
|
572 |
if (command_count > 0) { // there is command in buffer |
572 |
if (command_count > 0) { // there is command in buffer |
573 |
command_to_process = command_buffer[current_command_out].command; |
573 |
command_to_process = command_buffer[current_command_out].command; |
574 |
|
574 |
|
575 |
switch (command_to_process){ |
575 |
switch (command_to_process){ |
576 |
case CMD_SET_FREQ_REG: |
576 |
case CMD_SET_FREQ_REG: |
577 |
Set_Register_Handler(); |
577 |
Set_Register_Handler(); |
578 |
break; |
578 |
break; |
579 |
case CMD_SET_LO_SM: |
579 |
case CMD_SET_LO_SM: |
580 |
Set_Sub_Mul_Handler(); |
580 |
Set_Sub_Mul_Handler(); |
581 |
break; |
581 |
break; |
582 |
case CMD_SET_FREQ: |
582 |
case CMD_SET_FREQ: |
583 |
Set_Freq_Handler(); |
583 |
Set_Freq_Handler(); |
584 |
break; |
584 |
break; |
585 |
case CMD_SET_XTAL: |
585 |
case CMD_SET_XTAL: |
586 |
Set_Cal_Handler(); |
586 |
Set_Cal_Handler(); |
587 |
break; |
587 |
break; |
588 |
case CMD_SET_STARTUP: |
588 |
case CMD_SET_STARTUP: |
589 |
Set_Init_Freq_Handler(); |
589 |
Set_Init_Freq_Handler(); |
590 |
break; |
590 |
break; |
591 |
case CMD_SET_PPM: |
591 |
case CMD_SET_PPM: |
592 |
Set_Smooth_Handler(); |
592 |
Set_Smooth_Handler(); |
593 |
break; |
593 |
break; |
594 |
}; |
594 |
}; |
595 |
// end switch |
595 |
// end switch |
596 |
current_command_out++; |
596 |
current_command_out++; |
597 |
if (current_command_out >= COMMAND_BUFFER_SIZE) current_command_out = 0; |
597 |
if (current_command_out >= COMMAND_BUFFER_SIZE) current_command_out = 0; |
598 |
command_count--; |
598 |
command_count--; |
599 |
} // end command_count > 0 |
599 |
} // end command_count > 0 |
600 |
|
600 |
|
601 |
|
601 |
|
602 |
}//end ServiceRequests |
602 |
}//end ServiceRequests |
603 |
|
603 |
|
604 |
/******************************************************************** |
604 |
/******************************************************************** |
605 |
* Function: void BlinkUSBStatus(void) |
605 |
* Function: void BlinkUSBStatus(void) |
606 |
* |
606 |
* |
607 |
* PreCondition: None |
607 |
* PreCondition: None |
608 |
* |
608 |
* |
609 |
* Input: None |
609 |
* Input: None |
610 |
* |
610 |
* |
611 |
* Output: None |
611 |
* Output: None |
612 |
* |
612 |
* |
613 |
* Side Effects: None |
613 |
* Side Effects: None |
614 |
* |
614 |
* |
615 |
* Overview: BlinkUSBStatus turns on and off LEDs |
615 |
* Overview: BlinkUSBStatus turns on and off LEDs |
616 |
* corresponding to the USB device state. |
616 |
* corresponding to the USB device state. |
617 |
* |
617 |
* |
618 |
* Note: mLED macros can be found in HardwareProfile.h |
618 |
* Note: mLED macros can be found in HardwareProfile.h |
619 |
* USBDeviceState is declared and updated in |
619 |
* USBDeviceState is declared and updated in |
620 |
* usb_device.c. |
620 |
* usb_device.c. |
621 |
*******************************************************************/ |
621 |
*******************************************************************/ |
622 |
void BlinkUSBStatus(void) |
622 |
void BlinkUSBStatus(void) |
623 |
{ |
623 |
{ |
624 |
static WORD led_count=0; |
624 |
static WORD led_count=0; |
625 |
|
625 |
|
626 |
if(led_count == 0)led_count = 10000U; |
626 |
if(led_count == 0)led_count = 10000U; |
627 |
led_count--; |
627 |
led_count--; |
628 |
|
628 |
|
629 |
|
629 |
|
630 |
if(USBSuspendControl == 1) |
630 |
if(USBSuspendControl == 1) |
631 |
{ |
631 |
{ |
632 |
if(led_count==0) |
632 |
if(led_count==0) |
633 |
{ |
633 |
{ |
634 |
mLED_1_Toggle(); |
634 |
mLED_1_Toggle(); |
635 |
mLED_2 = mLED_1; |
635 |
mLED_2 = mLED_1; |
636 |
}//end if |
636 |
}//end if |
637 |
} |
637 |
} |
638 |
else |
638 |
else |
639 |
{ |
639 |
{ |
640 |
if(USBDeviceState == DETACHED_STATE) |
640 |
if(USBDeviceState == DETACHED_STATE) |
641 |
{ |
641 |
{ |
642 |
mLED_1_Off(); mLED_2_Off(); |
642 |
mLED_1_Off(); mLED_2_Off(); |
643 |
} |
643 |
} |
644 |
else if(USBDeviceState == ATTACHED_STATE) |
644 |
else if(USBDeviceState == ATTACHED_STATE) |
645 |
{ |
645 |
{ |
646 |
mLED_1_On(); mLED_2_On(); |
646 |
mLED_1_On(); mLED_2_On(); |
647 |
} |
647 |
} |
648 |
else if(USBDeviceState == POWERED_STATE) |
648 |
else if(USBDeviceState == POWERED_STATE) |
649 |
{ |
649 |
{ |
650 |
mLED_1_On(); mLED_2_Off(); |
650 |
mLED_1_On(); mLED_2_Off(); |
651 |
} |
651 |
} |
652 |
else if(USBDeviceState == DEFAULT_STATE) |
652 |
else if(USBDeviceState == DEFAULT_STATE) |
653 |
{ |
653 |
{ |
654 |
mLED_1_Off(); mLED_2_On(); |
654 |
mLED_1_Off(); mLED_2_On(); |
655 |
} |
655 |
} |
656 |
else if(USBDeviceState == ADDRESS_STATE) |
656 |
else if(USBDeviceState == ADDRESS_STATE) |
657 |
{ |
657 |
{ |
658 |
if(led_count == 0) |
658 |
if(led_count == 0) |
659 |
{ |
659 |
{ |
660 |
mLED_1_Toggle(); |
660 |
mLED_1_Toggle(); |
661 |
mLED_2_Off(); |
661 |
mLED_2_Off(); |
662 |
}//end if |
662 |
}//end if |
663 |
} |
663 |
} |
664 |
else if(USBDeviceState == CONFIGURED_STATE) |
664 |
else if(USBDeviceState == CONFIGURED_STATE) |
665 |
{ |
665 |
{ |
666 |
if(led_count==0) |
666 |
if(led_count==0) |
667 |
{ |
667 |
{ |
668 |
mLED_1_Toggle(); |
668 |
mLED_1_Toggle(); |
669 |
mLED_2 = !mLED_1; |
669 |
mLED_2 = !mLED_1; |
670 |
|
670 |
|
671 |
}//end if |
671 |
}//end if |
672 |
}//end if(...) |
672 |
}//end if(...) |
673 |
}//end if(UCONbits.SUSPND...) |
673 |
}//end if(UCONbits.SUSPND...) |
674 |
|
674 |
|
675 |
}//end BlinkUSBStatus |
675 |
}//end BlinkUSBStatus |
676 |
|
676 |
|
677 |
|
677 |
|
678 |
/****************************************************************************** |
678 |
/****************************************************************************** |
679 |
* Function: BOOL SwitchIsPressed(void) |
679 |
* Function: BOOL SwitchIsPressed(void) |
680 |
* |
680 |
* |
681 |
* PreCondition: None |
681 |
* PreCondition: None |
682 |
* |
682 |
* |
683 |
* Input: None |
683 |
* Input: None |
684 |
* |
684 |
* |
685 |
* Output: BOOL - TRUE if the SW2 was pressed and FALSE otherwise |
685 |
* Output: BOOL - TRUE if the SW2 was pressed and FALSE otherwise |
686 |
* |
686 |
* |
687 |
* Side Effects: None |
687 |
* Side Effects: None |
688 |
* |
688 |
* |
689 |
* Overview: returns TRUE if the SW2 was pressed and FALSE otherwise |
689 |
* Overview: returns TRUE if the SW2 was pressed and FALSE otherwise |
690 |
* |
690 |
* |
691 |
* Note: None |
691 |
* Note: None |
692 |
*****************************************************************************/ |
692 |
*****************************************************************************/ |
693 |
|
693 |
|
694 |
BOOL SwitchIsPressed(void) |
694 |
BOOL SwitchIsPressed(void) |
695 |
{ |
695 |
{ |
696 |
if(UserSW != old_SW) |
696 |
if(UserSW != old_SW) |
697 |
{ |
697 |
{ |
698 |
old_SW = UserSW; // Save new value |
698 |
old_SW = UserSW; // Save new value |
699 |
if(UserSW == 0) // If pressed |
699 |
if(UserSW == 0) // If pressed |
700 |
return TRUE; // Was pressed |
700 |
return TRUE; // Was pressed |
701 |
}//end if |
701 |
}//end if |
702 |
return FALSE; // Was not pressed |
702 |
return FALSE; // Was not pressed |
703 |
}//end SwitchIsPressed |
703 |
}//end SwitchIsPressed |
704 |
|
704 |
|
705 |
void Reset_Si570() |
705 |
void Reset_Si570() |
706 |
{ |
706 |
{ |
707 |
#if defined (UBW) |
707 |
#if defined (UBW) |
708 |
StartI2C(); //Reset Si570 to Startup |
708 |
StartI2C(); //Reset Si570 to Startup |
709 |
IdleI2C(); |
709 |
IdleI2C(); |
710 |
WriteI2C(i2c_adr << 1); |
710 |
WriteI2C(i2c_adr << 1); |
711 |
WriteI2C(135); //REG 135 |
711 |
WriteI2C(135); //REG 135 |
712 |
WriteI2C(0x01); // reset |
712 |
WriteI2C(0x01); // reset |
713 |
StopI2C(); |
713 |
StopI2C(); |
714 |
IdleI2C(); |
714 |
IdleI2C(); |
715 |
#elif defined (UBW32) |
715 |
#elif defined (UBW32) |
716 |
StartI2C1(); //Reset Si570 to Startup |
716 |
StartI2C1(); //Reset Si570 to Startup |
717 |
IdleI2C1(); |
717 |
IdleI2C1(); |
718 |
MasterWriteI2C1(i2c_adr << 1); |
718 |
MasterWriteI2C1(i2c_adr << 1); |
719 |
MasterWriteI2C1(135); //REG 135 |
719 |
MasterWriteI2C1(135); //REG 135 |
720 |
MasterWriteI2C1(0x01); // reset |
720 |
MasterWriteI2C1(0x01); // reset |
721 |
StopI2C1(); |
721 |
StopI2C1(); |
722 |
IdleI2C1(); |
722 |
IdleI2C1(); |
723 |
#endif |
723 |
#endif |
724 |
|
724 |
|
725 |
} |
725 |
} |
726 |
|
726 |
|
727 |
void ReadRegs() |
727 |
void ReadRegs() |
728 |
{ |
728 |
{ |
729 |
unsigned int i; |
729 |
unsigned int i; |
730 |
|
730 |
|
731 |
for(i=0;i<6;i++) |
731 |
for(i=0;i<6;i++) |
732 |
{ |
732 |
{ |
733 |
|
733 |
|
734 |
#if defined (UBW) |
734 |
#if defined (UBW) |
735 |
StartI2C(); |
735 |
StartI2C(); |
736 |
IdleI2C(); |
736 |
IdleI2C(); |
737 |
WriteI2C(i2c_adr << 1); |
737 |
WriteI2C(i2c_adr << 1); |
738 |
WriteI2C(i+7); //specify register |
738 |
WriteI2C(i+7); //specify register |
739 |
RestartI2C(); |
739 |
RestartI2C(); |
740 |
IdleI2C(); |
740 |
IdleI2C(); |
741 |
WriteI2C(i2c_adr << 1 | 0x01); |
741 |
WriteI2C(i2c_adr << 1 | 0x01); |
742 |
registers[i] = ReadI2C(); |
742 |
registers[i] = ReadI2C(); |
743 |
StopI2C(); |
743 |
StopI2C(); |
744 |
IdleI2C(); |
744 |
IdleI2C(); |
745 |
#elif defined (UBW32) |
745 |
#elif defined (UBW32) |
746 |
StartI2C1(); |
746 |
StartI2C1(); |
747 |
IdleI2C1(); |
747 |
IdleI2C1(); |
748 |
MasterWriteI2C1(i2c_adr << 1); |
748 |
MasterWriteI2C1(i2c_adr << 1); |
749 |
MasterWriteI2C1(i+7); |
749 |
MasterWriteI2C1(i+7); |
750 |
RestartI2C1(); |
750 |
RestartI2C1(); |
751 |
IdleI2C1(); |
751 |
IdleI2C1(); |
752 |
MasterWriteI2C1(i2c_adr << 1 | 0x01); |
752 |
MasterWriteI2C1(i2c_adr << 1 | 0x01); |
753 |
registers[i] = MasterReadI2C1(); |
753 |
registers[i] = MasterReadI2C1(); |
754 |
StopI2C1(); |
754 |
StopI2C1(); |
755 |
IdleI2C1(); |
755 |
IdleI2C1(); |
756 |
#endif |
756 |
#endif |
757 |
} |
757 |
} |
758 |
} |
758 |
} |
759 |
|
759 |
|
760 |
|
760 |
|
761 |
void Freeze () { |
761 |
void Freeze () { |
762 |
Prep_rd(137); //get current value |
762 |
Prep_rd(137); //get current value |
763 |
#if defined (UBW) |
763 |
#if defined (UBW) |
764 |
R137 = ReadI2C(); |
764 |
R137 = ReadI2C(); |
765 |
#elif defined (UBW32) |
765 |
#elif defined (UBW32) |
766 |
R137 = MasterReadI2C1(); |
766 |
R137 = MasterReadI2C1(); |
767 |
#endif |
767 |
#endif |
768 |
R137 = R137 | 0x10; //turn on freeze |
768 |
R137 = R137 | 0x10; //turn on freeze |
769 |
WriteBk(); |
769 |
WriteBk(); |
770 |
} |
770 |
} |
771 |
|
771 |
|
772 |
void Unfreeze () { |
772 |
void Unfreeze () { |
773 |
Prep_rd(137); |
773 |
Prep_rd(137); |
774 |
#if defined (UBW) |
774 |
#if defined (UBW) |
775 |
R137 = ReadI2C(); |
775 |
R137 = ReadI2C(); |
776 |
#elif defined (UBW32) |
776 |
#elif defined (UBW32) |
777 |
R137 = MasterReadI2C1(); |
777 |
R137 = MasterReadI2C1(); |
778 |
#endif |
778 |
#endif |
779 |
R137 = R137 & 0xEF; |
779 |
R137 = R137 & 0xEF; |
780 |
WriteBk(); |
780 |
WriteBk(); |
781 |
} |
781 |
} |
782 |
|
782 |
|
783 |
void WriteBk () { //Write back |
783 |
void WriteBk () { //Write back |
784 |
#if defined (UBW) |
784 |
#if defined (UBW) |
785 |
StopI2C(); |
785 |
StopI2C(); |
786 |
IdleI2C(); |
786 |
IdleI2C(); |
787 |
StartI2C(); |
787 |
StartI2C(); |
788 |
IdleI2C(); |
788 |
IdleI2C(); |
789 |
WriteI2C(i2c_adr<<1); |
789 |
WriteI2C(i2c_adr<<1); |
790 |
WriteI2C(137); //REG |
790 |
WriteI2C(137); //REG |
791 |
WriteI2C(R137); // new data |
791 |
WriteI2C(R137); // new data |
792 |
StopI2C(); |
792 |
StopI2C(); |
793 |
IdleI2C(); |
793 |
IdleI2C(); |
794 |
#elif defined (UBW32) |
794 |
#elif defined (UBW32) |
795 |
StopI2C1(); |
795 |
StopI2C1(); |
796 |
IdleI2C1(); |
796 |
IdleI2C1(); |
797 |
StartI2C1(); |
797 |
StartI2C1(); |
798 |
IdleI2C1(); |
798 |
IdleI2C1(); |
799 |
MasterWriteI2C1(i2c_adr<<1); |
799 |
MasterWriteI2C1(i2c_adr<<1); |
800 |
MasterWriteI2C1(137); //REG |
800 |
MasterWriteI2C1(137); //REG |
801 |
MasterWriteI2C1(R137); // new data |
801 |
MasterWriteI2C1(R137); // new data |
802 |
StopI2C1(); |
802 |
StopI2C1(); |
803 |
IdleI2C1(); |
803 |
IdleI2C1(); |
804 |
#endif |
804 |
#endif |
805 |
} |
805 |
} |
806 |
|
806 |
|
807 |
void Prep_rd (unsigned short r) { // get ready to read |
807 |
void Prep_rd (unsigned short r) { // get ready to read |
808 |
#if defined (UBW) |
808 |
#if defined (UBW) |
809 |
StartI2C(); |
809 |
StartI2C(); |
810 |
IdleI2C(); |
810 |
IdleI2C(); |
811 |
WriteI2C(i2c_adr<<1); |
811 |
WriteI2C(i2c_adr<<1); |
812 |
WriteI2C(r); //REG |
812 |
WriteI2C(r); //REG |
813 |
RestartI2C(); |
813 |
RestartI2C(); |
814 |
IdleI2C(); |
814 |
IdleI2C(); |
815 |
WriteI2C(i2c_adr<<1 | 0x01); |
815 |
WriteI2C(i2c_adr<<1 | 0x01); |
816 |
#elif defined (UBW32) |
816 |
#elif defined (UBW32) |
817 |
StartI2C1(); |
817 |
StartI2C1(); |
818 |
IdleI2C1(); |
818 |
IdleI2C1(); |
819 |
MasterWriteI2C1(i2c_adr<<1); |
819 |
MasterWriteI2C1(i2c_adr<<1); |
820 |
MasterWriteI2C1(r); //REG |
820 |
MasterWriteI2C1(r); //REG |
821 |
RestartI2C1(); |
821 |
RestartI2C1(); |
822 |
IdleI2C1(); |
822 |
IdleI2C1(); |
823 |
MasterWriteI2C1(i2c_adr<<1 | 0x01); |
823 |
MasterWriteI2C1(i2c_adr<<1 | 0x01); |
824 |
#endif |
824 |
#endif |
825 |
} |
825 |
} |
826 |
|
826 |
|
827 |
void NewF () { |
827 |
void NewF () { |
828 |
|
828 |
|
829 |
Prep_rd(135); |
829 |
Prep_rd(135); |
830 |
|
830 |
|
831 |
#if defined (UBW) |
831 |
#if defined (UBW) |
832 |
R135 = ReadI2C(); |
832 |
R135 = ReadI2C(); |
833 |
R135 |= 0x40; // set New Data bit |
833 |
R135 |= 0x40; // set New Data bit |
834 |
StopI2C(); |
834 |
StopI2C(); |
835 |
IdleI2C(); |
835 |
IdleI2C(); |
836 |
StartI2C(); |
836 |
StartI2C(); |
837 |
IdleI2C(); |
837 |
IdleI2C(); |
838 |
WriteI2C(i2c_adr<<1); |
838 |
WriteI2C(i2c_adr<<1); |
839 |
WriteI2C(135); //REG |
839 |
WriteI2C(135); //REG |
840 |
WriteI2C(R135); |
840 |
WriteI2C(R135); |
841 |
StopI2C(); |
841 |
StopI2C(); |
842 |
IdleI2C(); |
842 |
IdleI2C(); |
843 |
#elif defined (UBW32) |
843 |
#elif defined (UBW32) |
844 |
R135 = MasterReadI2C1(); |
844 |
R135 = MasterReadI2C1(); |
845 |
R135 |= 0x40; // set New Data bit |
845 |
R135 |= 0x40; // set New Data bit |
846 |
StopI2C1(); |
846 |
StopI2C1(); |
847 |
IdleI2C1(); |
847 |
IdleI2C1(); |
848 |
StartI2C1(); |
848 |
StartI2C1(); |
849 |
IdleI2C1(); |
849 |
IdleI2C1(); |
850 |
MasterWriteI2C1(i2c_adr<<1); |
850 |
MasterWriteI2C1(i2c_adr<<1); |
851 |
MasterWriteI2C1(135); //REG |
851 |
MasterWriteI2C1(135); //REG |
852 |
MasterWriteI2C1(R135); |
852 |
MasterWriteI2C1(R135); |
853 |
StopI2C1(); |
853 |
StopI2C1(); |
854 |
IdleI2C1(); |
854 |
IdleI2C1(); |
855 |
#endif |
855 |
#endif |
856 |
} |
856 |
} |
857 |
|
857 |
|
858 |
|
858 |
|
859 |
|
859 |
|
860 |
void RunFreqProg(double f) |
860 |
void RunFreqProg(double f) |
861 |
{ |
861 |
{ |
862 |
double rfreq_fraction; |
862 |
double rfreq_fraction; |
863 |
unsigned long rfreq_integer_part; |
863 |
unsigned long rfreq_integer_part; |
864 |
unsigned long rfreq_fraction_part; |
864 |
unsigned long rfreq_fraction_part; |
865 |
const float FDCO_MAX = 5670; //MHz |
865 |
const float FDCO_MAX = 5670; //MHz |
866 |
const float FDCO_MIN = 4850; |
866 |
const float FDCO_MIN = 4850; |
867 |
|
867 |
|
868 |
// Register finding the lowest DCO frequenty - code from Fred |
868 |
// Register finding the lowest DCO frequenty - code from Fred |
869 |
unsigned char xHS_DIV; |
869 |
unsigned char xHS_DIV; |
870 |
unsigned int xN1; |
870 |
unsigned int xN1; |
871 |
unsigned int xN; |
871 |
unsigned int xN; |
872 |
|
872 |
|
873 |
// Registers to save the found dividers |
873 |
// Registers to save the found dividers |
874 |
unsigned char sHS_DIV=0; |
874 |
unsigned char sHS_DIV=0; |
875 |
unsigned char sN1=0; |
875 |
unsigned char sN1=0; |
876 |
unsigned int sN=0; // Total dividing |
876 |
unsigned int sN=0; // Total dividing |
877 |
unsigned int N0; // Total divider needed (N1 * HS_DIV) |
877 |
unsigned int N0; // Total divider needed (N1 * HS_DIV) |
878 |
|
878 |
|
879 |
// Find the total division needed. |
879 |
// Find the total division needed. |
880 |
// It is always one too low (not in the case reminder is zero, reminder not used here). |
880 |
// It is always one too low (not in the case reminder is zero, reminder not used here). |
881 |
|
881 |
|
882 |
N0 = FDCO_MIN / (float) f; |
882 |
N0 = FDCO_MIN / (float) f; |
883 |
sN = 11*128; |
883 |
sN = 11*128; |
884 |
for(xHS_DIV = 11; xHS_DIV > 3; xHS_DIV--) |
884 |
for(xHS_DIV = 11; xHS_DIV > 3; xHS_DIV--) |
885 |
{ |
885 |
{ |
886 |
// Skip the unavailable divider's |
886 |
// Skip the unavailable divider's |
887 |
if (xHS_DIV == 8 || xHS_DIV == 10) |
887 |
if (xHS_DIV == 8 || xHS_DIV == 10) |
888 |
continue; |
888 |
continue; |
889 |
|
889 |
|
890 |
// Calculate the needed low speed divider |
890 |
// Calculate the needed low speed divider |
891 |
xN1 = N0 / xHS_DIV + 1; |
891 |
xN1 = N0 / xHS_DIV + 1; |
892 |
|
892 |
|
893 |
if (xN1 > 128) |
893 |
if (xN1 > 128) |
894 |
continue; |
894 |
continue; |
895 |
|
895 |
|
896 |
// Skip the unavailable divider's |
896 |
// Skip the unavailable divider's |
897 |
if (xN1 != 1 && (xN1 & 1) == 1) |
897 |
if (xN1 != 1 && (xN1 & 1) == 1) |
898 |
xN1 += 1; |
898 |
xN1 += 1; |
899 |
|
899 |
|
900 |
xN = xHS_DIV * xN1; |
900 |
xN = xHS_DIV * xN1; |
901 |
if (sN > xN) |
901 |
if (sN > xN) |
902 |
{ |
902 |
{ |
903 |
sN = xN; |
903 |
sN = xN; |
904 |
sN1 = xN1; |
904 |
sN1 = xN1; |
905 |
sHS_DIV = xHS_DIV; |
905 |
sHS_DIV = xHS_DIV; |
906 |
} |
906 |
} |
907 |
}; |
907 |
}; |
908 |
|
908 |
|
909 |
validCombo = 0; |
909 |
validCombo = 0; |
910 |
|
910 |
|
911 |
if (sHS_DIV == 0) return; // no valid dividers found |
911 |
if (sHS_DIV == 0) return; // no valid dividers found |
912 |
|
912 |
|
913 |
rfreq = f * (double) sN; // DCO freq |
913 |
rfreq = f * (double) sN; // DCO freq |
914 |
if ((float)rfreq > FDCO_MAX) return; // calculated DCO freq > max |
914 |
if ((float)rfreq > FDCO_MAX) return; // calculated DCO freq > max |
915 |
|
915 |
|
916 |
validCombo = 1; |
916 |
validCombo = 1; |
917 |
|
917 |
|
918 |
// rfreq is a 38 bit number, MSB 10 bits integer portion, and LSB 28 fraction |
918 |
// rfreq is a 38 bit number, MSB 10 bits integer portion, and LSB 28 fraction |
919 |
// in the Si570 registers, tempBuf[1] has 6 bits, and tempBuf[2] has 4 bits of the integer portion |
919 |
// in the Si570 registers, tempBuf[1] has 6 bits, and tempBuf[2] has 4 bits of the integer portion |
920 |
|
920 |
|
921 |
rfreq /= fcryst_double; // DCO divided by fcryst |
921 |
rfreq /= fcryst_double; // DCO divided by fcryst |
922 |
rfreq_integer_part = rfreq; |
922 |
rfreq_integer_part = rfreq; |
923 |
rfreq_fraction = rfreq - rfreq_integer_part; |
923 |
rfreq_fraction = rfreq - rfreq_integer_part; |
924 |
rfreq_fraction_part = rfreq_fraction * (1L << 28); |
924 |
rfreq_fraction_part = rfreq_fraction * (1L << 28); |
925 |
|
925 |
|
926 |
sHS_DIV -= 4; |
926 |
sHS_DIV -= 4; |
927 |
sN1 -= 1; |
927 |
sN1 -= 1; |
928 |
tempBuf[0] = (sHS_DIV << 5) | (sN1 >> 2); |
928 |
tempBuf[0] = (sHS_DIV << 5) | (sN1 >> 2); |
929 |
tempBuf[1] = (sN1 & 3) << 6; |
929 |
tempBuf[1] = (sN1 & 3) << 6; |
930 |
tempBuf[1] |= ((rfreq_integer_part >> 4) & 0x3f); |
930 |
tempBuf[1] |= ((rfreq_integer_part >> 4) & 0x3f); |
931 |
tempBuf[2] = ((rfreq_integer_part & 0x0f) << 4) | (rfreq_fraction_part >> 24); |
931 |
tempBuf[2] = ((rfreq_integer_part & 0x0f) << 4) | (rfreq_fraction_part >> 24); |
932 |
tempBuf[3] = rfreq_fraction_part >> 16; |
932 |
tempBuf[3] = rfreq_fraction_part >> 16; |
933 |
tempBuf[4] = rfreq_fraction_part >> 8; |
933 |
tempBuf[4] = rfreq_fraction_part >> 8; |
934 |
tempBuf[5] = rfreq_fraction_part; |
934 |
tempBuf[5] = rfreq_fraction_part; |
935 |
|
935 |
|
936 |
} |
936 |
} |
937 |
|
937 |
|
938 |
|
938 |
|
939 |
void SetNewFreq() |
939 |
void SetNewFreq() |
940 |
{ int i; |
940 |
{ int i; |
941 |
double freq_double; |
941 |
double freq_double; |
942 |
double delta_freq; |
942 |
double delta_freq; |
943 |
|
943 |
|
944 |
if(validCombo) |
944 |
if(validCombo) |
945 |
{ |
945 |
{ |
946 |
|
946 |
|
947 |
Freeze(); // freeze DCO |
947 |
Freeze(); // freeze DCO |
948 |
|
948 |
|
949 |
for (i=7; i<=12; i++){ //Data to Si570 |
949 |
for (i=7; i<=12; i++){ //Data to Si570 |
950 |
#if defined (UBW) |
950 |
#if defined (UBW) |
951 |
StartI2C(); |
951 |
StartI2C(); |
952 |
IdleI2C(); |
952 |
IdleI2C(); |
953 |
WriteI2C(i2c_adr<<1); |
953 |
WriteI2C(i2c_adr<<1); |
954 |
WriteI2C(i); //specify register |
954 |
WriteI2C(i); //specify register |
955 |
WriteI2C(tempBuf[i-7]); // new data to registers |
955 |
WriteI2C(tempBuf[i-7]); // new data to registers |
956 |
StopI2C(); |
956 |
StopI2C(); |
957 |
IdleI2C(); |
957 |
IdleI2C(); |
958 |
#elif defined (UBW32) |
958 |
#elif defined (UBW32) |
959 |
StartI2C1(); |
959 |
StartI2C1(); |
960 |
IdleI2C1(); |
960 |
IdleI2C1(); |
961 |
MasterWriteI2C1(i2c_adr<<1); |
961 |
MasterWriteI2C1(i2c_adr<<1); |
962 |
MasterWriteI2C1(i); //specify register |
962 |
MasterWriteI2C1(i); //specify register |
963 |
MasterWriteI2C1(tempBuf[i-7]); // new data to registers |
963 |
MasterWriteI2C1(tempBuf[i-7]); // new data to registers |
964 |
StopI2C1(); |
964 |
StopI2C1(); |
965 |
IdleI2C1(); |
965 |
IdleI2C1(); |
966 |
#endif |
966 |
#endif |
967 |
} |
967 |
} |
968 |
Unfreeze (); // thaw (unfreeze) |
968 |
Unfreeze (); // thaw (unfreeze) |
969 |
|
969 |
|
970 |
// check for smooth tune range |
970 |
// check for smooth tune range |
971 |
freq_double = Freq_From_Register(fcryst_double); |
971 |
freq_double = Freq_From_Register(fcryst_double); |
972 |
|
972 |
|
973 |
if (freq_double >= Old_freq_double) delta_freq = freq_double - Old_freq_double; |
973 |
if (freq_double >= Old_freq_double) delta_freq = freq_double - Old_freq_double; |
974 |
else delta_freq = Old_freq_double - freq_double; |
974 |
else delta_freq = Old_freq_double - freq_double; |
975 |
|
975 |
|
976 |
if (((delta_rfreq / Old_rfreq ) > Smooth_double) || (delta_freq > 0.5)){ |
976 |
if (((delta_rfreq / Old_rfreq ) > Smooth_double) || (delta_freq > 0.5)){ |
977 |
NewF (); // indicate new freq. This will cause a pause in the Si570 output |
977 |
NewF (); // indicate new freq. This will cause a pause in the Si570 output |
978 |
Old_rfreq = rfreq; |
978 |
Old_rfreq = rfreq; |
979 |
Old_freq_double = freq_double; |
979 |
Old_freq_double = freq_double; |
980 |
}; |
980 |
}; |
981 |
|
981 |
|
982 |
// set filters, using set freq without offset and multiplier |
982 |
// set filters, using set freq without offset and multiplier |
983 |
|
983 |
|
984 |
if (abpf_flag) Set_BPF((float) set_frequency); |
984 |
if (abpf_flag) Set_BPF((float) set_frequency); |
985 |
Set_LPF((float)set_frequency); |
985 |
Set_LPF((float)set_frequency); |
986 |
|
986 |
|
987 |
}; // valid combo |
987 |
}; // valid combo |
988 |
} |
988 |
} |
989 |
|
989 |
|
990 |
double Freq_From_Register(double fcryst){ // side effects: rfreq and delta_rfreq are set |
990 |
double Freq_From_Register(double fcryst){ // side effects: rfreq and delta_rfreq are set |
991 |
double freq_double; |
991 |
double freq_double; |
992 |
unsigned char n1; |
992 |
unsigned char n1; |
993 |
unsigned char hsdiv; |
993 |
unsigned char hsdiv; |
994 |
unsigned long rfreq_integer_portion, rfreq_fraction_portion; |
994 |
unsigned long rfreq_integer_portion, rfreq_fraction_portion; |
995 |
|
995 |
|
996 |
// Now find out the current rfreq and freq |
996 |
// Now find out the current rfreq and freq |
997 |
|
997 |
|
998 |
hsdiv = ((tempBuf[0] & 0xE0) >> 5) + 4; |
998 |
hsdiv = ((tempBuf[0] & 0xE0) >> 5) + 4; |
999 |
n1 = ((tempBuf[0] & 0x1f ) << 2 ) + ((tempBuf[1] & 0xc0 ) >> 6 ); |
999 |
n1 = ((tempBuf[0] & 0x1f ) << 2 ) + ((tempBuf[1] & 0xc0 ) >> 6 ); |
1000 |
// if(n1 == 0) n1 = 1; |
1000 |
// if(n1 == 0) n1 = 1; |
1001 |
// else if((n1 & 1) !=0) n1 += 1; |
1001 |
// else if((n1 & 1) !=0) n1 += 1; |
1002 |
n1 += 1; |
1002 |
n1 += 1; |
1003 |
|
1003 |
|
1004 |
rfreq_integer_portion = ((unsigned long)(tempBuf[1] & 0x3f)) << 4 | |
1004 |
rfreq_integer_portion = ((unsigned long)(tempBuf[1] & 0x3f)) << 4 | |
1005 |
((unsigned long)(tempBuf[2] & 0xf0)) >> 4; |
1005 |
((unsigned long)(tempBuf[2] & 0xf0)) >> 4; |
1006 |
|
1006 |
|
1007 |
rfreq_fraction_portion = ((unsigned long) (tempBuf[2] & 0x0f)) << 24; |
1007 |
rfreq_fraction_portion = ((unsigned long) (tempBuf[2] & 0x0f)) << 24; |
1008 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[3])) << 16; |
1008 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[3])) << 16; |
1009 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[4])) << 8; |
1009 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[4])) << 8; |
1010 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[5])); |
1010 |
rfreq_fraction_portion += ((unsigned long)(tempBuf[5])); |
1011 |
|
1011 |
|
1012 |
rfreq = (double)rfreq_integer_portion + ((double)rfreq_fraction_portion / (1L << 28)); |
1012 |
rfreq = (double)rfreq_integer_portion + ((double)rfreq_fraction_portion / (1L << 28)); |
1013 |
|
1013 |
|
1014 |
if (rfreq >= Old_rfreq) delta_rfreq = rfreq - Old_rfreq; |
1014 |
if (rfreq >= Old_rfreq) delta_rfreq = rfreq - Old_rfreq; |
1015 |
else delta_rfreq = Old_rfreq - rfreq; |
1015 |
else delta_rfreq = Old_rfreq - rfreq; |
1016 |
|
1016 |
|
1017 |
freq_double = fcryst * rfreq / (double) hsdiv / (double) n1; |
1017 |
freq_double = fcryst * rfreq / (double) hsdiv / (double) n1; |
1018 |
return (freq_double); |
1018 |
return (freq_double); |
1019 |
} |
1019 |
} |
1020 |
|
1020 |
|
1021 |
|
1021 |
|
1022 |
|
1022 |
|
1023 |
void Set_BPF(float freq){ // note the freq used is the Si570 freq |
1023 |
void Set_BPF(float freq){ // note the freq used is the Si570 freq |
1024 |
|
1024 |
|
1025 |
#if defined(YAS) |
1025 |
#if defined(YAS) |
1026 |
if (freq < FilterSwitchOver[0]) {BPF_S2 = 0;BPF_S1 = 0; BPF_S0 = 0;} |
1026 |
if (freq < FilterSwitchOver[0]) {BPF_S2 = 0;BPF_S1 = 0; BPF_S0 = 0;} |
1027 |
else if (freq < FilterSwitchOver[1]) {BPF_S2 = 0; BPF_S1=0;BPF_S0=1;} |
1027 |
else if (freq < FilterSwitchOver[1]) {BPF_S2 = 0; BPF_S1=0;BPF_S0=1;} |
1028 |
else if (freq < FilterSwitchOver[2]) {BPF_S2 = 0;BPF_S1=1;BPF_S0=0;} |
1028 |
else if (freq < FilterSwitchOver[2]) {BPF_S2 = 0;BPF_S1=1;BPF_S0=0;} |
1029 |
else if (freq < FilterSwitchOver[3]) {BPF_S2 = 0; BPF_S1 = 1; BPF_S0 = 1;} |
1029 |
else if (freq < FilterSwitchOver[3]) {BPF_S2 = 0; BPF_S1 = 1; BPF_S0 = 1;} |
1030 |
else if (freq < FilterSwitchOver[4]) {BPF_S2 = 1; BPF_S1 = 0; BPF_S0 = 0;} |
1030 |
else if (freq < FilterSwitchOver[4]) {BPF_S2 = 1; BPF_S1 = 0; BPF_S0 = 0;} |
1031 |
else if (freq < FilterSwitchOver[5]) {BPF_S2 = 1; BPF_S1 = 0; BPF_S0 = 1;} |
1031 |
else if (freq < FilterSwitchOver[5]) {BPF_S2 = 1; BPF_S1 = 0; BPF_S0 = 1;} |
1032 |
else if (freq < FilterSwitchOver[6]) {BPF_S2 = 1; BPF_S1 = 1; BPF_S0 = 0;} |
1032 |
else if (freq < FilterSwitchOver[6]) {BPF_S2 = 1; BPF_S1 = 1; BPF_S0 = 0;} |
1033 |
else {BPF_S2 = 1;BPF_S1=1; BPF_S0=1;}; |
1033 |
else {BPF_S2 = 1;BPF_S1=1; BPF_S0=1;}; |
1034 |
|
1034 |
|
1035 |
#else |
1035 |
#else |
1036 |
if (freq < FilterSwitchOver[0]) {BPF_S1 = 0; BPF_S0 = 0;} |
1036 |
if (freq < FilterSwitchOver[0]) {BPF_S1 = 0; BPF_S0 = 0;} |
1037 |
else if (freq < FilterSwitchOver[1]) {BPF_S1=0;BPF_S0=1;} |
1037 |
else if (freq < FilterSwitchOver[1]) {BPF_S1=0;BPF_S0=1;} |
1038 |
else if (freq < FilterSwitchOver[2]) {BPF_S1=1;BPF_S0=0;} |
1038 |
else if (freq < FilterSwitchOver[2]) {BPF_S1=1;BPF_S0=0;} |
1039 |
else {BPF_S1=1; BPF_S0=1;}; |
1039 |
else {BPF_S1=1; BPF_S0=1;}; |
1040 |
#endif |
1040 |
#endif |
1041 |
} |
1041 |
} |
1042 |
|
1042 |
|
1043 |
void Set_LPF(float freq){ |
1043 |
void Set_LPF(float freq){ |
1044 |
|
1044 |
|
1045 |
unsigned char LPF_select; |
1045 |
unsigned char LPF_select; |
1046 |
|
1046 |
|
1047 |
LPF_0 = 0; |
1047 |
LPF_0 = 0; |
1048 |
LPF_1 = 0; |
1048 |
LPF_1 = 0; |
1049 |
LPF_2 = 0; |
1049 |
LPF_2 = 0; |
1050 |
|
1050 |
|
1051 |
#if defined(YAS) |
1051 |
#if defined(YAS) |
1052 |
if (freq < LPFSwitchOver[0]) {LPF_0 = 0; LPF_1 = 0; LPF_2 = 0; LPF_select = 0x01;} |
1052 |
if (freq < LPFSwitchOver[0]) {LPF_0 = 0; LPF_1 = 0; LPF_2 = 0; LPF_select = 0x01;} |
1053 |
else if (freq < LPFSwitchOver[1]) {LPF_0 = 1; LPF_1 = 0; LPF_2 = 0; LPF_select = 0x02;} |
1053 |
else if (freq < LPFSwitchOver[1]) {LPF_0 = 1; LPF_1 = 0; LPF_2 = 0; LPF_select = 0x02;} |
1054 |
else if (freq < LPFSwitchOver[2]) {LPF_0 = 0; LPF_1 = 1; LPF_2 = 0; LPF_select = 0x04;} |
1054 |
else if (freq < LPFSwitchOver[2]) {LPF_0 = 0; LPF_1 = 1; LPF_2 = 0; LPF_select = 0x04;} |
1055 |
else if (freq < LPFSwitchOver[3]) {LPF_0 = 1; LPF_1 = 1; LPF_2 = 0; LPF_select = 0x08;} |
1055 |
else if (freq < LPFSwitchOver[3]) {LPF_0 = 1; LPF_1 = 1; LPF_2 = 0; LPF_select = 0x08;} |
1056 |
else if (freq < LPFSwitchOver[4]) {LPF_0 = 0; LPF_1 = 0; LPF_2 = 1; LPF_select = 0x10;} |
1056 |
else if (freq < LPFSwitchOver[4]) {LPF_0 = 0; LPF_1 = 0; LPF_2 = 1; LPF_select = 0x10;} |
1057 |
else if (freq < LPFSwitchOver[5]) {LPF_0 = 1; LPF_1 = 0; LPF_2 =1; LPF_select = 0x20;} |
1057 |
else if (freq < LPFSwitchOver[5]) {LPF_0 = 1; LPF_1 = 0; LPF_2 =1; LPF_select = 0x20;} |
1058 |
else if (freq < LPFSwitchOver[6]) {LPF_0 = 0; LPF_1 = 1; LPF_2 = 1; LPF_select = 0x40;} |
1058 |
else if (freq < LPFSwitchOver[6]) {LPF_0 = 0; LPF_1 = 1; LPF_2 = 1; LPF_select = 0x40;} |
1059 |
else {LPF_0 = 1; LPF_1 = 1; LPF_2 = 1; LPF_select = 0x80;}; |
1059 |
else {LPF_0 = 1; LPF_1 = 1; LPF_2 = 1; LPF_select = 0x80;}; |
1060 |
|
1060 |
|
1061 |
#else |
1061 |
#else |
1062 |
LPF_3 = 0; |
1062 |
LPF_3 = 0; |
1063 |
LPF_4 = 0; |
1063 |
LPF_4 = 0; |
1064 |
LPF_5 = 0; |
1064 |
LPF_5 = 0; |
1065 |
LPF_6 = 0; |
1065 |
LPF_6 = 0; |
1066 |
|
1066 |
|
1067 |
if (freq < LPFSwitchOver[0]) {LPF_0 = 1; LPF_select = 0x01;} |
1067 |
if (freq < LPFSwitchOver[0]) {LPF_0 = 1; LPF_select = 0x01;} |
1068 |
else if (freq < LPFSwitchOver[1]) {LPF_1 = 1; LPF_select = 0x02;} |
1068 |
else if (freq < LPFSwitchOver[1]) {LPF_1 = 1; LPF_select = 0x02;} |
1069 |
else if (freq <= LPFSwitchOver[2]) {LPF_2 = 1; LPF_select = 0x04;} |
1069 |
else if (freq <= LPFSwitchOver[2]) {LPF_2 = 1; LPF_select = 0x04;} |
1070 |
else if (freq < LPFSwitchOver[3]) {LPF_3 = 1; LPF_select = 0x08;} |
1070 |
else if (freq < LPFSwitchOver[3]) {LPF_3 = 1; LPF_select = 0x08;} |
1071 |
else if (freq < LPFSwitchOver[4]) {LPF_4 = 1; LPF_select = 0x10;} |
1071 |
else if (freq < LPFSwitchOver[4]) {LPF_4 = 1; LPF_select = 0x10;} |
1072 |
else if (freq < LPFSwitchOver[5]) {LPF_5 = 1; LPF_select = 0x20;} |
1072 |
else if (freq < LPFSwitchOver[5]) {LPF_5 = 1; LPF_select = 0x20;} |
1073 |
else if (freq < LPFSwitchOver[6]) {LPF_6 = 1; LPF_select = 0x40;} |
1073 |
else if (freq < LPFSwitchOver[6]) {LPF_6 = 1; LPF_select = 0x40;} |
1074 |
else {LPF_6 = 1; LPF_select = 0x80;}; |
1074 |
else {LPF_6 = 1; LPF_select = 0x80;}; |
1075 |
|
1075 |
|
1076 |
#endif |
1076 |
#endif |
1077 |
|
1077 |
|
1078 |
|
1078 |
|
1079 |
|
1079 |
|
1080 |
// Now use i2c bus to switch LPF |
1080 |
// Now use i2c bus to switch LPF |
1081 |
#if defined (UBW) |
1081 |
#if defined (UBW) |
1082 |
StartI2C(); |
1082 |
StartI2C(); |
1083 |
IdleI2C(); |
1083 |
IdleI2C(); |
1084 |
WriteI2C(PCF8574 << 1); |
1084 |
WriteI2C(PCF8574 << 1); |
1085 |
WriteI2C(LPF_select); |
1085 |
WriteI2C(LPF_select); |
1086 |
StopI2C(); |
1086 |
StopI2C(); |
1087 |
IdleI2C(); |
1087 |
IdleI2C(); |
1088 |
#elif defined (UBW32) |
1088 |
#elif defined (UBW32) |
1089 |
StartI2C1(); |
1089 |
StartI2C1(); |
1090 |
IdleI2C1(); |
1090 |
IdleI2C1(); |
1091 |
MasterWriteI2C1(PCF8574 << 1); |
1091 |
MasterWriteI2C1(PCF8574 << 1); |
1092 |
MasterWriteI2C1(LPF_select); |
1092 |
MasterWriteI2C1(LPF_select); |
1093 |
StopI2C1(); |
1093 |
StopI2C1(); |
1094 |
IdleI2C1(); |
1094 |
IdleI2C1(); |
1095 |
#endif |
1095 |
#endif |
1096 |
|
1096 |
|
1097 |
|
1097 |
|
1098 |
} |
1098 |
} |
1099 |
|
1099 |
|
1100 |
void SetFrequency(double f) |
1100 |
void SetFrequency(double f) |
1101 |
{ |
1101 |
{ |
1102 |
// introduce the offset and mul here |
1102 |
// introduce the offset and mul here |
1103 |
RunFreqProg((f - ((double)f_sub.qw / (double)(1L << 21))) * (double)f_mul.qw/(double)(1L <<21)); |
1103 |
RunFreqProg((f - ((double)f_sub.qw / (double)(1L << 21))) * (double)f_mul.qw/(double)(1L <<21)); |
1104 |
SetNewFreq(); |
1104 |
SetNewFreq(); |
1105 |
} |
1105 |
} |
1106 |
|
1106 |
|
1107 |
void Set_Freq_Handler(void){ // 4 byte freq value in avr_freq format |
1107 |
void Set_Freq_Handler(void){ // 4 byte freq value in avr_freq format |
1108 |
BYTE i; |
1108 |
BYTE i; |
1109 |
|
1109 |
|
1110 |
if (command_buffer[current_command_out].wCount == 4){ |
1110 |
if (command_buffer[current_command_out].wCount == 4){ |
1111 |
for (i=0; i<4; i++) avr_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1111 |
for (i=0; i<4; i++) avr_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1112 |
set_frequency = (double) avr_freq.qw / (double)(1L << 21); |
1112 |
set_frequency = (double) avr_freq.qw / (double)(1L << 21); |
1113 |
SetFrequency(set_frequency); |
1113 |
SetFrequency(set_frequency); |
1114 |
} |
1114 |
} |
1115 |
} |
1115 |
} |
1116 |
|
1116 |
|
1117 |
void Set_Register_Handler(void){ // 6 byte register value |
1117 |
void Set_Register_Handler(void){ // 6 byte register value |
1118 |
unsigned char i; |
1118 |
unsigned char i; |
1119 |
|
1119 |
|
1120 |
if (command_buffer[current_command_out].wCount == 6){ |
1120 |
if (command_buffer[current_command_out].wCount == 6){ |
1121 |
for (i=0; i<6; i++) tempBuf[i] = command_buffer[current_command_out].data[i]; |
1121 |
for (i=0; i<6; i++) tempBuf[i] = command_buffer[current_command_out].data[i]; |
1122 |
set_frequency = Freq_From_Register(DEFAULT_FCRYST); |
1122 |
set_frequency = Freq_From_Register(DEFAULT_FCRYST); |
1123 |
SetFrequency(set_frequency); |
1123 |
SetFrequency(set_frequency); |
1124 |
} |
1124 |
} |
1125 |
} |
1125 |
} |
1126 |
|
1126 |
|
1127 |
void Set_Cal_Handler(void){ |
1127 |
void Set_Cal_Handler(void){ |
1128 |
|
1128 |
|
1129 |
// 4 bytes of fcryst freq in avr_freq format |
1129 |
// 4 bytes of fcryst freq in avr_freq format |
1130 |
int i; |
1130 |
int i; |
1131 |
|
1131 |
|
1132 |
if (command_buffer[current_command_out].wCount == 4){ |
1132 |
if (command_buffer[current_command_out].wCount == 4){ |
1133 |
|
1133 |
|
1134 |
for (i=0; i<4; i++)fcryst_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1134 |
for (i=0; i<4; i++)fcryst_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1135 |
fcryst_double = (double) fcryst_freq.qw / (double)(1L << 24); |
1135 |
fcryst_double = (double) fcryst_freq.qw / (double)(1L << 24); |
1136 |
|
1136 |
|
1137 |
#if defined(UBW) |
1137 |
#if defined(UBW) |
1138 |
for (i=0; i<4; i++){ |
1138 |
for (i=0; i<4; i++){ |
1139 |
Write_b_eep (i+F_CAL_DONE+1, fcryst_freq.bytes[i]); |
1139 |
Write_b_eep (i+F_CAL_DONE+1, fcryst_freq.bytes[i]); |
1140 |
Busy_eep (); |
1140 |
Busy_eep (); |
1141 |
}; |
1141 |
}; |
1142 |
#elif defined (UBW32) |
1142 |
#elif defined (UBW32) |
1143 |
DataEEWrite( (unsigned int) fcryst_freq.qw, (F_CAL_DONE + 1)); |
1143 |
DataEEWrite( (unsigned int) fcryst_freq.qw, (F_CAL_DONE + 1)); |
1144 |
#endif |
1144 |
#endif |
1145 |
|
1145 |
|
1146 |
#if defined (UBW) |
1146 |
#if defined (UBW) |
1147 |
Write_b_eep(F_CAL_DONE, F_CAL_DONE_VALUE); |
1147 |
Write_b_eep(F_CAL_DONE, F_CAL_DONE_VALUE); |
1148 |
Busy_eep(); |
1148 |
Busy_eep(); |
1149 |
#elif defined (UBW32) |
1149 |
#elif defined (UBW32) |
1150 |
DataEEWrite(F_CAL_DONE_VALUE, F_CAL_DONE); |
1150 |
DataEEWrite(F_CAL_DONE_VALUE, F_CAL_DONE); |
1151 |
#endif |
1151 |
#endif |
1152 |
}; |
1152 |
}; |
1153 |
} |
1153 |
} |
1154 |
|
1154 |
|
1155 |
void Set_Init_Freq_Handler(void) |
1155 |
void Set_Init_Freq_Handler(void) |
1156 |
{ |
1156 |
{ |
1157 |
#if defined (UBW) |
1157 |
#if defined (UBW) |
1158 |
unsigned char i; |
1158 |
unsigned char i; |
1159 |
#else |
1159 |
#else |
1160 |
unsigned int i; |
1160 |
unsigned int i; |
1161 |
#endif |
1161 |
#endif |
1162 |
|
1162 |
|
1163 |
if (command_buffer[current_command_out].wCount == 4){ |
1163 |
if (command_buffer[current_command_out].wCount == 4){ |
1164 |
for (i=0; i<4; i++) avr_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1164 |
for (i=0; i<4; i++) avr_freq.bytes[i] = command_buffer[current_command_out].data[i]; |
1165 |
#if defined (UBW) |
1165 |
#if defined (UBW) |
1166 |
for (i=0; i<4; i++){ |
1166 |
for (i=0; i<4; i++){ |
1167 |
Write_b_eep((i + F_INIT_FREQ +1), avr_freq.bytes[i]); |
1167 |
Write_b_eep((i + F_INIT_FREQ +1), avr_freq.bytes[i]); |
1168 |
Busy_eep(); |
1168 |
Busy_eep(); |
1169 |
}; |
1169 |
}; |
1170 |
#elif defined (UBW32) |
1170 |
#elif defined (UBW32) |
1171 |
DataEEWrite( (unsigned int) avr_freq.qw, (F_INIT_FREQ +1)); |
1171 |
DataEEWrite( (unsigned int) avr_freq.qw, (F_INIT_FREQ +1)); |
1172 |
#endif |
1172 |
#endif |
1173 |
|
1173 |
|
1174 |
#if defined (UBW) |
1174 |
#if defined (UBW) |
1175 |
Write_b_eep(F_INIT_FREQ, F_INIT_FREQ_VALUE); |
1175 |
Write_b_eep(F_INIT_FREQ, F_INIT_FREQ_VALUE); |
1176 |
Busy_eep(); |
1176 |
Busy_eep(); |
1177 |
#elif defined (UBW32) |
1177 |
#elif defined (UBW32) |
1178 |
DataEEWrite(F_INIT_FREQ_VALUE, F_INIT_FREQ); |
1178 |
DataEEWrite(F_INIT_FREQ_VALUE, F_INIT_FREQ); |
1179 |
#endif |
1179 |
#endif |
1180 |
}; |
1180 |
}; |
1181 |
} |
1181 |
} |
1182 |
|
1182 |
|
1183 |
void Set_Sub_Mul_Handler(void) |
1183 |
void Set_Sub_Mul_Handler(void) |
1184 |
{ |
1184 |
{ |
1185 |
#if defined (UBW) |
1185 |
#if defined (UBW) |
1186 |
unsigned char i; |
1186 |
unsigned char i; |
1187 |
#else |
1187 |
#else |
1188 |
unsigned int i; |
1188 |
unsigned int i; |
1189 |
#endif |
1189 |
#endif |
1190 |
|
1190 |
|
1191 |
avr_freq_t old_f_mul; |
1191 |
avr_freq_t old_f_mul; |
1192 |
offset_t old_f_sub; |
1192 |
offset_t old_f_sub; |
1193 |
double filter_value; |
1193 |
double filter_value; |
1194 |
|
1194 |
|
1195 |
|
1195 |
|
1196 |
if (command_buffer[current_command_out].wCount == 8){ |
1196 |
if (command_buffer[current_command_out].wCount == 8){ |
1197 |
|
1197 |
|
1198 |
old_f_sub = f_sub; // save old values first |
1198 |
old_f_sub = f_sub; // save old values first |
1199 |
old_f_mul = f_mul; |
1199 |
old_f_mul = f_mul; |
1200 |
|
1200 |
|
1201 |
for (i=0; i<4; i++) f_sub.bytes[i] = command_buffer[current_command_out].data[i]; |
1201 |
for (i=0; i<4; i++) f_sub.bytes[i] = command_buffer[current_command_out].data[i]; |
1202 |
for (i=0; i<4; i++) f_mul.bytes[i] = command_buffer[current_command_out].data[i+4]; |
1202 |
for (i=0; i<4; i++) f_mul.bytes[i] = command_buffer[current_command_out].data[i+4]; |
1203 |
#if defined (UBW) |
1203 |
#if defined (UBW) |
1204 |
for (i=0; i<4; i++){ |
1204 |
for (i=0; i<4; i++){ |
1205 |
Write_b_eep((i + F_SUB_MUL +1), f_sub.bytes[i]); |
1205 |
Write_b_eep((i + F_SUB_MUL +1), f_sub.bytes[i]); |
1206 |
Busy_eep(); |
1206 |
Busy_eep(); |
1207 |
}; |
1207 |
}; |
1208 |
for (i=0; i<4; i++){ |
1208 |
for (i=0; i<4; i++){ |
1209 |
Write_b_eep((i + F_SUB_MUL +5), f_mul.bytes[i]); |
1209 |
Write_b_eep((i + F_SUB_MUL +5), f_mul.bytes[i]); |
1210 |
Busy_eep(); |
1210 |
Busy_eep(); |
1211 |
}; |
1211 |
}; |
1212 |
#elif defined (UBW32) |
1212 |
#elif defined (UBW32) |
1213 |
DataEEWrite( (unsigned int) f_sub.qw, (F_SUB_MUL +1)); |
1213 |
DataEEWrite( (unsigned int) f_sub.qw, (F_SUB_MUL +1)); |
1214 |
DataEEWrite( (unsigned int) f_mul.qw, (F_SUB_MUL +5)); |
1214 |
DataEEWrite( (unsigned int) f_mul.qw, (F_SUB_MUL +5)); |
1215 |
#endif |
1215 |
#endif |
1216 |
|
1216 |
|
1217 |
#if defined (UBW) |
1217 |
#if defined (UBW) |
1218 |
Write_b_eep(F_SUB_MUL, F_SUB_MUL_VALUE); |
1218 |
Write_b_eep(F_SUB_MUL, F_SUB_MUL_VALUE); |
1219 |
Busy_eep(); |
1219 |
Busy_eep(); |
1220 |
#elif defined (UBW32) |
1220 |
#elif defined (UBW32) |
1221 |
DataEEWrite(F_SUB_MUL_VALUE, F_SUB_MUL); |
1221 |
DataEEWrite(F_SUB_MUL_VALUE, F_SUB_MUL); |
1222 |
#endif |
1222 |
#endif |
1223 |
|
1223 |
|
1224 |
// Now update the filter switchover points as well |
1224 |
// Now update the filter switchover points as well |
1225 |
for (i = 0; i < (NUM_BPF - 1); i++){ |
1225 |
for (i = 0; i < (NUM_BPF - 1); i++){ |
1226 |
// get back filter_value in Mhz |
1226 |
// get back filter_value in Mhz |
1227 |
filter_value = FilterSwitchOver[i] / (old_f_mul.qw / ((double) (1L << 21))) / 4 + (old_f_sub.qw / ((double) (1L << 21))); |
1227 |
filter_value = FilterSwitchOver[i] / (old_f_mul.qw / ((double) (1L << 21))) / 4 + (old_f_sub.qw / ((double) (1L << 21))); |
1228 |
// now convert to new translated values |
1228 |
// now convert to new translated values |
1229 |
FilterSwitchOver[i] = (filter_value - (f_sub.qw / (double)(1L << 21))) * (f_mul.qw / (double)(1L << 21)) * 4; |
1229 |
FilterSwitchOver[i] = (filter_value - (f_sub.qw / (double)(1L << 21))) * (f_mul.qw / (double)(1L << 21)) * 4; |
1230 |
FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
1230 |
FilterCrossOver[i] = Switch2Cross(FilterSwitchOver[i]); |
1231 |
}; |
1231 |
}; |
1232 |
for (i = 0; i < 7; i++){ |
1232 |
for (i = 0; i < 7; i++){ |
1233 |
// get back filter_value in Mhz |
1233 |
// get back filter_value in Mhz |
1234 |
filter_value = LPFSwitchOver[i] / (old_f_mul.qw / ((double) (1L << 21))) / 4 + (old_f_sub.qw / ((double) (1L << 21))); |
1234 |
filter_value = LPFSwitchOver[i] / (old_f_mul.qw / ((double) (1L << 21))) / 4 + (old_f_sub.qw / ((double) (1L << 21))); |
1235 |
// now convert to new translated values |
1235 |
// now convert to new translated values |
1236 |
LPFSwitchOver[i] = (filter_value - (f_sub.qw / (double)(1L << 21))) * (f_mul.qw / (double)(1L << 21)) * 4; |
1236 |
LPFSwitchOver[i] = (filter_value - (f_sub.qw / (double)(1L << 21))) * (f_mul.qw / (double)(1L << 21)) * 4; |
1237 |
LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
1237 |
LPFCrossOver[i] = Switch2Cross(LPFSwitchOver[i]); |
1238 |
}; |
1238 |
}; |
1239 |
}; // if wCount == 8 |
1239 |
}; // if wCount == 8 |
1240 |
} |
1240 |
} |
1241 |
|
1241 |
|
1242 |
|
1242 |
|
1243 |
|
1243 |
|
1244 |
|
1244 |
|
1245 |
void Set_Smooth_Handler(void) |
1245 |
void Set_Smooth_Handler(void) |
1246 |
{ |
1246 |
{ |
1247 |
WORD_VAL w; |
1247 |
WORD_VAL w; |
1248 |
unsigned int i; |
1248 |
unsigned int i; |
1249 |
|
1249 |
|
1250 |
if (command_buffer[current_command_out].wCount == 2){ // 2 bytes of Smooth Tune value in ppm |
1250 |
if (command_buffer[current_command_out].wCount == 2){ // 2 bytes of Smooth Tune value in ppm |
1251 |
w.v[0] = command_buffer[current_command_out].data[0]; |
1251 |
w.v[0] = command_buffer[current_command_out].data[0]; |
1252 |
w.v[1] = command_buffer[current_command_out].data[1]; |
1252 |
w.v[1] = command_buffer[current_command_out].data[1]; |
1253 |
|
1253 |
|
1254 |
Smooth_double = (double) w.Val / 1000000L; |
1254 |
Smooth_double = (double) w.Val / 1000000L; |
1255 |
|
1255 |
|
1256 |
#if defined (UBW) |
1256 |
#if defined (UBW) |
1257 |
for (i=0; i<2; i++){ |
1257 |
for (i=0; i<2; i++){ |
1258 |
Write_b_eep (i+F_SMOOTH+1, w.v[i]); |
1258 |
Write_b_eep (i+F_SMOOTH+1, w.v[i]); |
1259 |
Busy_eep (); |
1259 |
Busy_eep (); |
1260 |
}; |
1260 |
}; |
1261 |
|
1261 |
|
1262 |
#elif defined (UBW32) |
1262 |
#elif defined (UBW32) |
1263 |
DataEEWrite( (unsigned int) w.Val, (i + F_SMOOTH + 1)); |
1263 |
DataEEWrite( (unsigned int) w.Val, (i + F_SMOOTH + 1)); |
1264 |
#endif |
1264 |
#endif |
1265 |
|
1265 |
|
1266 |
#if defined (UBW) |
1266 |
#if defined (UBW) |
1267 |
Write_b_eep(F_SMOOTH, F_SMOOTH_VALUE); |
1267 |
Write_b_eep(F_SMOOTH, F_SMOOTH_VALUE); |
1268 |
Busy_eep(); |
1268 |
Busy_eep(); |
1269 |
#elif defined (UBW32) |
1269 |
#elif defined (UBW32) |
1270 |
DataEEWrite( F_SMOOTH_VALUE, F_SMOOTH); |
1270 |
DataEEWrite( F_SMOOTH_VALUE, F_SMOOTH); |
1271 |
#endif |
1271 |
#endif |
1272 |
|
1272 |
|
1273 |
} |
1273 |
} |
1274 |
} |
1274 |
} |
1275 |
|
1275 |
|
1276 |
|
1276 |
|
1277 |
|
1277 |
|
1278 |
/** EOF user.c ***************************************************************/ |
1278 |
/** EOF user.c ***************************************************************/ |