Rev Author Line No. Line
952 miho 1 //**********************************************************************
2 // program pro rizeni TRXu
3 //**********************************************************************
4 // (c) OK1XGL 2005
5 // verze 1.0.0 - uvodni verze
6 // verze 1.0.1 - prechod 16F877 a usazeni sibnalu na porty
7 // verze 1.0.2 = odladeni zakladnich funkci - muzeme delat tistak
8 // verze 1.0.3 - definitivni usazeni signalu - hotovy DPS
9 // verze 1.0.4 - prvni pouzitelna verze
10 // verze 1.1.0 - SIGNAL ATN1 PRESUNUT NA RE0 A SIGNAL ATN2 PRESUNUT NA RC0 !!!!!
11 // verze 1.2.0 - doprobramovan jednopakovy klic
12 // verze 1.3.0 - elbug zmenen na dvoupakovy a cely presunut do preruseni
13 // verze 1.4.0 - po zapnuti se RX naladi na QRP kmitocet na danem pasmu
14 // - PSV se povazuje za platne jen kdyz je skutecne zaklicovano
15 // verze 1.5.0 - upraven zpusob cteni dat z AD prevodniku
16 // - pwm rozsirena na 157 kroku
17 // - doplneno ALC pro vykon a nastaveni vykonu v 0.5W jednotkach
18 // verze 1.6.0 - provedena kalibrace S-metru
19  
20  
21 // Poznamky:
22 // zobrazeni kmitoctu na LCD trva 30ms !!!
23 // pri rychlosti klicovani 200zn/s je sirka impulzu (tecka) cca 30ms
24 // timer2 vyhrazen na generovani tonu a ma nastaven kmitocet 800Hz, ton se generuje PWM, rizeni vykonu tez PWM 800Hz je baze
25 // timer 1 vyhrazen pro elbug
26  
27  
28 //DODELAT: - pri BK provozu je treba, aby se pri prepnuti na prjem mezi elementy znacky nezobrazoval S-metr, protoze
29 // se to tak rychle nestiha zobrazovat a je lepsi,aby se zobrazovalo stale psv a vykon. Nyni je toho dosazeno tak,
30 // ze pokud je aktivni elbug, tak se zobrazeni nedela ovsem toto reseni nebude fungovat pri externim elbugu
31 // spravne reseni je timerem, ktery bude vykryvat cas mezi znackami
32 // - projit kod a nektere veci ucesat
33  
34  
35  
36 #include "vfo.h"
37 #include <lcd.c>
38  
39  
40 //#define ADC_LCD // misto obvyklych udaju zobrazuje hodnoty AD prevodniku
41 //#define NO_FILTER_CONTROL // vyrazuje prubeznou kontrolu pritomnosti filtru pro prislusne pasmo
42  
43  
44 /////////// FUNKCE PRO ZOBRAZOVANI NA LCD /////////
45  
46 // podpora zobrazeni RIT
47 // POZOR: pred pouzitim je nutno vynulovat promennou lcd_pos !!!
48 void rit_lcd_putc(int8 c)
49 {
50 lcd_pos++;
51 if(lcd_pos==2) lcd_putc('.'); // prida tecku za KHZ
52 lcd_putc(c);
53 } // rit_lcd_putc
54  
55  
56  
57 // podpora zobrazeni kmitoctu VFO
58 // POZOR: pred pouzitim je nutno vynulovat promennou lcd_pos !!!
59 void vfo_lcd_putc(int8 c)
60 {
61 lcd_pos++;
62 // za MHz dopln pismenko VFO
63 if(lcd_pos==3)
64 if(vfo_index)
65 if(bit_test(_SPLIT)) lcd_putc('\21'); // vyplnene b
66 else lcd_putc('b');
67 else if(bit_test(_SPLIT)) lcd_putc('\22'); // vyplnene a
68 else lcd_putc('a');
69 // za KHz dopln tecku
70 if(lcd_pos==6)
71 if(step_index) lcd_putc(':'); // hrube ladeni
72 else lcd_putc('.'); // jemne ladeni
73 lcd_putc(c);
74 } //vfo_lcd_putc
75  
76  
77 // podpora zobrazeni vykonu a psv
78 // POZOR: pred pouzitim je nutno vynulovat promennou lcd_pos !!!
79 void pwr_lcd_putc(int8 c)
80 {
81 lcd_pos++;
82 if(lcd_pos==2) lcd_putc('.');
83 lcd_putc(c);
84 } // pwr_lcd_putc
85  
86  
87  
88 // podpora zobrazeni napeti baterie
89 // POZOR: pred pouzitim je nutno vynulovat promennou lcd_pos !!!
90 void batt_lcd_putc(int8 c)
91 {
92 lcd_pos++;
93 if(lcd_pos==3) lcd_putc('.');
94 lcd_putc(c);
95 } // batt_lcd_putc
96  
97  
98  
99  
100 /////////// FUNKCE PRO PRACI S DDS /////////
101  
102 // odesle 16 bitovy zaznam do DDS
103 //
104 void dds_send(int16 record)
105 {
106 int8 i;
107 #use fast_io(A)
108 #use fast_io(B)
109 #use fast_io(C)
110 #use fast_io(D)
111  
112 output_low(DDS_FSYNC); // zacatek komunikace s DDS
113 i=16;
114 do
115 {
116 if(bit_test(record,15)) output_high(DDS_SDATA); // vystav datovy bit, zaciname MSB
117 else output_low(DDS_SDATA);
118 output_low(DDS_SCK); // hodinovy impulz
119 output_high(DDS_SCK);
120 record=record<<1; // na dalsi bit
121 } while(--i);
122  
123 output_high(DDS_FSYNC); // konec komunikace s DDS
124 #use standard_io(A)
125 #use standard_io(B)
126 #use standard_io(C)
127 #use standard_io(D)
128 } // dds_send
129  
130  
131  
132  
133 // naplni registr0 pro kmitocet v DDS (28 bitu)
134 //
135 void dds_freq0(int32 freq)
136 {
137 int16 record;
138  
139 // posli ridici slovo
140 dds_send(CTRL_FREQ0);
141  
142 // zapis pozadovane frekvence
143 // zapis LSB
144 record=(int16)freq;
145 bit_set(record,14); // zapis do frekvencniho registru 0
146 bit_clear(record,15);
147 dds_send(record);
148 // zapis MSB
149 record=(int16)((freq<<2)>>16); // divny zapis, ale >> 14 dava hrozny vysledek
150 bit_set(record,14); // zapis do frekvencniho registru 0
151 bit_clear(record,15);
152 dds_send(record);
153 } // dds_freq0
154  
155  
156  
157 /////////// FUNKCE PRO RIZENI PRIPOSLECHU /////////
158  
159 // vypne generovani tonu priposlechu
160 //
161 #inline
162 void tone_off()
163 {
164 int8 a;
165 a=input(TONE);
166 } // tone_off()
167  
168  
169  
170 // zapne generovani tonu priposlechu
171 //
172 #inline
173 void tone_on()
174 {
175 output_low(TONE);
176 } // tone_on
177  
178  
179  
180  
181 /////////////////////////////////
182 // Prerusovaci rutiny
183 /////////////////////////////////
184 // rezie preruseni je cca 30+30 cyklu
185  
186 // preruseni od zmeny polohy kroutitka
187 #int_EXT
188 void Encoder_handler()
189 {
190 #use fast_io(a)
191 #use fast_io(b)
192 #use fast_io(c)
193 #use fast_io(d)
194  
195  
196 int1 dir;
197  
198 dir=input(ENCODER_DIR); // zapamatuj si smer krouceni
199 bit_set(_ENC_CHNG); // oznam zmenu polohy kroutitka
200 if(dir) enc_delta++; // pridej
201 else enc_delta--; // uber
202  
203 #use standard_io(a)
204 #use standard_io(b)
205 #use standard_io(c)
206 #use standard_io(d)
207 } // Encoder_handler
208  
209  
210  
211 // periodicke tiky, granularita TICK_TIME
212 // citace/ casovace se granularitou TICK_TIME
213 #INT_TIMER0
214 void Tick_handler()
215 {
216 #use fast_io(a)
217 #use fast_io(b)
218 #use fast_io(c)
219 #use fast_io(d)
220  
221 set_timer0(TICK_TIME); // znovu natahni timer
222  
223 // mereni napeti z prevodniku
224 if(bit_test(_ADC_START))
225 {
226 read_adc(ADC_START_ONLY); // spust prevod
227 bit_clear(_ADC_START); // priste budeme cist vysledek
228 } else
229 {
230 adc_val=read_adc(ADC_READ_ONLY); // vyzvedni vysledek
231  
232 if(bit_test(_KEYING)) // hodnoty vykonu aktualizuj jen pokud je zaklicovano
233 {
234 if(adc_ch==1) fwd_val=adc_val;
235 if(adc_ch==0) rev_val=adc_val;
236 }
237 if(adc_ch==2) batt_val=adc_val;
238 else if(adc_ch==3) smtr_val=adc_val;
239 else if(adc_ch==4) bnd_val=adc_val;
240 if(adc_ch>=4) adc_ch=0; // mame 5 kanalu
241 else adc_ch++;
242 set_adc_channel(adc_ch); // priste nasledujici kanal
243 bit_set(_ADC_START); // priste budeme spoustet prevod
244 }
245  
246 // klicovani
247 if(bit_test(_TXDELAY)) // jen pokud tx_delay vyprsel
248 {
249 if(!bit_test(_ELBUG_ON))
250 keyer=(~input_b()) & 0b10000000; // pokud neni zapnut elbug, zavzorkuj stav klice
251  
252 if((keyer!=0 && !bit_test(_ELBUG_ON)) || // pri vypnutem elbugu rizeno stavem pak
253 (bit_test(_ELBUG_OUT) && bit_test(_ELBUG_ON))) // pri zapnutem elbugu rizeno stavem _ELBUG_ON
254 {
255 // zaklicuj
256 output_high(KEYING);
257 tone_on();
258 bit_clear(_RUN_VOX);
259 bit_set(_KEYING);
260 adc_ch=0; // zacneme merit dopredny vykon
261 set_adc_channel(adc_ch);
262 bit_set(_ADC_START); // priste spustime prevod ADC
263 } else
264 {
265 // prestan klicovat
266 output_low(KEYING);
267 vox_timer=vox_time; // natahni vox_timer
268 bit_set(_RUN_VOX);
269 tone_off();
270 bit_clear(_KEYING);
271 }
272 bit_clear(_TXDELAY);
273 }
274  
275  
276 // periodicky timer na aktualizaci kde ceho
277 if(update_timer==0xFF) update_timer=UPDATE_TIME;
278 else update_timer--;
279  
280 // vox timer
281 if(bit_test(_RUN_VOX))
282 if(vox_timer!=0) vox_timer--;
283 else
284 {
285 // vox vyprsel
286 bit_clear(_RUN_VOX);
287 output_low(RXTX); // prepni zpet na prijem
288 bit_clear(_TRANSMIT);
289 bit_set(_DDS_UPDATE);
290 }
291  
292 // timer pro zjisteni dlouheho stisku tlacitek
293 if(key_timer!=0) key_timer--;
294  
295  
296 // periodicke cteni tlacitek
297 #use fast_io(C)
298 keys_work=(~input_c()) & KEY_MASK; // precti stav tlacitek
299 #use standard_io(C)
300 if(keys_work!=keys_old) keys_old=keys_work; // neshoda zapamatuj si novy stav
301 else
302 {
303 // shoda
304 if(keys_work!=0)
305 {
306 // tlacitko je STISKNUTO
307 if(keys==0)
308 {
309 // akceptujeme jen pokud bylo zpracovano vse predchozi
310 keys=keys_work; // zapamatuj si nove tlacitko
311 key_timer=KEY_LONG; // natahni casovac pro zjisteni dlouheho stisku
312 } else
313 {
314 // neco je jeste ke zpracovani
315 if(key_timer==0 && !bit_test(_KEYS_RELEASE))
316 {
317 // jde o dlouhy stisk tlacitka
318 bit_set(_KEYS_LONG);
319 bit_set(_KEYS_VALID);
320 }
321 }
322 } else
323 {
324 // tlacitko je UVOLNENO
325 if(key_timer!=0)
326 {
327 // jde o kratky stisk tlacitka
328 bit_set(_KEYS_VALID);
329 key_timer=0;
330 } else if(bit_test(_KEYS_RELEASE))
331 {
332 keys_flags=0; // jde o klidovy stav - tlacitka zpracovana
333 keys=0;
334 }
335 }
336 }
337  
338 #use standard_io(a)
339 #use standard_io(b)
340 #use standard_io(c)
341 #use standard_io(d)
342 } // Tick_handler
343  
344  
345  
346  
347 // periodicke tiky kazdych 5ms
348 // vyuzito pro rizeli LCD_LED
349 //
350 #INT_TIMER2
351 void led_handler()
352 {
353 #use fast_io(a)
354 #use fast_io(b)
355 #use fast_io(c)
356 #use fast_io(d)
357  
358  
359 flash_timer++;
360  
361 // rizeni LED
362 // pri prijmu bez attenuatoru sviti zelena
363 // pri prijmu s attenuatorem sviti zluta
364 // pri vysilani sviti cervena
365 // pri vybite baterii pri prijmu led blika
366  
367  
368 if(bit_test(_TRANSMIT))
369 {
370 // vysilani - rozsvid cervenou LED
371 if(bit_test(_LED_UPDATE)) output_high(LCD_LED1);
372 else output_low(LCD_LED1);
373 output_low(LCD_LED2);
374 } else
375 {
376 if(bit_test(_BATT_LOW) && bit_test(flash_timer,7))
377 {
378 // zhasni led
379 output_low(LCD_LED1);
380 output_low(LCD_LED2);
381 } else
382 {
383 // prijem - rozsvid zelenou nebo zlutou led
384 if(bit_test(_LED_UPDATE))
385 {
386 output_high(LCD_LED2);
387 output_low(LCD_LED1);
388 } else
389 {
390 output_low(LCD_LED2);
391 if(bit_test(_ATTN)) output_high(LCD_LED1);
392 else output_low(LCD_LED1);
393 }
394 }
395 }
396  
397 if(bit_test(_LED_UPDATE)) bit_clear(_LED_UPDATE);
398 else bit_set(_LED_UPDATE);
399  
400 #use standard_io(a)
401 #use standard_io(b)
402 #use standard_io(c)
403 #use standard_io(d)
404 } // led_handler
405  
406  
407  
408  
409 // cteni pak, klice
410 #INT_RB
411 void paddle_handler()
412 {
413 #use fast_io(a)
414 #use fast_io(b)
415 #use fast_io(c)
416 #use fast_io(d)
417  
418 keyerb=(~input_b()); // precti stav pak
419 if(bit_test(_ELBUG_ON)) keyerb=keyerb & 0b11000000; // platne jsou obe paky
420 else keyerb=keyerb & 0b10000000; // platna je paka tecek
421  
422 if(!bit_test(_TXDELAY)) // reagujeme jen kdyz nebezi TXDELAY
423 {
424 if(!bit_test(_ELBUG_ON))
425 {
426 // RUCNI KLICOVANI
427 set_timer0(TICK_TIME); // txdelay je dano jednim zakladnim tikem, natahni tik
428 _T0IF=0;
429 bit_set(_TXDELAY); // spustime TXDELAY
430 } else
431 {
432 // ELBUG
433 // nastav priznaky pak
434 if(bit_test(_ELBUG_REV))
435 {
436 if(bit_test(keyerb,6)) bit_set(_ELBUG_DOT);
437 if(bit_test(keyerb,7)) bit_set(_ELBUG_DASH);
438 } else
439 {
440 if(bit_test(keyerb,7)) bit_set(_ELBUG_DOT);
441 if(bit_test(keyerb,6)) bit_set(_ELBUG_DASH);
442 }
443 if(!bit_test(_ELBUG_BSY))
444 {
445 // spusteni elbugu
446 setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); // spust casovac
447 _TMR1IF=1;
448 }
449 }
450 if(!bit_test(_TRANSMIT) && keyerb!=0) // pri stisku pak prejdeme na vysilani pokud tomu jiz tak neni
451 {
452 bit_set(_TRANSMIT); // priznak stavu vysilani
453 output_high(RXTX); // prepni TRX na vysilani
454 bit_set(_DDS_UPDATE); // nastav vysilaci kmitocet
455 }
456 }
457  
458 #use standard_io(a)
459 #use standard_io(b)
460 #use standard_io(c)
461 #use standard_io(d)
462 } // paddle_handler
463  
464  
465  
466 // elbug
467 //
468 #int_timer1
469 void elbug_handler()
470 {
471 #use fast_io(a)
472 #use fast_io(b)
473 #use fast_io(c)
474 #use fast_io(d)
475  
476  
477 if(bit_test(_ELBUG_SP))
478 {
479 // odvysilali jsem tecku nebo carku - musime dovysilat mezeru
480 bit_clear(_ELBUG_SP); // priste budeme vysilat podle stavu pak
481 bit_clear(_ELBUG_OUT);
482 set_timer1(elbug_dot_sp); // natahni casovac na mezeru
483 set_timer0(TICK_TIME); // txdelay je dano jednim zakladnim tikem, natahni tik
484 _T0IF=0;
485 bit_set(_TXDELAY); // spustime TXDELAY
486 return;
487 }
488  
489 if(bit_test(_ELBUG_BSY))
490 {
491 // odvysilali jsme posloupnost tecka-mezera nebo carka-mezera
492 // nuluj priznak prave dovysilaneho elementu
493 if(bit_test(_ELBUG_LAST)) bit_clear(_ELBUG_DASH);
494 else bit_clear(_ELBUG_DOT);
495 // dale se rozhodujeme podle stavu pak
496 keyer=(~input_b()) & 0b11000000; // precti stav pak
497  
498 // nastav priznak pak podle stisknute paky
499 if(bit_test(_ELBUG_REV))
500 {
501 if(bit_test(keyer,6)) bit_set(_ELBUG_DOT);
502 if(bit_test(keyer,7)) bit_set(_ELBUG_DASH);
503 } else
504 {
505 if(bit_test(keyer,7)) bit_set(_ELBUG_DOT);
506 if(bit_test(keyer,6)) bit_set(_ELBUG_DASH);
507 }
508  
509 if(bit_test(_ELBUG_REAL) && keyer==0) // nestisknuto nic
510 {
511 // pri realnem klicovani po uvolneni pak se uz dal nic nevysila
512 bit_clear(_ELBUG_DOT);
513 bit_clear(_ELBUG_DASH);
514 }
515 }
516  
517 // prepnuti na vysilani pokud tomu uz tak neni
518 if(!bit_test(_TRANSMIT) &&
519 (bit_test(_ELBUG_DOT) || bit_test(_ELBUG_DASH)))
520 {
521 bit_set(_TRANSMIT); // priznak stavu vysilani
522 output_high(RXTX); // prepni TRX na vysilani
523 bit_set(_DDS_UPDATE); // nastav vysilaci kmitocet
524 }
525  
526 // nastav hodnotu casovace podle stisknute paky
527 if(bit_test(_ELBUG_DOT))
528 {
529 if(bit_test(_ELBUG_DASH))
530 {
531 // stisknuty obe paky - vysilej opak priznaku LAST
532 if(bit_test(_ELBUG_LAST))
533 {
534 bit_clear(_ELBUG_LAST);
535 set_timer1(elbug_dot_sp); // natahni casovac na tecku
536 } else
537 {
538 bit_set(_ELBUG_LAST);
539 set_timer1(elbug_dash); // natahni casovac na carku
540 }
541 } else
542 {
543 bit_clear(_ELBUG_LAST);
544 set_timer1(elbug_dot_sp); // natahni casovac na tecku
545 }
546 } else if(bit_test(_ELBUG_DASH))
547 {
548 bit_set(_ELBUG_LAST);
549 set_timer1(elbug_dash); // natahni casovac na carku
550 } else
551 {
552 // NENI CO VYSILAT -KONCIME
553 bit_clear(_ELBUG_BSY);
554 setup_timer_1(T1_DISABLED); // zastav casovac
555 return;
556 }
557  
558 bit_set(_ELBUG_BSY); // elbug bezi
559 bit_set(_ELBUG_SP); // priste musime vysilat mezeru
560 bit_set(_ELBUG_OUT);
561 set_timer0(TICK_TIME); // txdelay je dano jednim zakladnim tikem, natahni tik
562 _T0IF=0;
563 bit_set(_TXDELAY); // spustime TXDELAY
564  
565 #use standard_io(a)
566 #use standard_io(b)
567 #use standard_io(c)
568 #use standard_io(d)
569 } // elbug_handler
570  
571  
572  
573 /////////// FUNKCE PRO OVLADANI UTLUMU /////////
574  
575 // natavi utlum
576 //
577 void Attn_0dB()
578 {
579 output_low(ATN1);
580 output_low(ATN2);
581 output_high(ATNC);
582 delay_ms(RELE_PULSE);
583 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
584 delay_ms(RELE_PULSE);
585 input(ATN1);
586 input(ATN2);
587 }
588  
589  
590 // natavi utlum
591 //
592 void Attn_6dB()
593 {
594 output_high(ATN1);
595 output_low(ATNC);
596 delay_ms(RELE_PULSE);
597 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
598 output_low(ATN2);
599 output_high(ATNC);
600 delay_ms(RELE_PULSE);
601 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
602 delay_ms(RELE_PULSE);
603 input(ATN1);
604 input(ATN2);
605 }
606  
607  
608 // natavi utlum
609 //
610 void Attn_12dB()
611 {
612 output_low(ATN1);
613 output_high(ATNC);
614 delay_ms(RELE_PULSE);
615 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
616 output_high(ATN2);
617 output_low(ATNC);
618 delay_ms(RELE_PULSE);
619 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
620 delay_ms(RELE_PULSE);
621 input(ATN1);
622 input(ATN2);
623 }
624  
625  
626 // natavi utlum
627 //
628 void Attn_18dB()
629 {
630 output_high(ATN1);
631 output_high(ATN2);
632 output_low(ATNC);
633 delay_ms(RELE_PULSE);
634 input(ATNC); // prepni ANTC zpet do tretiho stavu (vstup)
635 delay_ms(RELE_PULSE);
636 input(ATN1);
637 input(ATN2);
638 }
639  
640  
641  
642 /*
643 // precte z prevodnihu hornich 8 bitu
644 //
645 int8 adc()
646 {
647 return(read_adc()>>8) ;
648 } // adc
649 */
650  
651  
652 /////////// FUNKCE PRO PRACI S EEPROM /////////
653  
654 // aktualizuje kontrolni soucet
655 //
656 void update_eeprom()
657 {
658 int8 i;
659 int8 crc;
660 crc=0;
661 for(i=0;i<EE_ADR_CRC;i++) crc+=read_eeprom(i);
662 crc=0-crc;
663 write_eeprom(EE_ADR_CRC,crc);
664 } // update_eeprom
665  
666  
667  
668 // zkontroluje obsah pameti eeprom a pokud je poskozen, nAstavi defaultni parametry
669 //
670 void check_eeprom()
671 {
672 int8 i;
673 int8 crc;
674  
675 crc=0;
676 for(i=0;i<=EE_ADR_CRC;i++) crc=crc+read_eeprom(i);
677  
678 if(crc!=0)
679 {
680 i=EE_ADR_POWER;
681 while(i<BAND_NUM) write_eeprom(i++,PAR_LIMIT[PAR_POWER][0]); // minimalni vykon na vsech pasmech
682 write_eeprom(EE_ADR_KEYER,20); // nastaveno 20 WPM
683 write_eeprom(EE_ADR_VOX,6); // vox 300ms
684 write_eeprom(EE_ADR_BATT,0); // konstantni hodntota,dale se nemeni
685 write_eeprom(EE_ADR_KEYER_REV,0); // nereverzuj paky
686 write_eeprom(EE_ADR_KEYER_MODE,0); // doplnkove klicovani
687 write_eeprom(EE_ADR_ATTN,PAR_LIMIT[PAR_VOX][0]); // utlum vypnut
688 update_eeprom(); // aktualizuj kontorlni soucet
689 }
690  
691 } // check_eeprom
692  
693  
694  
695  
696  
697 /////////////////////////////////////
698 // VYKONNE FUNKCE HLAVNI SMYCKY
699 /////////////////////////////////////
700  
701  
702 // zpracovani zmeny polohy kroutitka
703 // trva max 600cyklu (600us)
704 //
705 // CHELO BY TO UCESAT POMOCI KONSTRUKCE IF - RETURN
706 #inline
707 void enc_chng()
708 {
709 int32 freq_dds;
710 signed int32 delta_freq;
711 signed int16 delta_rit;
712  
713 if(bit_test(_MNU) || bit_test(_MNU2))
714 {
715 // NASTAVUJEME PARAMETRY
716 if(enc_delta<ENC_HISTEREZE && enc_delta>-ENC_HISTEREZE) return; // zmeny pod minimum si nevsimej
717  
718 if(enc_delta>0)
719 {
720 // nastala zmena +1
721 if(bit_test(_MNU2))
722 {
723 if(par_index<PAR_NUM-3)
724 {
725 par_index++; // zmena typu parametru pokud projde kontrola horni meze
726 bit_set(_LCD2_UPDATE);
727 }
728 } else if(par[par_index]<PAR_LIMIT[par_index][1]) // zmena hodnoty parametru pokud projde kontrola horni meze
729 {
730 par[par_index]++;
731 bit_set(_PAR_UPDATE); // pozadavek aktualizace parametru
732 }
733 } else
734 {
735 // nastala zmena -1
736 if(bit_test(_MNU2))
737 {
738 if(par_index>0)
739 {
740 par_index--; // zmena typu parametru pokud projde kontrola dolni meze
741 bit_set(_LCD2_UPDATE);
742 }
743 } else if(par[par_index]>PAR_LIMIT[par_index][0]) // zmena hodnoty parametru pokud projde kontrola dolni meze
744 {
745 par[par_index]--;
746 bit_set(_PAR_UPDATE); // pozadavek aktualizace parametru
747 }
748 }
749 enc_delta=0; // zmena provedena
750 } else
751 {
752 // LADIME KMITOCET
753 if(bit_test(_RIT))
754 {
755 // ladime RIT
756 delta_rit=enc_delta*RIT_STEP;
757 enc_delta=0;
758 if(freq_rit+delta_rit <=RIT_LIMIT[1] &&
759 freq_rit+delta_rit >=RIT_LIMIT[0]) freq_rit+=delta_rit;
760 } else
761 {
762 // ladime VFO
763 delta_freq=enc_delta*FREQ_STEP[step_index];
764 enc_delta=0;
765 freq_dds=freq_vfo[vfo_index]+delta_freq;
766 if(freq_dds <=BAND_LIMIT[band_index][1] &&
767 freq_dds >=BAND_LIMIT[band_index][0]) freq_vfo[vfo_index]+=delta_freq;
768 }
769 bit_set(_DDS_UPDATE); // pozadujeme zmenu kmitoctu v DDS
770 }
771 bit_clear(_ENC_CHNG); // zmena polohy kroutitka zpracovana
772 } // enc_chng
773  
774  
775  
776  
777  
778 // aktualizuje parametry
779 //
780 #inline
781 void par_update()
782 {
783  
784 // int16 power;
785  
786 bit_clear(_PAR_UPDATE);
787  
788 switch(par_index)
789 {
790 case PAR_ATTN:
791 bit_set(_ATTN); // pri utlumu bude misto zelene led svitit zluta
792 switch(par[PAR_ATTN])
793 {
794 case 1: Attn_6dB();
795 break;
796 case 2: Attn_12dB();
797 break;
798 case 3: Attn_18dB();
799 break;
800 default:Attn_0dB();
801 bit_clear(_ATTN); // zadny utlum, zpet zelena led
802 break;
803 }
804 break;
805 case PAR_POWER:
806 // set_pwm2_duty(par[PAR_POWER]);
807 // power=par[PAR_POWER];
808 // set_pwm2_duty(power<<1);
809 //!!!!!
810 power=par[PAR_POWER]*5; // vykon je v nasobcich 0.5W
811 break;
812 case PAR_KEYER:
813 if(par[PAR_KEYER]<=PAR_LIMIT[PAR_KEYER][0]) bit_clear(_ELBUG_ON); ///elbug_flags=0; // vypni elbug
814 else
815 {
816 // zapni elbug a nastav rychlost
817 bit_set(_ELBUG_ON);
818 elbug_dot_sp=~(ELBUG_CONST/par[PAR_KEYER]); // preved na hodnotu citace TMR1
819 elbug_dot_sp++;
820 elbug_dash=(elbug_dot_sp<<1)+elbug_dot_sp; // *3, ale rychleji
821 }
822  
823 break;
824 case PAR_VOX:
825 vox_time=par[PAR_VOX];
826 if(vox_time!=0) vox_time=vox_time*10; // cas je ve 50ms jednotkach
827 else vox_time=1; // minimalni vox je 5ms
828 break;
829 case PAR_KEYER_REV:
830 if(par[PAR_KEYER_REV]) bit_set(_ELBUG_REV); //
831 else bit_clear(_ELBUG_REV);
832 break;
833 case PAR_KEYER_MODE:
834 // if(par[PAR_KEYER_MODE]) bit_set(_ELBUG_REAL); //
835 // else bit_clear(_ELBUG_REAL);
836 break;
837 }
838 bit_set(_LCD2_UPDATE); // pozadujeme update 2. radku dispeje
839 } // par_update()
840  
841  
842  
843  
844 // aktualizuje kmitocet v dds
845 // trva max. cca 2500cyklu (2.5ms)
846 //
847 #inline
848 void dds_update()
849 {
850 int32 freq_dds;
851 signed int32 delta_freq;
852 signed int32 freq_rit2;
853  
854  
855 if(!bit_test(_TRANSMIT))
856 {
857 // PRIJEM
858 if(band_index>=SUB_IF_INDEX) freq_dds=freq_vfo[vfo_index]-FREQ_IF; // pri prijmu na 14MHz se odecita kmitocet mezifrekvence
859 else freq_dds=freq_vfo[vfo_index]+FREQ_IF; // pri prijmu pod 14MHz se pricita kmitocet mezifrekvence
860  
861 if(bit_test(_RIT))
862 {
863 freq_rit2=freq_rit; // prevod na signed int32, chyba v C, neumi int32 + signed int16
864 freq_dds=freq_dds+freq_rit2; // je-li zapnut RIT, udelej korekci kmitoctu
865 }
866 bit_set(_LCD1_UPDATE); // pozadujeme zmenit kmitocet na lcd
867 } else
868 {
869 // VYSILANI
870 if(bit_test(_SPLIT)) // pri split se pouzije opacne vfo
871 freq_dds=freq_vfo[(~vfo_index)];
872 else freq_dds=freq_vfo[vfo_index];
873 }
874  
875 dds_freq0((int32)((float)freq_dds*CONVERT_CONST)); // odesli jej do DDS trva to cca 2050 cylklu (2.05ms)
876 bit_clear(_DDS_UPDATE); // kmitocet v dds zmenen
877 // bit_set(_LCD1_UPDATE); // pozadujeme zmenit kmitocet na lcd
878 } // dds_update
879  
880  
881  
882  
883 // aktualizuje zobrazeni na lcd - 1.radek
884 // trva max. 3000cyklu (30ms) !!!!!!
885 //
886 //#inline
887 #separate
888 int8 lcd1_update()
889 {
890 int16 rit_val;
891  
892 lcd_gotoxy(1,1);
893 bit_clear(_LCD1_UPDATE);
894  
895 if(bit_test(_MNU2)) printf(lcd_putc,"PARAM: "); // zobraz ze vybirame typ parametru
896 else if(bit_test(_MNU))
897 {
898 // zobraz nazev parametru
899 switch(par_index)
900 {
901 case PAR_ATTN: printf(lcd_putc,"ATTN: ");
902 break;
903 case PAR_POWER: printf(lcd_putc,"POWER: ");
904 break;
905 case PAR_KEYER: printf(lcd_putc,"KEYER: ");
906 break;
907 case PAR_VOX: printf(lcd_putc,"DELAY: ");
908 break;
909 case INF_BATT: printf(lcd_putc,"BATTERY:");
910 break;
911 case PAR_KEYER_MODE: printf(lcd_putc,"MODE: ");
912 break;
913 case PAR_KEYER_REV: printf(lcd_putc,"REVERSE:");
914 break;
915  
916 }
917 } else if(bit_test(_RIT))
918 {
919 // POZN: fce printf spatne zachazi se znaminkovimi cisly, proto je znamenko
920 // zobrazeno samostatne a rit je preveden na neznamenkove cislo
921 printf(lcd_putc,"RIT:");
922 if(freq_rit<0) lcd_putc('+');
923 else lcd_putc('-');
924 rit_val=abs(freq_rit);
925 lcd_pos=0;
926 printf(rit_lcd_putc,"%04LU",rit_val); // zobraz RIT na LCD
927 } else
928 {
929 lcd_pos=0;
930 printf(vfo_lcd_putc,"%8LD",freq_vfo[vfo_index]); // zobraz kmitocet na LCD
931 }
932 } // lcd1_update
933  
934  
935  
936 // pomocna funkce pro zobrazeni vykonu a psv na lcd
937 //
938 #separate
939 void lcd_pwr_psv()
940 {
941 #ifdef ADC_LCD
942 printf(lcd_putc,"F%2X R%2X",pwr_val,psv_val);
943 #else
944  
945 // vysilani - zobrazujeme vykon a psv
946 if(pwr_val>99) printf(lcd_putc,">10");
947 else
948 {
949 lcd_pos=0;
950 printf(pwr_lcd_putc,"%02U",pwr_val);
951 }
952 printf(lcd_putc,"W ");
953 if(psv_val>99) printf(lcd_putc,">10");
954 else
955 {
956 lcd_pos=0;
957 printf(pwr_lcd_putc,"%02U",psv_val);
958 }
959 #endif
960 } // lcd_pwr_psv
961  
962  
963  
964 // aktualizuje zobrazeni na lcd - 2.radek
965 // trva max 2000 cyklu (2ms)
966 //
967 //#inline
968 #separate
969 void lcd2_update()
970 {
971 int8 i;
972 int16 vox;
973 int16 batt;
974  
975 bit_clear(_LCD2_UPDATE);
976 lcd_gotoxy(1,2);
977  
978 if(bit_test(_MNU2))
979 {
980 // zobraz vybrany parametr
981 switch(par_index)
982 {
983 case PAR_POWER: printf(lcd_putc,"POWER ");
984 break;
985 case PAR_VOX: printf(lcd_putc,"DELAY ");
986 break;
987 case INF_BATT: printf(lcd_putc,"BATTERY ");
988 break;
989 case PAR_KEYER_MODE: printf(lcd_putc,"MODE ");
990 break;
991 case PAR_KEYER_REV: printf(lcd_putc,"REVERSE ");
992 break;
993  
994 }
995 } else if(bit_test(_MNU))
996 {
997 // zobraz hodnotu parametru
998 switch(par_index)
999 {
1000 case PAR_ATTN: printf(lcd_putc,"-%2U dB ",par[PAR_ATTN]*6); // krok je po 6dB
1001 break;
1002 case PAR_POWER: if(!bit_test(_TRANSMIT))
1003 {
1004 lcd_pos=0;
1005 printf(pwr_lcd_putc,"%02UW PTT",power); // prijem - zobraz pozadovany vykon a vyzvu k vysilani
1006 } else lcd_pwr_psv(); // vysilani - zobraz vykon a psv
1007 break;
1008 case PAR_KEYER: if( par[PAR_KEYER]<=PAR_LIMIT[PAR_KEYER][0]) printf(lcd_putc,"OFF ");
1009 else printf(lcd_putc,"%2U ",par[PAR_KEYER]);
1010 break;
1011 case PAR_VOX:
1012 vox=par[PAR_VOX];
1013 vox=vox*50; // ve 50ms jednotkach
1014 printf(lcd_putc,"%4LU ms ",vox);
1015 break;
1016 case INF_BATT:
1017 #ifdef ADC_LCD
1018 printf(lcd_putc,"%3X V ",batt_val);
1019 #else
1020 // zobraz napeti baterie na desetiny voltu
1021 batt=batt_val;
1022 batt=(batt*10)/16;
1023 lcd_pos=0;
1024 printf(batt_lcd_putc,"%03UV ",(int8)batt);
1025  
1026 #endif
1027 break;
1028 case PAR_KEYER_MODE:
1029 if(par[PAR_KEYER_MODE]) printf(lcd_putc,"B ");
1030 else printf(lcd_putc,"A ");
1031 break;
1032 case PAR_KEYER_REV:
1033 if(par[PAR_KEYER_REV]) printf(lcd_putc,"YES ");
1034 else printf(lcd_putc,"NO ");
1035 break;
1036  
1037 }
1038 } else if(bit_test(_TRANSMIT)) lcd_pwr_psv(); // vysilani - zobraz vykon a psv
1039 else if(!bit_test(_ELBUG_BSY)) // v mezerach mezi znackami elbugu S-metr nezobrazuj
1040 {
1041 // prijem - zobrazujeme S-metr
1042 #ifdef ADC_LCD
1043 printf(lcd_putc,"SMTR:%2X ",smtr_val);
1044 #else
1045 if(smtr_val<=S_METER[0]) lcd_putc('2');
1046 else lcd_putc(' ');
1047 if(smtr_val<=S_METER[1]) lcd_putc('3');
1048 else lcd_putc(' ');
1049 if(smtr_val<=S_METER[2]) lcd_putc('4');
1050 else lcd_putc(' ');
1051 if(smtr_val<=S_METER[3]) lcd_putc('5');
1052 else lcd_putc(' ');
1053 if(smtr_val<=S_METER[4]) lcd_putc('6');
1054 else lcd_putc(' ');
1055 if(smtr_val<=S_METER[5]) lcd_putc('7');
1056 else lcd_putc(' ');
1057 if(smtr_val<=S_METER[6]) lcd_putc('8');
1058 else lcd_putc(' ');
1059 if(smtr_val<=S_METER[8]) lcd_putc('\23');
1060 else if(smtr_val<=S_METER[7]) lcd_putc('9');
1061 else lcd_putc(' ');
1062 #endif
1063 }
1064 } // lcd2_update()
1065  
1066  
1067  
1068  
1069 // nastavi pasmo podle pripojeneho filtru
1070 //
1071 //#inline
1072 void set_band()
1073 {
1074 // int8 adc_band;
1075  
1076 set_adc_channel (BND_CH); // prepni ADC na vstup signalu BAND
1077 delay_ms(20);
1078  
1079 // opakuj dokud neni pripojen vhodny filtr
1080 for(;;)
1081 {
1082 bnd_val=read_adc() & BAND_ADC_MASK;
1083 // prohlidni tabulku moznych filtru
1084 band_index=BAND_NUM;
1085 while(band_index--)
1086 {
1087 if(bnd_val==BAND_ADC[band_index]) return; // platny filtr pritomen
1088 }
1089 printf(lcd_putc,"\rCONNECT\n");
1090 printf(lcd_putc," FILTER");
1091 delay_ms(500);
1092 }
1093 } // set_band
1094  
1095  
1096  
1097  
1098 // mereni analogovych vstupu
1099 //
1100 // doba trvani max 3000 cyklu (3ms)
1101 #separate
1102 void analog_inputs()
1103 {
1104 static int8 count;
1105 int16 k;
1106 int32 pom32,pom32_2; // pro vypocet dopredneho vykonu
1107 int16 pom16,pom16_2; // pro vypocet PSV
1108 signed int8 delta;
1109  
1110  
1111 #ifndef NO_FILTER_CONTROL // vyrazuje prubeznou kontrolu pritomnosti filtru pro prislusne pasmo
1112 if((bnd_val & BAND_ADC_MASK)!=BAND_ADC[band_index]) reset_cpu(); // fittr byl odpojen
1113 #endif
1114  
1115 // mereni napeti baterie
1116 if(batt_val+5<=BATT_MIN) bit_set(_BATT_LOW); // baterie je vybita
1117  
1118 // vypocti aktualni vykon a psv a reguluj vykon
1119 if(bit_test(_TRANSMIT))
1120 {
1121 #ifdef ADC_LCD // vypina zpracovani - zobrazuje prime hodnoty z prevodniku
1122 pwr_val=fwd_val;
1123 psv_val=rev_val;
1124 #else
1125 // vypocti vykon na desetiny watu
1126 pom32=fwd_val;
1127 pom32=pom32*pom32; // vykon je umerny kvadratu napeti
1128 // vynasobime *10 - vykon bude 100mW jednotkach
1129 // realizuje *10, je vyrazne casove kratsi ( o cca 500cyklu)
1130 pom32_2=pom32<<3;
1131 pom32_2=pom32_2+pom32;
1132 pom32_2=pom32_2+pom32;
1133 pwr_val=pom32_2/PWR_FWD_CONST; // vydelime kalibracni konstantou pro dopredny vykon
1134  
1135 // vypocti PSV na desetinu
1136 if(fwd_val>=0 && rev_val==0) psv_val=10; // psv je 1.0 pokud je odrazeny vykon nulovy
1137 else
1138 {
1139 pom16=fwd_val;
1140 pom16=pom16<<4; // vynasobime *16 pro vetsi presnost
1141 k=pom16/rev_val; // pomer odpovidajici ciniteli odrazu
1142 if(k<=16) psv_val=250; // PSV se blizi nekonecnu
1143 else if(k>337) psv_val=10; // psv je lepsi jak 1.1 tedy ho povazujeme za 1.0
1144 else
1145 {
1146 // toto realizuje vyraz (k+16)*10
1147 pom16=k+16;
1148 pom16_2=pom16<<3;
1149 pom16_2=pom16_2+pom16;
1150 pom16_2=pom16_2+pom16;
1151 // vypocet psv
1152 psv_val=pom16_2/(k-16);
1153 }
1154 }
1155  
1156 // rizeni vykonu (ALC)
1157 if(psv_val>BAD_PSV) delta=PWR_LIM-pwr_val; // pri spatnem PSV omez vykon
1158 else delta=power-pwr_val;
1159 if(delta<-PWR_HIST_HI && pwm_val>PWM_MIN)
1160 {
1161 if(delta<-10) pwm_val=pwm_val-4;
1162 else pwm_val--;
1163 pom16=pwm_val;
1164 set_pwm2_duty(pom16<<1);
1165 } else if(delta>PWR_HIST_LO && pwm_val<PWM_MAX)
1166 {
1167 if(delta>10) pwm_val=pwm_val+4;
1168 else pwm_val++;
1169 pom16=pwm_val;
1170 set_pwm2_duty(pom16<<1);
1171 }
1172 #endif
1173 }
1174  
1175 // zobrazeni na LCD delame mene casto
1176 if(count>4)
1177 {
1178 bit_set(_LCD2_UPDATE);
1179 count=0;
1180 } else count++;
1181 }// analog_inputs
1182  
1183  
1184 /*
1185 void pwr_control()
1186 {
1187 int16 aaa;
1188 signed int8 delta;
1189  
1190 if(bit_test(_TRANSMIT))
1191 {
1192 delta=power-pwr_val;
1193 if(delta<-1 && pwm_val>27)
1194 {
1195 if(delta<-10) pwm_val=pwm_val-4;
1196 else
1197 pwm_val--;
1198 aaa=pwm_val;
1199 set_pwm2_duty(aaa<<1);
1200 } else if(delta>2 && pwm_val<157)
1201 {
1202 if(delta>10) pwm_val=pwm_val+4;
1203 else
1204 pwm_val++;
1205 aaa=pwm_val;
1206 set_pwm2_duty(aaa<<1);
1207 }
1208 }
1209 } // pwr_control
1210 */
1211  
1212  
1213  
1214  
1215 /////////////////////////////////
1216 ///// HLAVNI FUNKCE /////
1217 /////////////////////////////////
1218 void main()
1219 {
1220 int8 ee_adr;
1221  
1222 int8 a;
1223 int8 b;
1224 signed int8 c;
1225  
1226  
1227  
1228 // inicializace LCD
1229 lcd_init();
1230 // definice specialnich znaku
1231 lcd_define_char(2,LCD_CHAR_a_FILL);
1232 lcd_define_char(1,LCD_CHAR_b_FILL);
1233 lcd_define_char(3,LCD_CHAR_9_FILL);
1234  
1235 // nastaveni smeru signalu a jejich klidovych stavu
1236 port_b_pullups(TRUE);
1237 output_high(DDS_FSYNC); // zapis_so DDS neaktivni
1238 output_low(DDS_SDATA); // data do 0
1239 output_high(DDS_SCK); // hodiny do neaktivniho stavu
1240 output_low(RXTX); // prepni na prijem
1241 output_low(KEYING); // neklicuj
1242 output_low(LCD_LED2); // zhasni led
1243 output_low(LCD_LED1); // zhasni led
1244 input(TONE); // vypni priposlech
1245 output_low(PWR_CTRL); // nulovy vykon
1246  
1247 output_low(ATN1);
1248 output_low(ATN2);
1249 output_low(ATNC);
1250  
1251 // inicializace DDS
1252 dds_send(CTRL_RESET); // pozadujeme reset
1253 dds_send(CLR_PHASE0);
1254 dds_send(CLR_PHASE1);
1255  
1256  
1257 // zakladni nastaveni ridicich promennych programu
1258 update_timer=UPDATE_TIME; // natahni periodicky timer pro LCD
1259 flags=0; // nuluj priznaky ridici program
1260 elbug_flags=0; // nuluj priznaky pro elbug
1261 keys_flags=0;
1262 adc_flags=0;
1263 adc_ch=0;
1264 pwm_val=PWM_MIN;
1265 enc_delta=0; // zadna zmena od kroutitka
1266 keys=0; // zadna tlacitka nejsou stisknuta
1267 freq_rit=0; // nuluj RIT
1268  
1269 // uvodni hlaseni programu
1270 lcd_gotoxy(1,1);
1271 printf(lcd_putc,NAME);
1272 lcd_gotoxy(1,2);
1273 printf(lcd_putc,VERSION);
1274 delay_ms(1000);
1275  
1276 // nastaveni AD prevodniku
1277 setup_adc(ADC_CLOCK_DIV_8);
1278 setup_adc_ports(AN0_AN1_AN2_AN3_AN4); // povoleny porty AN0-AN4
1279  
1280 set_band(); // nastav pasmo podle pripojeneho filtru nebo cekej na jeho pripojeni
1281  
1282 check_eeprom(); // kontrola platnosti obsahu eeprom, pri poruse nastav defaultni parametry
1283  
1284 // obnoveni a nastaveni parametru programu
1285 par[PAR_POWER]=read_eeprom(EE_ADR_POWER+band_index); // vyzvedni nastaveny vykon pro dane pasmo
1286 power=par[PAR_POWER]*5;
1287  
1288 par[PAR_KEYER]=read_eeprom(EE_ADR_KEYER); // vyzvedni rychlost klice
1289 if(par[PAR_KEYER]<=PAR_LIMIT[PAR_KEYER][0]) elbug_flags=0; // vypni elbug
1290 else
1291 {
1292 // zapni elbug a nastav rychlost
1293 bit_set(_ELBUG_ON);
1294 elbug_dot_sp=~(ELBUG_CONST/par[PAR_KEYER]); // preved na hodnotu citace TMR1
1295 elbug_dot_sp++;
1296 elbug_dash=(elbug_dot_sp<<1)+elbug_dot_sp; // *3, ale rychleji
1297 }
1298  
1299 par[PAR_VOX]=read_eeprom(EE_ADR_VOX); // vyzvedni vox
1300 vox_time=par[PAR_VOX];
1301 if(vox_time!=0) vox_time=vox_time*20; // cas je ve 100ms jednotkach
1302 else vox_time=2;
1303  
1304 par[PAR_KEYER_REV]=read_eeprom(EE_ADR_KEYER_REV); // vyzvedni chapani pak
1305 if(par[PAR_KEYER_REV]) bit_set(_ELBUG_REV); //
1306 else bit_clear(_ELBUG_REV);
1307  
1308  
1309 par[PAR_KEYER_REV]=read_eeprom(EE_ADR_KEYER_REV); // vyzvedni mod elbugu
1310 // if(par[PAR_KEYER_REV]) bit_set(_ELBUG_REAL); //
1311 // else bit_clear(_ELBUG_REAL);
1312 bit_clear(_ELBUG_REAL); // mod elbugu je zatim vzdy doplnkovy
1313  
1314 par[PAR_ATTN]=PAR_LIMIT[PAR_ATTN][0]; // attenuator vzdy vypnut
1315 Attn_0dB();
1316 freq_vfo[0]=START_FREQ[band_index]; // QRP volaci kmitocet BAND_LIMIT[band_index][0] ; // po zapnuti ma VFO nejmensi kmitocet pasma
1317 freq_vfo[1]=START_FREQ[band_index]; // QRP volaci kmitocet BAND_LIMIT[band_index][0] ; // po zapnuti ma VFO nejmensi kmitocet pasma
1318 bit_set(_DDS_UPDATE); // pozadujeme nastavit kmitocet v dds
1319 step_index=0; // defaultne jemny krok ladeni
1320 vfo_index=0; // defaultne vfoA
1321  
1322  
1323  
1324 // nastaveni zakladniho tiku
1325 setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128);
1326 set_timer0(TICK_TIME);
1327  
1328 // nastaveni pro generovani priposlechu, rizeni LCD_LED a PWM pro rizeni vykonu
1329 setup_timer_2(T2_DIV_BY_16,TONE_SET,4); // zajisti pro PWM rozliseni 8.28 bitu
1330 setup_ccp1(CCP_PWM); // pro generovani tonu
1331 set_pwm1_duty((TONE_SET+1)/2); // strida cca 1:1
1332 tone_off(); // priposlech vypnut
1333 setup_ccp2(CCP_PWM); // pro rizeni vykonu
1334 set_pwm2_duty((int16)27); //
1335 setup_timer_1(T1_DISABLED); // elbug je v klidu
1336  
1337  
1338 #use fast_io(b)
1339 keyer=(~input_b()) & 0b11000000; // precti stav pak
1340 #use standard_io(b)
1341  
1342 if(bit_test(keyer,6)) bit_clear(_ELBUG_ON); // pokud je ori zapnuti stisknuta paka carek, je pripojen rucni klic
1343  
1344  
1345 // povoleni preruseni
1346 enable_interrupts(INT_EXT); // preruseni od zmeny polohy kroutitka
1347 enable_interrupts(INT_TIMER0); // zakadni tik
1348 enable_interrupts(INT_TIMER2); // preruseni pro rizeni vykonu, LED a generovani priposlechu
1349 enable_interrupts(INT_TIMER1); // preruseni pro elbug
1350 enable_interrupts(INT_RB); // preruseni od stavu pak klice
1351 enable_interrupts(GLOBAL);
1352  
1353  
1354  
1355  
1356  
1357 //#define TEST
1358 #ifdef TEST
1359  
1360 bit_set(_TRANSMIT);
1361 //bit_set(_MNU);
1362  
1363 fwd_val=150;
1364 rev_val=10;
1365 smtr_val=150;
1366 bnd_val=0x20;
1367  
1368 a=50;
1369 b=5;
1370  
1371  
1372 // testovaci smycka pro zjistovani doby behu testovane funkce
1373 setup_timer_1(T1_INTERNAL|RTCC_DIV_1);
1374 set_timer1(0);
1375  
1376 //Analog_inputs();
1377  
1378 c=b-a;
1379  
1380 setup_timer_1(T1_DISABLED);
1381 lcd_gotoxy(1,1);
1382 printf(lcd_putc,"T:%LU",get_timer1());
1383 lcd_gotoxy(1,2);
1384 printf(lcd_putc,"%D",c);
1385  
1386 for(;;);
1387  
1388 #else
1389  
1390  
1391  
1392 // HLAVNI SMYCKA
1393 for(;;)
1394 {
1395  
1396 /////////////////
1397 // pozadavek na zmenu kmitoctu (max. 2,5ms)
1398 if(bit_test(_DDS_UPDATE)) dds_update();
1399  
1400 ////////////////
1401 // nastala zmena polohy kroutitka
1402 if(bit_test(_ENC_CHNG)) enc_chng();
1403  
1404 /////////////////
1405 // zmena parametru
1406 if(bit_test(_PAR_UPDATE)) par_update();
1407  
1408 /////////////////
1409 // pozadavek zmeny kmitoctu na lcd - 1.radek (zabere 30ms !!!!!)
1410 // PODMINKU NUTNO UPRAVIT
1411 if(bit_test(_LCD1_UPDATE) && update_timer==0 && !bit_test(_ELBUG_BSY)) lcd1_update();
1412  
1413  
1414 /////////////////
1415 // pozadavek na zmenu informaci na lcd - 2.radek (max 2ms)
1416 if(bit_test(_LCD2_UPDATE) && update_timer==0)
1417 {
1418 lcd2_update();
1419 update_timer=0xFF; // ukonci okno,kdy je timer vyprseny
1420 }
1421  
1422  
1423 /////////////////
1424 // periodicka mereni (max 3ms)
1425 if(update_timer==0)
1426 {
1427 analog_inputs();
1428 update_timer=0xFF; // ukonci okno,kdy je timer vyprseny
1429 }
1430  
1431  
1432 /////////////////
1433 // stisknuta tlacitka
1434  
1435 if(bit_test(_KEYS_VALID)) // stisknuto nejake tlacitko
1436 {
1437 // kratky stisk libovolneho tlacitka ukonci nastavovani
1438 if(bit_test(_MNU) && !bit_test(_KEYS_LONG))
1439 {
1440 bit_clear(_MNU); // vypni nastavovani
1441 enc_delta=0; // zahod nacitane zbyle impulzy korutitka
1442 if(bit_test(_ELBUG_ON_TMP)) bit_set(_ELBUG_ON); // obnov zapnuti elbugu pokud byl zapnut
1443  
1444 if(par_index!=PAR_ATTN) // stav attenuatoru se neuklada do eeprom
1445 {
1446 ee_adr=EE_ADDR[par_index];
1447 if(par_index==PAR_POWER) ee_adr=ee_adr+band_index; // pro parametr vykonu urci adresu eeprom pro dane pasmo
1448 if(read_eeprom(ee_adr)!=par[par_index]) // pokud doslo ke zmene parametru, aktualizuj ho v eeprom
1449 {
1450 write_eeprom(ee_adr,par[par_index]);
1451 update_eeprom();
1452 }
1453 }
1454 bit_set(_LCD1_UPDATE);
1455 bit_set(_LCD2_UPDATE);
1456 } else
1457 {
1458 // ktere tlacitko je stisknuto?
1459 if(keys==KEY_SPLIT) // SPLIT/MNU
1460 {
1461 if(bit_test(_KEYS_LONG))
1462 {
1463 // dlouhy stisk - vstup do MENU
1464 bit_set(_MNU2); // prvni stisk - vyber parametr
1465 par_index=PAR_POWER;
1466 bit_set(_LCD1_UPDATE);
1467 bit_set(_LCD2_UPDATE);
1468 } else
1469 {
1470 // kratky stisk - pokracovani v MENU
1471 if(bit_test(_MNU2))
1472 {
1473 if(par_index==PAR_POWER)
1474 {
1475 // zapamatuj si , zda je elbug zapnut nebo vypnut
1476 if(bit_test(_ELBUG_ON)) bit_set(_ELBUG_ON_TMP);
1477 else bit_clear(_ELBUG_ON_TMP);
1478 bit_clear(_ELBUG_ON); // pri nastavovani vykonu je elbug vypnut
1479 }
1480 bit_clear(_MNU2); // druhy stisk - prejdi do vybraneho parametru
1481 bit_set(_MNU);
1482 } else
1483 {
1484 // kratky stisk - funkce SPLIT
1485 if(bit_test(_SPLIT)) bit_clear(_SPLIT);
1486 else bit_set(_SPLIT);
1487 }
1488 bit_set(_LCD1_UPDATE);
1489 }
1490 } // KEY_SPLIT
1491  
1492 // ostani tlacitka jsou aktivni jen kdyz nejsme ve vyberu parametru
1493 if(!bit_test(_MNU2))
1494 {
1495 if(keys==KEY_RIT) // RIT/STEP
1496 {
1497 if(bit_test(_KEYS_LONG))
1498 {
1499 // dlouhy stisk - funkce STEP
1500 if(step_index) step_index=0;
1501 else step_index=1;
1502 bit_set(_LCD1_UPDATE);
1503 } else
1504 {
1505 // kratky stisk - funkce RIT
1506 if(bit_test(_RIT))
1507 {
1508 bit_clear(_RIT);
1509 freq_rit=0; // pri vypnuti RIT vynuluj
1510 } else bit_set(_RIT);
1511 bit_set(_DDS_UPDATE);
1512 }
1513 } // KEY_RIT
1514  
1515 if(keys==KEY_CHNGVFO) // prepni VFO/srovnej VFO
1516 {
1517 if(bit_test(_KEYS_LONG))
1518 {
1519 // dlouhy stisk - funkce srovnej VFO
1520 if(vfo_index) freq_vfo[0]=freq_vfo[1];
1521 else freq_vfo[1]=freq_vfo[0];
1522 } else
1523 {
1524 // kratky stisk - funkce prepni VFO
1525 if(vfo_index) vfo_index=0;
1526 else vfo_index=1;
1527 bit_set(_DDS_UPDATE);
1528 }
1529 } // KEY_CHNGVFO
1530  
1531 if(keys==KEY_ATTN) // ATTN/ELBUG
1532 {
1533 if(bit_test(_KEYS_LONG))
1534 {
1535 // dlouhy stisk - funkce ELBUG
1536 par_index=PAR_KEYER;
1537 bit_set(_MNU);
1538 bit_set(_LCD1_UPDATE);
1539 bit_set(_LCD2_UPDATE);
1540 } else
1541 {
1542 // kratky stisk - funkce ATTN - mozne jen pokud se nevysila
1543 par_index=PAR_ATTN;
1544 bit_set(_MNU);
1545 bit_set(_LCD1_UPDATE);
1546 bit_set(_LCD2_UPDATE);
1547 }
1548 } // KEY_ATTN
1549 }
1550 }
1551 bit_clear(_KEYS_VALID); // tlacitko zpracovano
1552 bit_set(_KEYS_RELEASE); // budeme cekat na uvolneni tlacitek
1553 }
1554  
1555 } // hlavni smycka
1556 #endif
1557 }
1558 // End of File