/tests/testrig.c

00001 /* 
00002  * Hamlib sample program
00003  */
00004 
00005 #include <stdio.h>
00006 #include <string.h>
00007 #include <unistd.h>
00008 #include <stdlib.h>
00009 #include <hamlib/rig.h>
00010 
00011 #define SERIAL_PORT "/dev/ttyS0"
00012 
00013 int main (int argc, char *argv[])
00014 { 
00015         RIG *my_rig;            /* handle to rig (nstance) */
00016         freq_t freq;            /* frequency  */
00017         rmode_t rmode;          /* radio mode of operation */
00018         pbwidth_t width;
00019         vfo_t vfo;              /* vfo selection */
00020         int strength;           /* S-Meter level */
00021         int retcode;            /* generic return code from functions */
00022         rig_model_t myrig_model;
00023 
00024 
00025         printf("testrig:hello, I am your main() !\n");
00026 
00027         /*
00028          * allocate memory, setup & open port 
00029          */
00030 
00031         if (argc < 2) {
00032                         hamlib_port_t myport;
00033                         /* may be overriden by backend probe */
00034                         myport.type.rig = RIG_PORT_SERIAL;
00035                         myport.parm.serial.rate = 9600;
00036                         myport.parm.serial.data_bits = 8;
00037                         myport.parm.serial.stop_bits = 1;
00038                         myport.parm.serial.parity = RIG_PARITY_NONE;
00039                         myport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
00040                         strncpy(myport.pathname, SERIAL_PORT, FILPATHLEN);
00041 
00042                         rig_load_all_backends();
00043                         myrig_model = rig_probe(&myport);
00044         } else {
00045                         myrig_model = atoi(argv[1]);
00046         }
00047 
00048         my_rig = rig_init(myrig_model);
00049                 
00050         if (!my_rig) {
00051                 fprintf(stderr,"Unknown rig num: %d\n", myrig_model);
00052                 fprintf(stderr,"Please check riglist.h\n");
00053                 exit(1); /* whoops! something went wrong (mem alloc?) */
00054         }
00055 
00056         strncpy(my_rig->state.rigport.pathname,SERIAL_PORT,FILPATHLEN);
00057 
00058         retcode = rig_open(my_rig);
00059         if (retcode != RIG_OK) {
00060                 printf("rig_open: error = %s\n", rigerror(retcode));
00061                 exit(2);
00062         }
00063 
00064         printf("Port %s opened ok\n", SERIAL_PORT);
00065 
00066         /*
00067          * Below are examples of set/get routines.
00068          * Must add checking of functionality map prior to command execution -- FS
00069          *
00070          */
00071 
00072         /*
00073          * Example of setting rig paameters
00074          * and some error checking on the return code.
00075          */
00076 
00077         retcode = rig_set_vfo(my_rig, RIG_VFO_B);
00078 
00079 
00080         if (retcode != RIG_OK ) {
00081           printf("rig_set_vfo: error = %s \n", rigerror(retcode));
00082         }
00083 
00084 
00085         /*
00086          * Lets try some frequencies and modes. Return code is not checked.
00087          * Examples of checking return code are further down.
00088          *
00089          */
00090         
00091         /* 10m FM Narrow */
00092 
00093         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 28350125); /* 10m */
00094         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_FM, 
00095                                         rig_passband_narrow(my_rig, RIG_MODE_FM));
00096         sleep(3);               /* so you can see it -- FS */
00097 
00098         /* 15m USB */
00099 
00100         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 21235175); /* 15m  */
00101         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_USB, RIG_PASSBAND_NORMAL);
00102         sleep(3);
00103 
00104         /* AM Broadcast band */
00105 
00106         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 770000); /* KAAM */
00107         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_AM, RIG_PASSBAND_NORMAL);
00108         sleep(3);
00109 
00110         /* 40m LSB */
00111 
00112         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 7250100); /* 40m  */
00113         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_LSB, RIG_PASSBAND_NORMAL);
00114         sleep(3);
00115 
00116         /* 80m AM NArrow */
00117 
00118         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 3980000); /* 80m  */
00119         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_AM, 
00120                                         rig_passband_narrow(my_rig, RIG_MODE_FM));
00121         sleep(3);
00122 
00123         /* 160m CW Normal */
00124 
00125         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 1875000); /* 160m  */
00126         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_CW, RIG_PASSBAND_NORMAL);
00127         sleep(3);
00128 
00129         /* 160m CW Narrow -- The band is noisy tonight -- FS*/
00130 
00131         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_CW,
00132                                         rig_passband_narrow(my_rig, RIG_MODE_FM));
00133         sleep(3);
00134 
00135         /* 20m USB on VFO_A */
00136 
00137         retcode = rig_set_vfo(my_rig, RIG_VFO_A);
00138         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 14250375); /* cq de vk3fcs */
00139         sleep(3);
00140 
00141         /* 20m USB on VFO_A , with only 1 call */
00142 
00143         retcode = rig_set_freq(my_rig, RIG_VFO_A, 14295125); /* cq de vk3fcs */
00144         sleep(3);
00145 
00146 
00147 
00148 #if 0
00149         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 145100000); /* 2m  */
00150         sleep(2);
00151         retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 435125000); /* 70cm  */
00152         sleep(2);
00153 #endif
00154 
00155         if (retcode != RIG_OK ) {
00156           printf("rig_set_freq: error = %s \n", rigerror(retcode));
00157         } 
00158 
00159         retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_LSB, RIG_PASSBAND_NORMAL);
00160 
00161         if (retcode != RIG_OK ) {
00162           printf("rig_set_mode: error = %s \n", rigerror(retcode));
00163         } 
00164 
00165         retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_ON ); /* stand back ! */
00166 
00167         if (retcode != RIG_OK ) {
00168           printf("rig_set_ptt: error = %s \n", rigerror(retcode));
00169         } 
00170 
00171         sleep(1);
00172 
00173         retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_OFF ); /* phew ! */
00174 
00175         if (retcode != RIG_OK ) {
00176           printf("rig_set_ptt: error = %s \n", rigerror(retcode));
00177         } 
00178 
00179         sleep(1);
00180 
00181         /*
00182          * Simple examples of getting rig information -- FS
00183          *
00184          */
00185 
00186         retcode = rig_get_vfo(my_rig, &vfo); /* try to get vfo info */
00187 
00188         if (retcode == RIG_OK ) {
00189           printf("rig_get_vfo: vfo = %i \n", vfo);
00190         } else {
00191           printf("rig_get_vfo: error =  %s \n", rigerror(retcode));
00192         }
00193 
00194         retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
00195         
00196         if (retcode == RIG_OK ) {
00197           printf("rig_get_freq: freq = %"PRIfreq"\n", freq);
00198         } else {
00199           printf("rig_get_freq: error =  %s \n", rigerror(retcode));
00200         }
00201 
00202         retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
00203 
00204         if (retcode == RIG_OK ) {
00205           printf("rig_get_mode: mode = %i \n", rmode);
00206         } else {
00207           printf("rig_get_mode: error =  %s \n", rigerror(retcode));
00208         }
00209 
00210         retcode = rig_get_strength(my_rig, RIG_VFO_CURR, &strength);
00211 
00212         if (retcode == RIG_OK ) {
00213           printf("rig_get_strength: strength = %i \n", strength);
00214         } else {
00215           printf("rig_get_strength: error =  %s \n", rigerror(retcode));
00216         }
00217 
00218 
00219         rig_close(my_rig); /* close port */
00220         rig_cleanup(my_rig); /* if you care about memory */
00221 
00222         printf("port %s closed ok \n",SERIAL_PORT);
00223 
00224         return 0;
00225 }
00226 

Hamlib documentation for version 1.2.6.2 -- Sun Dec 9 09:37:48 2007
Project page: http://hamlib.org