00001 /*
00002 Copyright (C) 1999 PolyWog and Javaman for Ghetto.Org
00003 This file is part of the PCR-1000 API Library.
00004
00005 The PCR-1000 API Library is free software; you can redistribute it and/or
00006 modify it under the terms of the GNU Library General Public License as
00007 published by the Free Software Foundation; either version 2 of the
00008 License, or (at your option) any later version.
00009
00010 The PCR-1000 API Library is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00013 Library General Public License for more details.
00014
00015 You should have received a copy of the GNU Library General Public
00016 License along with the PCR-1000 API Library; see the file LICENSE. If not,
00017 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018 Boston, MA 02111-1307, USA.
00019 */
00020
00021 /*
00022 * This file declares PCP.
00023 * PCP Is the actual object that interfaces with the GUI
00024 * This API deals with the error handling and the calls
00025 * that must be made to and from the radio, via the PComm
00026 * serial i/o object.
00027 */
00028
00029 #include "pcp.h"
00030
00031 #include <stdio.h>
00032 #include <unistd.h>
00033 #include <stdlib.h>
00034
00035 #if defined (SunOS) || defined (Irix)
00036 #include <strings.h>
00037 #else // def SunOs/Irix
00038 #include <string.h>
00039 #endif // def SunOs/Irix
00040
00041 PCP :: PCP(char *port, tcflag_t speed, const char *name)
00042 {
00043 PCPRadio = new PRadInf;
00044 PCPComm = new PComm(port, speed, name);
00045
00046 bzero(PCPRadio, sizeof( PRadInf));
00047 bzero(PCPTemp, sizeof(PCPTemp));
00048
00049 strncpy(PCPRadio->PCPPort, port, 0xff);
00050 PCPRadio->PCPSpeed = speed;
00051 PCPRadio->PCPVolume = 0;
00052 PCPRadio->PCPSquelch = 0;
00053 PCPRadio->PCPFreq = 146000000;
00054 strncpy(PCPRadio->PCPMode, PCRMODNFM, sizeof(PCPRadio->PCPMode));
00055 strncpy(PCPRadio->PCPFilter, PCRFLTR15, sizeof(PCPRadio->PCPFilter));
00056 PCPRadio->PCPToneSq=0;
00057 PCPRadio->PCPToneSqFloat=0.0;
00058 PCPRadio->PCPAutoGain=false;
00059 PCPRadio->PCPNoiseBlank=false;
00060 PCPRadio->PCPRFAttenuator=false;
00061 PCPRadio->PCPAutoUpdate = false;
00062 PCPStatus = false;
00063 }
00079 PCP :: ~PCP()
00080 {
00081 delete PCPComm;
00082 }
00090 bool PCP :: PCPInit(bool autoUpdate)
00091 {
00092 if (autoUpdate==false) {
00093 PCPComm->PCTell(PCRINITM);
00094 fprintf(stderr, "Radio is coming up. Please wait...\n");
00095 sleep(1);
00096 if (PCPStatus)
00097 if (PCPCheckResponse()) {
00098 PCPRadio->PCPAutoUpdate=false;
00099 return true;
00100 }
00101 } else {
00102 PCPComm->PCTell(PCRINITA);
00103 sleep(1);
00104 if (PCPStatus)
00105 if (PCPCheckResponse()) {
00106 PCPRadio->PCPAutoUpdate=true;
00107 return true;
00108 }
00109 }
00110
00111 return false;
00112 }
00131 bool PCP :: PCPPowerUp()
00132 {
00133 PCPComm->PCTell(PCRPWRON);
00134 if (PCPCheckResponse()) {
00135 // PCPCheckResponse();
00136 PCPStatus=true;
00137 return true;
00138 }
00139 return false;
00140 }
00152 bool PCP :: PCPPowerDown()
00153 {
00154 PCPComm->PCTell(PCRPWROFF);
00155 // if (PCPCheckResponse()) {
00156 PCPCheckResponse();
00157 PCPStatus=false;
00158 return true;
00159 // }
00160 // return false;
00161 }
00173 bool PCP :: PCPSetSpeed(tcflag_t speed)
00174 {
00175 if ( (B300<=speed)&&(speed<=B38400) ) {
00176 bzero(PCPRadio->PCPInitSpeed, sizeof(PCPRadio->PCPInitSpeed));
00177 switch (speed) {
00178 case B38400:
00179 // you probably want to set the speed
00180 // to fastest available, so let's put
00181 // this here first
00182 strncpy(PCPRadio->PCPInitSpeed, PCRBD38400,
00183 sizeof(PCPRadio->PCPInitSpeed)-1);
00184 break;
00185 case B19200:
00186 strncpy(PCPRadio->PCPInitSpeed, PCRBD19200,
00187 sizeof(PCPRadio->PCPInitSpeed)-1);
00188 break;
00189 case B300:
00190 strncpy(PCPRadio->PCPInitSpeed, PCRBD300,
00191 sizeof(PCPRadio->PCPInitSpeed)-1);
00192 break;
00193 case B1200:
00194 strncpy(PCPRadio->PCPInitSpeed, PCRBD1200,
00195 sizeof(PCPRadio->PCPInitSpeed)-1);
00196 break;
00197 case B2400:
00198 strncpy(PCPRadio->PCPInitSpeed, PCRBD2400,
00199 sizeof(PCPRadio->PCPInitSpeed)-1);
00200 break;
00201 default:
00202 // if all else fails, we'll always
00203 // have paris! ~=^)
00204 strncpy(PCPRadio->PCPInitSpeed, PCRBD9600,
00205 sizeof(PCPRadio->PCPInitSpeed)-1);
00206 }
00207 PCPComm->PCTell(PCPRadio->PCPInitSpeed);
00208 delete PCPComm;
00209 PCPComm = new PComm(PCPRadio->PCPPort, speed, "PCPComm_R");
00210 // investigate possible responses, i dont think one is given.
00211 // PCPCheckResponse();
00212 PCPRadio->PCPSpeed = speed;
00213 return true;
00214 }
00215
00216 return false;
00217 }
00246 bool PCP :: PCPSetPort(const char *port)
00247 {
00248 PCPComm->PCClose();
00249 return(PCPComm->PCOpen(port));
00250 }
00263 bool PCP :: PCPSetVolume(int volume)
00264 {
00265 if ((0<=volume)&&(volume<=99)) {
00266 bzero(PCPTemp, sizeof(PCPTemp));
00267 sprintf(PCPTemp, "%s%0.2d", PCRVOL, volume);
00268 PCPComm->PCTell(PCPTemp);
00269 if (PCPCheckResponse()) {
00270 PCPRadio->PCPVolume=volume;
00271 return true;
00272 }
00273 }
00274
00275 return false;
00276 }
00292 bool PCP :: PCPSetSquelch(int squelch)
00293 {
00294 if ((0<=squelch)&&(squelch<=99)) {
00295 bzero(PCPTemp, sizeof(PCPTemp));
00296 sprintf(PCPTemp, "%s%0.2d", PCRSQL, squelch);
00297 PCPComm->PCTell(PCPTemp);
00298 if (PCPCheckResponse()) {
00299 PCPRadio->PCPSquelch=squelch;
00300 return true;
00301 }
00302 }
00303
00304 return false;
00305 }
00322 bool PCP :: PCPSetFreq(pcrfreq_t freq)
00323 {
00324 char freqConv[32];
00325 bzero(freqConv, sizeof(freqConv));
00326
00327 if ((LOWERFRQ<=freq)&&(freq<=UPPERFRQ)) {
00328 bzero(PCPTemp, sizeof(PCPTemp));
00329 sprintf(freqConv, "%0.10lu", freq);
00330 strcpy(PCPTemp, PCRFRQ);
00331 strcat(PCPTemp, freqConv);
00332 strcat(PCPTemp, PCPRadio->PCPMode);
00333 strcat(PCPTemp, PCPRadio->PCPFilter);
00334 strcat(PCPTemp, "00");
00335 PCPComm->PCTell(PCPTemp);
00336 if (PCPCheckResponse()) {
00337 PCPRadio->PCPFreq=freq;
00338 #ifdef DEBUG_VER_
00339 fprintf(stderr, "PCP: PCPSETFREQ - Success\n");
00340 #endif
00341 return true;
00342 }
00343 }
00344 #ifdef DEBUG_VER_
00345 fprintf(stderr, "PCP: PCPSETFREQ - Failed\n");
00346 #endif
00347 return false;
00348 }
00374 bool PCP :: PCPSetMode(const char *mode)
00375 {
00376 char freqConv[32];
00377 char temp[8];
00378
00379 bzero(PCPTemp, sizeof(PCPTemp));
00380 sprintf(freqConv, "%0.10lu", PCPRadio->PCPFreq);
00381 strcpy(PCPTemp, PCRFRQ);
00382 strcat(PCPTemp, freqConv);
00383
00384 if ( strncmp(mode, "AM", 2)==0 ) {
00385 strcat(PCPTemp, PCRMODAM);
00386 strcpy(temp, PCRMODAM);
00387 } else if ( strncmp(mode, "CW", 2)== 0 ) {
00388 strcat(PCPTemp, PCRMODCW);
00389 strcpy(temp, PCRMODCW);
00390 } else if ( strncmp(mode, "LSB", 3)==0 ) {
00391 strcat(PCPTemp, PCRMODLSB);
00392 strcpy(temp, PCRMODLSB);
00393 } else if ( strncmp(mode, "USB", 3)==0 ) {
00394 strcat(PCPTemp, PCRMODUSB);
00395 strcpy(temp, PCRMODUSB);
00396 } else if ( strncmp(mode, "NFM", 3)==0 ) {
00397 strcat(PCPTemp, PCRMODNFM);
00398 strcpy(temp, PCRMODNFM);
00399 } else if ( strncmp(mode, "WFM", 3)==0 ) {
00400 strcat(PCPTemp, PCRMODWFM);
00401 strcpy(temp, PCRMODWFM);
00402 } else {
00403 return false;
00404 }
00405
00406 strcat(PCPTemp, PCPRadio->PCPFilter);
00407 strcat(PCPTemp, "00");
00408 PCPComm->PCTell(PCPTemp);
00409 if (PCPCheckResponse()) {
00410 #ifdef DEBUG_VER_
00411 fprintf(stderr, "Storing PCPRadio->PCPMode: %s\n", temp);
00412 #endif // DEBUG_VER_
00413 strcpy(PCPRadio->PCPMode,temp);
00414 return true;
00415 }
00416
00417 return false;
00418
00419 }
00441 bool PCP :: PCPSetFilter(const char *filter)
00442 {
00443 char freqConv[32];
00444 char temp[8];
00445
00446 bzero(PCPTemp, sizeof(PCPTemp));
00447 sprintf(freqConv, "%0.10lu", PCPRadio->PCPFreq);
00448 strcpy(PCPTemp, PCRFRQ);
00449 strcat(PCPTemp, freqConv);
00450 strcat(PCPTemp, PCPRadio->PCPMode);
00451
00452 if ( strncmp(filter, "3", 1)==0 ) {
00453 strcat(PCPTemp, PCRFLTR3);
00454 strcpy(temp, PCRFLTR3);
00455 } else if ( strncmp(filter, "6", 1)== 0 ) {
00456 strcat(PCPTemp, PCRFLTR6);
00457 strcpy(temp, PCRFLTR6);
00458 } else if ( strncmp(filter, "15", 2)==0 ) {
00459 strcat(PCPTemp, PCRFLTR15);
00460 strcpy(temp, PCRFLTR15);
00461 } else if ( strncmp(filter, "50", 2)==0 ) {
00462 strcat(PCPTemp, PCRFLTR50);
00463 strcpy(temp, PCRFLTR50);
00464 } else if ( strncmp(filter, "230", 3)==0 ) {
00465 strcat(PCPTemp, PCRFLTR230);
00466 strcpy(temp, PCRFLTR230);
00467 } else {
00468 return false;
00469 }
00470
00471 strcat(PCPTemp, "00");
00472 PCPComm->PCTell(PCPTemp);
00473 if (PCPCheckResponse()) {
00474 #ifdef DEBUG_VER_
00475 fprintf(stderr, "Storing PCPRadio->PCPFilter: %s\n", temp);
00476 #endif DEBUG_VER_
00477 strcpy(PCPRadio->PCPFilter,temp);
00478 return true;
00479 }
00480
00481 return false;
00482 }
00503 bool PCP :: PCPSetToneSq(const char *value)
00504 {
00505 #ifdef DEBUG_VER_
00506 fprintf(stderr, "PCP: PCPSETTONESQ (string) - %s\n", value);
00507 #endif // DEBUG_VER_
00508
00509 bzero(PCPTemp, sizeof(PCPTemp));
00510 strncpy(PCPTemp, PCRTSQL, sizeof(PCPTemp));
00511 strncat(PCPTemp, value, sizeof(PCPTemp));
00512 PCPComm->PCTell(PCPTemp);
00513 if (PCPCheckResponse()) {
00514 PCPRadio->PCPToneSq=value;
00515 return true;
00516 }
00517
00518 return false;
00519 }
00537 bool PCP :: PCPSetToneSq(float passvalue)
00538 {
00539 #ifdef DEBUG_VER_
00540 fprintf(stderr, "PCP: PCPSETTONESQ (float) - %f\n", passvalue);
00541 #endif // DEBUG_VER_
00542
00543 int tone;
00544
00545 tone = (int)(passvalue * 10.0 + .1); // Hack to remove truncating errors.
00546 PCPRadio->PCPToneSqFloat=passvalue;
00547
00548 switch (tone)
00549 {
00550 case 0: return PCPSetToneSq("00"); break;
00551 case 670: return PCPSetToneSq("01"); break;
00552 case 693: return PCPSetToneSq("02"); break;
00553 case 710: return PCPSetToneSq("03"); break;
00554 case 719: return PCPSetToneSq("04"); break;
00555 case 744: return PCPSetToneSq("05"); break;
00556 case 770: return PCPSetToneSq("06"); break;
00557 case 797: return PCPSetToneSq("07"); break;
00558 case 825: return PCPSetToneSq("08"); break;
00559 case 854: return PCPSetToneSq("09"); break;
00560 case 885: return PCPSetToneSq("0A"); break;
00561 case 915: return PCPSetToneSq("0B"); break;
00562 case 948: return PCPSetToneSq("0C"); break;
00563 case 974: return PCPSetToneSq("0D"); break;
00564 case 1000: return PCPSetToneSq("0E"); break;
00565 case 1035: return PCPSetToneSq("0F"); break;
00566 case 1072: return PCPSetToneSq("10"); break;
00567 case 1109: return PCPSetToneSq("11"); break;
00568 case 1148: return PCPSetToneSq("12"); break;
00569 case 1188: return PCPSetToneSq("13"); break;
00570 case 1230: return PCPSetToneSq("14"); break;
00571 case 1273: return PCPSetToneSq("15"); break;
00572 case 1318: return PCPSetToneSq("16"); break;
00573 case 1365: return PCPSetToneSq("17"); break;
00574 case 1413: return PCPSetToneSq("18"); break;
00575 case 1462: return PCPSetToneSq("19"); break;
00576 case 1514: return PCPSetToneSq("1A"); break;
00577 case 1567: return PCPSetToneSq("1B"); break;
00578 case 1598: return PCPSetToneSq("1C"); break;
00579 case 1622: return PCPSetToneSq("1D"); break;
00580 case 1655: return PCPSetToneSq("1E"); break;
00581 case 1679: return PCPSetToneSq("1F"); break;
00582 case 1713: return PCPSetToneSq("20"); break;
00583 case 1738: return PCPSetToneSq("21"); break;
00584 case 1773: return PCPSetToneSq("22"); break;
00585 case 1799: return PCPSetToneSq("23"); break;
00586 case 1835: return PCPSetToneSq("24"); break;
00587 case 1862: return PCPSetToneSq("25"); break;
00588 case 1899: return PCPSetToneSq("26"); break;
00589 case 1928: return PCPSetToneSq("27"); break;
00590 case 1966: return PCPSetToneSq("28"); break;
00591 case 1995: return PCPSetToneSq("29"); break;
00592 case 2035: return PCPSetToneSq("2A"); break;
00593 case 2065: return PCPSetToneSq("2B"); break;
00594 case 2107: return PCPSetToneSq("2C"); break;
00595 case 2181: return PCPSetToneSq("2D"); break;
00596 case 2257: return PCPSetToneSq("2E"); break;
00597 case 2291: return PCPSetToneSq("2F"); break;
00598 case 2336: return PCPSetToneSq("30"); break;
00599 case 2418: return PCPSetToneSq("31"); break;
00600 case 2503: return PCPSetToneSq("32"); break;
00601 case 2541: return PCPSetToneSq("33"); break;
00602 default: PCPSetToneSq("00"); break;
00603 }
00604 return false;
00605 }
00623 bool PCP :: PCPSetAutoGain(bool value)
00624 {
00625 #ifdef DEBUG_VER_
00626 fprintf(stderr, "PCP: PCPSETAUTOGAIN - %d\n", value);
00627 #endif // DEBUG_VER_
00628
00629 (value)?(PCPComm->PCTell(PCRAGCON)):(PCPComm->PCTell(PCRAGCOFF));
00630
00631 if (PCPCheckResponse()) {
00632 PCPRadio->PCPAutoGain=value;
00633 return true;
00634 }
00635
00636 return false;
00637 }
00655 bool PCP :: PCPSetNB(bool value)
00656 {
00657 #ifdef DEBUG_VER_
00658 fprintf(stderr, "PCP: PCPSETNB - %d\n", value);
00659 #endif // DEBUG_VER_
00660
00661 (value)?(PCPComm->PCTell(PCRNBON)):(PCPComm->PCTell(PCRNBOFF));
00662
00663 if (PCPCheckResponse()) {
00664 PCPRadio->PCPNoiseBlank=value;
00665 return true;
00666 }
00667
00668 return false;
00669 }
00687 bool PCP :: PCPSetRFAttenuator ( bool value )
00688 {
00689 #ifdef DEBUG_VER_
00690 fprintf(stderr, "PCP: PCPSETRFATTENUATOR - %d\n", value);
00691 #endif // DEBUG_VER_
00692
00693 (value)?(PCPComm->PCTell(PCRRFAON)):(PCPComm->PCTell(PCRRFAOFF));
00694
00695 if (PCPCheckResponse()) {
00696 PCPRadio->PCPRFAttenuator=value;
00697 return true;
00698 }
00699
00700 return false;
00701 }
00719
00720 // getter methods //
00722
00723 bool PCP :: PCPIsOn()
00724 {
00725 return PCPStatus;
00726 }
00739 const char *PCP :: PCPSigStrengthStr()
00740 {
00741 #ifdef DEBUG_VER_
00742 fprintf(stderr, "PCP: PCPSIGSTRENGTH (string) Called\n");
00743 #endif // DEBUG_VER_
00744 if(PCPComm->PCAsk(PCRQRST)) {
00745 if(PCPComm->PCHear(PCPTemp)) {
00746 return (const char*)PCPTemp;
00747 }
00748 }
00749
00750 return 0;
00751 }
00766 int PCP :: PCPSigStrength()
00767 {
00768 #ifdef DEBUG_VER_
00769 fprintf(stderr, "PCP: PCPSIGSTRENGTH (int) Called\n");
00770 #endif // DEBUG_VER_
00771
00772 int sigstr;
00773 char digit;
00774 if(PCPComm->PCAsk(PCRQRST)) {
00775 if(PCPComm->PCHear(PCPTemp)) {
00776 digit = PCPTemp[2];
00777 if((digit >= 'A') && (digit <= 'F'))
00778 sigstr = (digit - 'A' + 1) * 16;
00779 else
00780 sigstr = atoi(&digit) * 16;
00781
00782 digit = PCPTemp[3];
00783 if((digit >= 'A') && (digit <= 'F'))
00784 sigstr += digit - 'A' + 1;
00785 else
00786 sigstr += atoi(&digit);
00787
00788 return sigstr;
00789 }
00790 }
00791
00792 return 0;
00793 }
00802 bool PCP :: PCPQueryOn()
00803 {
00804 #ifdef DEBUG_VER_
00805 fprintf(stderr, "PCP: PCPQUERYON Called\n");
00806 #endif // DEBUG_VER_
00807 if(PCPComm->PCAsk("H1")) {
00808 if(PCPComm->PCHear(PCPTemp)) {
00809 if(strcmp(PCPTemp, "H101") == 0)
00810 return true;
00811 else
00812 return false;
00813 }
00814 }
00815
00816 return false;
00817 }
00832 bool PCP :: PCPQuerySquelch()
00833 {
00834 char __tempvar1[8];
00835 bzero(__tempvar1, sizeof(__tempvar1));
00836 strncpy(__tempvar1, PCRASQL, sizeof(__tempvar1)-1);
00837 strncat(__tempvar1, PCRASQLCL, sizeof(__tempvar1)-strlen(__tempvar1)-1);
00838
00839 if (PCPComm->PCAsk(PCRQSQL)) {
00840 if(PCPComm->PCHear(PCPTemp)) {
00841 if (strncmp(PCPTemp, __tempvar1, 4)==0) {
00842 return false;
00843 } else {
00844 return true;
00845 }
00846 }
00847 }
00848 return false;
00849 }
00862 const char *PCP :: PCPGetPort()
00863 // return a character string representing the current
00864 // port setting /dev/*
00865 {
00866 return PCPRadio->PCPPort;
00867 }
00882 tcflag_t PCP :: PCPGetSpeed_t()
00883 {
00884 return PCPRadio->PCPSpeed;
00885 }
00897 const char *PCP :: PCPGetSpeed()
00898 {
00899 switch(PCPRadio->PCPSpeed) {
00900 case B300: return "300"; break;
00901 case B600: return "600"; break;
00902 case B1200: return "1200"; break;
00903 case B1800: return "1800"; break;
00904 case B2400: return "2400"; break;
00905 case B4800: return "4800"; break;
00906 case B9600: return "9600"; break;
00907 case B19200: return "19200"; break;
00908 case B38400: return "38400"; break;
00909 case B57600: return "57600"; break;
00910 default: return "unknown"; break;
00911 }
00912 return "unknown";
00913 }
00927 int PCP :: PCPGetVolume()
00928 {
00929 return (PCPRadio->PCPVolume);
00930 }
00942 const char *PCP :: PCPGetVolumeStr()
00943 {
00944 sprintf(PCPTemp, "%d", PCPRadio->PCPVolume);
00945 return (PCPTemp);
00946 }
00959 int PCP :: PCPGetSquelch()
00960 {
00961 return (PCPRadio->PCPSquelch);
00962 }
00974 const char *PCP :: PCPGetSquelchStr()
00975 {
00976 sprintf(PCPTemp, "%d", PCPRadio->PCPSquelch);
00977 return (PCPTemp);
00978 }
00991 pcrfreq_t PCP :: PCPGetFreq()
00992 {
00993 return PCPRadio->PCPFreq;
00994 }
01008 const char *PCP :: PCPGetFreqStr()
01009 {
01010 sprintf(PCPTemp, "%0.10lu", PCPRadio->PCPFreq);
01011 return PCPTemp;
01012 }
01026 const pcrcmd_t *PCP :: PCPGetMode()
01027 {
01028 return (PCPRadio->PCPMode);
01029 }
01041 const char *PCP :: PCPGetModeStr()
01042 {
01043 bzero(PCPTemp, sizeof(PCPTemp));
01044
01045 if (strcmp(PCRMODWFM, PCPRadio->PCPMode)==0) {
01046 strcpy(PCPTemp, "WFM");
01047 return PCPTemp;
01048 } else if (strcmp(PCRMODNFM, PCPRadio->PCPMode)==0) {
01049 strcpy(PCPTemp, "NFM");
01050 return PCPTemp;
01051 } else if (strcmp(PCRMODCW, PCPRadio->PCPMode)==0) {
01052 strcpy(PCPTemp, "CW");
01053 return PCPTemp;
01054 } else if (strcmp(PCRMODAM, PCPRadio->PCPMode)==0) {
01055 strcpy(PCPTemp, "AM");
01056 return PCPTemp;
01057 } else if (strcmp(PCRMODUSB, PCPRadio->PCPMode)==0) {
01058 strcpy(PCPTemp, "USB");
01059 return PCPTemp;
01060 } else if (strcmp(PCRMODLSB, PCPRadio->PCPMode)==0) {
01061 strcpy(PCPTemp, "LSB");
01062 return PCPTemp;
01063 }
01064
01065 strcpy(PCPTemp, "UNKNOWN");
01066 return PCPTemp;
01067
01068 }
01081 const pcrcmd_t *PCP :: PCPGetFilter()
01082 {
01083 return (PCPRadio->PCPFilter);
01084 }
01096 const char *PCP :: PCPGetFilterStr()
01097 {
01098 bzero(PCPTemp, sizeof(PCPTemp));
01099
01100 if (strcmp(PCRFLTR230, PCPRadio->PCPFilter)==0) {
01101 strcpy(PCPTemp, "230");
01102 return PCPTemp;
01103 } else if (strcmp(PCRFLTR50, PCPRadio->PCPFilter)==0) {
01104 strcpy(PCPTemp, "50");
01105 return PCPTemp;
01106 } else if (strcmp(PCRFLTR15, PCPRadio->PCPFilter)==0) {
01107 strcpy(PCPTemp, "15");
01108 return PCPTemp;
01109 } else if (strcmp(PCRFLTR6, PCPRadio->PCPFilter)==0) {
01110 strcpy(PCPTemp, "6");
01111 return PCPTemp;
01112 } else if (strcmp(PCRFLTR3, PCPRadio->PCPFilter)==0) {
01113 strcpy(PCPTemp, "3");
01114 return PCPTemp;
01115 }
01116
01117 return PCPRadio->PCPFilter;
01118 }
01131 const char *PCP :: PCPGetToneSq()
01132 {
01133 return PCPRadio->PCPToneSq;
01134 }
01146 const char *PCP :: PCPGetToneSqStr()
01147 {
01148 bzero(PCPTemp, sizeof(PCPTemp));
01149 sprintf(PCPTemp, "%f", PCPRadio->PCPToneSqFloat);
01150 return PCPTemp;
01151 }
01164 bool PCP :: PCPGetAutoGain()
01165 {
01166 return PCPRadio->PCPAutoGain;
01167 }
01179 const char *PCP :: PCPGetAutoGainStr()
01180 {
01181 bzero(PCPTemp, sizeof(PCPTemp));
01182 (PCPGetAutoGain())?(strcpy(PCPTemp,"1")):(strcpy(PCPTemp,"0"));
01183 return PCPTemp;
01184 }
01197 bool PCP :: PCPGetNB()
01198 {
01199 return PCPRadio->PCPNoiseBlank;
01200 }
01212 const char *PCP :: PCPGetNBStr()
01213 {
01214 bzero(PCPTemp, sizeof(PCPTemp));
01215 (PCPGetNB())?(strcpy(PCPTemp,"1")):(strcpy(PCPTemp,"0"));
01216 return PCPTemp;
01217 }
01230 bool PCP :: PCPGetRFAttenuator()
01231 {
01232 return PCPRadio->PCPRFAttenuator;
01233 }
01245 const char *PCP :: PCPGetRFAttenuatorStr()
01246 {
01247 bzero(PCPTemp, sizeof(PCPTemp));
01248 (PCPGetRFAttenuator())?(strcpy(PCPTemp,"1")):(strcpy(PCPTemp,"0"));
01249 return PCPTemp;
01250 }
01263 const PRadInf PCP :: PCPGetRadioInfo()
01264 {
01265 return *PCPRadio;
01266 }
01267
01268 bool PCP :: PCPCheckResponse()
01269 {
01270 PCPComm->PCHear(PCPTemp);
01271 if (strncmp(PCPTemp, PCRAOK, 4)==0) {
01272 PCPErrRead=false;
01273 return true;
01274 } else if (strncmp(PCPTemp, PCRABAD, 4)==0) {
01275 PCPErrRead=false;
01276 return false;
01277 }
01278
01279 PCPErrRead = true;
01280 return false;
01281 }
