/******************************************************************************/
/* LOBO Root Menu                                                             */
/******************************************************************************/
//#ROOT
void RootMenu(void)
  {
  char   cmd;
  short  qret=TRUE;
 
  printf("\n/* LOBO Root Menu <H> for Help */");
  fflush(stdout);

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO>", NULL, "^[STFIHP", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {
            case '^[' :
                    break;

            case 'S' :
                    SetupMenu();
                    break;

            case 'T' :
                    TestMenu();
                    break;

            case 'F' :
                    FileMenu();
                    break;

            case 'I' :
                    InfoMenu();
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n",
                             "[S]etup    Menu",
                             "[T]est     Menu",
                             "[F]ile     Menu",
                             "[I]nfo     Menu",
                             "[P]ico DOS Exit");
                    break;

            case 'P' :                      //needs a Global Power Off later when more power chan are added
                    if(LoboPass() == TRUE){ //make it bozo proof
                      ioPwrDown();
                      // close comm relays, add later....
//                    WrLatchDefaults();    //reset hardware latches
                      ResetToPicoDOS();     //return to PicoDOS Monitor */
                      }
                    break;

            }//end switch

      } //end qret if

    } //end while
  }

/******************************************************************************/
/* LOBO Setup Menu                                                            */
/******************************************************************************/
//#SETUP
void SetupMenu(void)
  {
  char   cmd;
  short  qret = TRUE;

  printf("\n/* LOBO Setup Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_SETUP>", NULL, "^[DIRSH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {
            case '^[' :
                    break;

            case 'D' :
//                  if(LoboPass() == TRUE)  //screen out the RiffRaff!
                      LoggingSetup();
                     break;

            case 'I' :
//                  if(LoboPass() == TRUE)  //screen out the RiffRaff!
                      InstrumentSetup();
                     break;

            case 'R' :
                    if(LoboPass() == TRUE)
                      RadioModemSetup();
                     break;

            case 'S' :
//                  if(LoboPass() == TRUE)
                      RtcSetup();
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n",
                           "[D]ataLogging",
                           "[I]nstruments",
                           "[R]adio MODEM",
                           "[S]ystem Clock");
                    break;

            }//end switch

      }//end qret if

    }//end while
  }

void LoggingSetup()
  {
  char   cmd;
  uchar  DS1994_ret;
  short  qret = TRUE;
  ulong  input_var;

  printf("\n/* LOBO Logging Setup Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_SETUP_LOGGING>", NULL, "^[TSCPDLFWH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {
            case '^[' :
                    break;

            case 'T' :
                    printf("\n  Scheduled Sleep time between sampling (mins) = %lu\n", lobo_sleep);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = lobo_sleep;
                      QueryNum("\n  Enter mins between samples (sleep time)", "%lu", "%lu", &input_var);
                      if(input_var != lobo_sleep){
                        if( (input_var >= 5) && (input_var <= 45000) ){
                          lobo_sleep =  input_var;
                          current_time = RtcToCtm();    //where are we now
                          tp = localtime(&current_time);
                          printf("\n  %02d/%02d/%02d %02d:%02d:%02d - Current Time\n", tp->tm_mon+1, tp->tm_mday, tp->tm_year+1900, tp->tm_hour, tp->tm_min, tp->tm_sec);

                          //wakeup.secs = current_time + (lobo_sleep*60); //set new wakeup time
                          wakeup.secs = SyncNextSample(60, last_sample);
                          tp = localtime(&wakeup.secs);

                          printf("  %02d/%02d/%02d %02d:%02d:%02d - New Alarm Time\n", tp->tm_mon+1, tp->tm_mday, tp->tm_year+1900, tp->tm_hour, tp->tm_min, tp->tm_sec);
                          if(RtcDevice == 1)
                            WrDS1994Long(LOBOSLP_PTR, lobo_sleep, DS1994_ROM);
                          }
                        else
                          RangeError(5L, 45000L);
                        }
                      } //end modify if
                    break;

            case 'S' :
                    printf("\n  Number of Samples prior to Radio Transmission = %lu\n", samps_per_xmit);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = samps_per_xmit;
                      QueryNum("\n  Enter number of samples", "%lu", "%lu", &input_var);
                      if(input_var != samps_per_xmit){
                        if( (input_var >= 1) && (input_var <= 24) ){
                          samps_per_xmit = input_var;
                          if(RtcDevice == 1)
                            WrDS1994Short(SAMPSPERTX_PTR, samps_per_xmit, DS1994_ROM);
                          }
                        else
                          RangeError(1L, 24L);
                        }
                      } //end modify if
                    break;

            case 'C' :
                    printf("\n  Sample Counter =  %lu\n", samp_ctr);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      if(LoboPass() == TRUE){
                        samp_ctr = 0L;
                        if(RtcDevice == 1)
                          DS1994_ret = WrDS1994Long(SAMPCTR_PTR, samp_ctr, DS1994_ROM);
                        printf("\n  Sample Counter Reset\n");
                        }
                      }
                    break;

            case 'P' :
                    if(slog_mode == 1){
                      printf("\n\n  Synchronize Logging to the next XX:%02hu:00 period after power up\n", sync_min);
                      input_var = 0;
                      }
                    else if(slog_mode == 2){
                      printf("\n\n  Synchronize Logging to the next %02hu:%02hu:00 (LOCAL TIME) period after power up\n", sync_hour, sync_min);
                      input_var = 0;
                      }
                    else{
                      input_var = 1;
                      }
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = 0;
                      QueryNum("\n  Select Power Up Logging Sync:\n  [1] Sync to Min\n  [2] Sync to Hour&Min\n  Enter>", "%lu", "%lu", &input_var);
                      if( (input_var >= 1) && (input_var <= 2) ){
                        slog_mode = (ushort)input_var;
                        if(RtcDevice == 1)
                          WrDS1994Byte(SLOGMODE_PTR, slog_mode, DS1994_ROM);
                        if(input_var == 1){
                          input_var = sync_min;
                          QueryNum("\n  Enter minute to sync logging start to (mins)", "%lu", "%lu", &input_var);
                          if(input_var != sync_min){
                            if( (input_var >= 0) && (input_var <= 59) ){
                              sync_min = (ushort)input_var;
                              wakeup.secs = SyncNextSample(sync_min, last_sample);
                              last_sample = wakeup.secs;
                              if(RtcDevice == 1)
                                WrDS1994Short(SYNCMIN_PTR, sync_min, DS1994_ROM);
                              }
                            else{
                              RangeError(0L, 59L);
                              break;
                              }
                            }
                          }
                        if(input_var == 2){
                          input_var = sync_hour;
                          QueryNum("\n  Enter hour to sync logging start to (hours)", "%lu", "%lu", &input_var);
                          if(input_var != sync_hour){
                            if( (input_var >= 0) && (input_var <= 23) ){
                              sync_hour = (ushort)input_var;
                              if(RtcDevice == 1)
                                WrDS1994Short(SYNCHR_PTR, sync_hour, DS1994_ROM);
                              }
                            else{
                              RangeError(0L, 23L);
                              break;
                              }
                            }
                          input_var = sync_min;
                          QueryNum("\n  Enter minute to sync logging start to (mins)", "%lu", "%lu", &input_var);
                          if(input_var != sync_min){
                            if( (input_var >= 0) && (input_var <= 59) ){
                              sync_min = (ushort)input_var;
                              wakeup.secs = SyncNextSample(sync_min, last_sample);
                              last_sample = wakeup.secs;
                              if(RtcDevice == 1)
                                WrDS1994Short(SYNCMIN_PTR, sync_min, DS1994_ROM);
                              }
                            else{
                              RangeError(0L, 59L);
                              break;
                              }
                            }
                          } //end select = 2
                        }
                      else
                        RangeError(1L, 2L);
                      } //end modify if
                    break;

            case 'D' :
                    if(data_mode == REMOVE_AFTER_XMIT){
                      printf("\n\n  LOBO will remove data files after transmission.\n");
                      input_var = 0;
                      }
                    else if(data_mode == RENAME_AFTER_XMIT){
                      printf("\n\n  LOBO will rename data files after transmission.\n");
                      input_var = 0;
                      }
                    else{
                      input_var = 1;
                      }
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = data_mode;
                      QueryNum("\n  Select Data Logging Mode:\n  [1] Remove Files\n  [2] Rename Files\n  Enter>", "%lu", "%lu", &input_var);
                      if(input_var != data_mode){
                        if( (input_var >= 1) && (input_var <= 2) ){
                          data_mode = (uchar)input_var;
                          if(RtcDevice == 1)
                            WrDS1994Byte(DATAMODE_PTR, data_mode, DS1994_ROM);
                          }
                        else
                          RangeError(1L, 2L);
                        }
                      } //end modify if
                    break;

            case 'L' :

                    current_time = RtcToCtm();
                    tp = localtime(&current_time);
                    printf("\n  Last DOY = %03hu, Current DOY = %03hu\n", last_doy, DayOfYear(tp->tm_year+1900, tp->tm_mon+1, tp->tm_mday));
                    printf("\n  Log File Counter =  %lu\n", file_ctr);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      if(LoboPass() == TRUE){
                        QueryNum("\n  Enter file new file number", "%lu", "%lu", &input_var);
                        if( (input_var >= 1) && (input_var <= 900) ){
                          file_ctr = input_var;
                          if(RtcDevice == 1)
                            WrDS1994Long(FILECTR_PTR, file_ctr, DS1994_ROM);
                          printf("\n  File Counter Reset\n");
                          }
                        else
                          RangeError(1L, 900L);
                        }
                      } //end modify if
                    break;

            case 'F' :
                    printf("\n  Maximum size (in kBytes) for Instrument Data Log File = %hu\n", lf_limit);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = lf_limit;
                      QueryNum("\n  Enter max file size (kB)", "%lu", "%lu", &input_var);
                      if(input_var != lf_limit){
                        if( (input_var >= 1) && (input_var <= 5000) ){
                          lf_limit = (ushort)input_var;
                          if(RtcDevice == 1)
                            WrDS1994Short(LFLIMIT_PTR, lf_limit, DS1994_ROM);
                          }
                        else
                          RangeError(1L, 5000L);
                        }
                      } //end modify if
                    printf("\n\n  Maximum size (in kBytes) for Radio Xmit Spool File = %hu\n", sf_limit);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = sf_limit;
                      QueryNum("\n  Enter max file size (kB)", "%lu", "%lu", &input_var);
                      if(input_var != sf_limit){
                        if( (input_var >= 0) && (input_var <= 2000) ){
                          sf_limit = (ushort)input_var;
                          if(RtcDevice == 1)
                            WrDS1994Short(SFLIMIT_PTR, sf_limit, DS1994_ROM);
                          }
                        else
                          RangeError(0L, 2000L);
                        }
                      } //end modify if
                    break;

            case 'W' :
                    printf("\n  Hardware Watchdog is ");
                    if( watchdog_enable == TRUE )
                      printf("ENABLED\n");
                    else
                      printf("DISABLED\n");
                    if( QueryYesNo("\n  Modify", FALSE) ){
                      input_var = watchdog_enable;
                      QueryNum("\n\n  Selection:\n   [0] Disabled\n   [1] Enabled\n  Enter>", "%lu", "%lu", &input_var);
                      if(input_var != watchdog_enable){
                        if( (input_var >= 0) && (input_var <= 1) ){
                          watchdog_enable = (uchar)input_var;
                          if(RtcDevice != FALSE)
                            WrDS1994Byte(WDOGENABLE_PTR, watchdog_enable, DS1994_ROM);
                          if( watchdog_enable == TRUE )
                            EnableWatchDog();
                          else
                            DisableWatchDog();
                          }
                        else
                          RangeError(0L, 1L);
                        }
                      }  //end modify if

                    printf("\n  WatchDog Cycle Counter =  %lu\n", watchdog_ctr);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      if(LoboPass() == TRUE){
                        watchdog_ctr = 0L;
                        if(RtcDevice == 1)
                          DS1994_ret = WrDS1994Long(WATCHDOGCTR_PTR, watchdog_ctr, DS1994_ROM);
                        printf("\n  WatchDog Counter Reset\n");
                        }
                      }
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n",
                           "[T]ime Between Sampling",
                           "[S]amples Per Transmission",
                           "[C]lear Sample Counter",
                           "[P]ower Up Sync Time",
                           "[D]ata Logging Mode",
                           "[L]og File Counter",
                           "[F]lash File Sizes",
                           "[W]atchDog Counter");
                    break;

            }//end switch

      } //end qret if

    }//end while

  printf("\n");
  }

void InstrumentSetup(void)
  {
  char   cmd;
  short  qret=TRUE;
  uchar  byte_mask;
  ulong  input_var;

  printf("\n/* LOBO Instrument Setup Menu <H> for Help */");
  fflush(stdout);

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_SETUP_INSTRUMENT>", NULL, "^[AESCH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {
            case '^[' :
                    break;

            case 'A' :
                    break;

            case 'E' :
                    DisplayByteVal("\n  Sample Channel Enable Bits ", sample_enable, TTY_DEVICE);
                    input_var = 0;
                    QueryNum("  Enter Chan>", "%lu", "%lu", &input_var);
                    if( (input_var >= 1) && (input_var <= 8) ){
                      byte_mask = 0x01;
                      byte_mask = byte_mask << (input_var-1);
                      if(sample_enable & byte_mask)   // is it currently set?
                        printf("\n\n  Channel %lu is currently ENABLED for sampling.\n", input_var);
                      else
                        printf("\n\n  Channel %lu is currently DISABLED for sampling.\n", input_var);
                      }
                    else{
                      RangeError(1L, 8L);
                      break;
                      }
                    if( QueryYesNo("\n  Modify", FALSE) ){
                      if(sample_enable & byte_mask){  // is it currently set?
                        sample_enable = sample_enable & ~byte_mask;
                        printf("\n\n  Channel %lu was disabled!\n", input_var);
                        }
                      else{
                        sample_enable = sample_enable | byte_mask;
                        printf("\n\n  Channel %lu was enabled!\n", input_var);
                        }
                      if(RtcDevice != FALSE)
                        WrDS1994Byte(SAMPENABLE_PTR, sample_enable, DS1994_ROM);
                      } //end modify if
                    break;

            case 'C' :
                    input_var = 0;
                    QueryNum("\n  Select Instrument:\n  [1] Connect ISUS\n  [2] Connect SBE16\n  [3] Connect SBE37\n  Enter>", "%lu", "%lu", &input_var);
                    if( (input_var >= 1) && (input_var <= 3) ){
                      printf("\n\n");
                      if(input_var == 1)
                        SampleISUS(stdout, CONNECT);
                      else if(input_var == 2)
                        SampleSBE16(stdout, CONNECT);
                      else if(input_var == 3)
                        SampleSBE37(stdout, CONNECT);
                      }
                    else
                      RangeError(1L, 3L);
                    break;

            case 'S' :
                    input_var = 0;
                    QueryNum("\n  Select Instrument:\n  [1] Sample ISUS\n  [2] Sample SBE16\n  [3] Sample SBE37\n  Enter>", "%lu", "%lu", &input_var);
                    if( (input_var >= 1) && (input_var <= 3) ){
                      printf("\n\n");
                      if(input_var == 1)
                        SampleISUS(stdout, SAMPLE);
                      else if(input_var == 2)
                        SampleSBE16(stdout, SAMPLE);
                      else if(input_var == 3)
                        SampleSBE37(stdout, SAMPLE);
                      }
                    else
                      RangeError(1L, 3L);
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n",
                             "[A]ssign Logger Chan",
                             "[E]nable Logger Chan",
                             "[C]onnect Instrument",
                             "[S]ample  Instrument");
                    break;

            }//end switch

      } //end qret if

    } //end while
  }

void RadioModemSetup()
  {
  char   cmd;
  short  qret = TRUE;
  ulong  input_var;
  char *match_bauds[]={"0", "9600", "19200", "38400", "57600", "115200"};

  printf("\n/* LOBO Radio MODEM Setup Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_SETUP_RADIO>", NULL, "^[CBEFDLH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {

            case '^[' :
                    break;

            case 'C' :
                    ModemUserConnect(modem_baud);
                    break;

            case 'B' :
                    printf("\n  Radio RS232 Baud Rate = %lu\n", modem_baud);
                    input_var = 0;
                    if( QueryYesNo("\n  Modify", FALSE) ){
                      input_var = 0;
                      QueryNum("\n\n  Selection:\n   [1] 9600\n   [2] 19200\n   [3] 38400\n   [4] 57600\n   [5] 115200\n  Enter>", "%lu", "%lu", &input_var);
                      if(input_var != 0){
                        if( (input_var >= 1) && (input_var <= 5) ){
                          modem_baud = atol(match_bauds[input_var]);
                          if(RtcDevice != FALSE)
                            WrDS1994Long(MODEMBAUD_PTR, modem_baud, DS1994_ROM);
                          }
                        else
                          RangeError(1L, 5L);
                        }
                      } //end modify if
                    break;


            case 'E' :
                    if(RtcDevice == TRUE){
                      DS1994_elp = (ulong)RdDS1994Long(ELPTVAL_PTR, DS1994_ROM);
                      hdiv = ldiv(DS1994_elp, 3600L);
                      mdiv = ldiv(hdiv.rem, 60L);
                      printf("\n  Radio MODEM Total Connected On Time = %02ld:%02ld:%02ld = %lu secs\n",
                              hdiv.quot, mdiv.quot, mdiv.rem, DS1994_elp);
                      input_var = 0;
                      if( QueryYesNo("\n  Modify", FALSE) ){
                        input_var = 0;
                        QueryNum("\n\n  Enter Elapsed On Time (hours)", "%lu", "%lu", &input_var);
                        if(input_var != DS1994_elp){
                          if( (input_var >= 0) && (input_var <= 15000) ){
                            input_var = input_var * 3600L;
                            WrDS1994Long(ELPTVAL_PTR, input_var, DS1994_ROM);
                            printf("\n  Elapsed Time Counter Set");
                            }
                          }
                        else
                          RangeError(0L, 5000L);
                        }
                      }
                    else
                      printf("\n  NO RTC FOUND!\n");
                    break;

            case 'F' :
                    if(RtcDevice == TRUE){
                      connect_fail_ctr  = (ulong)RdDS1994Long( (ushort)CONNFAILCTR_PTR, DS1994_ROM);
                      connect_fail_time = (ulong)RdDS1994Long( (ushort)CONNFAILTIME_PTR, DS1994_ROM);
                      printf("\n  Radio MODEM Connection Failures =  %lu\n", connect_fail_ctr);
                      printf("\n  Last Connection Failure =  %s", ctime(&connect_fail_time) );
                      input_var = 0;
                      QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                      if(input_var == 1){
                        if(LoboPass() == TRUE){
                          connect_fail_ctr = connect_fail_time = 0L;
                          WrDS1994Long( (ushort)CONNFAILCTR_PTR, (ulong)connect_fail_ctr, DS1994_ROM);
                          WrDS1994Long( (ushort)CONNFAILTIME_PTR, (ulong)connect_fail_time, DS1994_ROM);
                          printf("\n  Connection Counter Cleared");
                          }
                        }
                      }
                    else
                      printf("\n  NO RTC FOUND!\n");
                    break;

            case 'D' :
                    if(RtcDevice == TRUE){
                      carrier_drop_ctr  = (ulong)RdDS1994Long( (ushort)CARRDROPCTR_PTR, DS1994_ROM);
                      carrier_drop_time = (ulong)RdDS1994Long( (ushort)CARRDROPTIME_PTR, DS1994_ROM);
                      printf("\n  Radio MODEM Dropped Carrier Detects =  %lu\n", carrier_drop_ctr);
                      printf("\n  Last Dropped Carrier =  %s", ctime(&carrier_drop_time) );
                      input_var = 0;
                      QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                      if(input_var == 1){
                        if(LoboPass() == TRUE){
                          carrier_drop_ctr = carrier_drop_time = 0L;
                          WrDS1994Long( (ushort)CARRDROPCTR_PTR, (ulong)carrier_drop_ctr, DS1994_ROM);
                          WrDS1994Long( (ushort)CARRDROPTIME_PTR, (ulong)carrier_drop_time, DS1994_ROM);
                          printf("\n  Carrier Drop Counter Cleared");
                          }
                        }
                      }
                    else
                      printf("\n  NO RTC FOUND!\n");
                    break;

            case 'L' :
                    printf("\n  Radio LED indicators are ");
                    if( LED_enable == TRUE )
                      printf("ENABLED\n");
                    else
                      printf("DISABLED\n");
                    if( QueryYesNo("\n  Modify", FALSE) ){
                      input_var = LED_enable;
                      QueryNum("\n\n  Selection:\n   [0] Disabled\n   [1] Enabled\n  Enter>", "%lu", "%lu", &input_var);
                      if(input_var != LED_enable){
                        if( (input_var >= 0) && (input_var <= 1) ){
                          LED_enable = (uchar)input_var;
                          if(RtcDevice != FALSE)
                            WrDS1994Byte(LEDENABLE_PTR, LED_enable, DS1994_ROM);
                          }
                        else
                          RangeError(0L, 1L);
                        }
                      }  //end modify if
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n %s\n",
                           "[C]onnect to MODEM",
                           "[B]aud Rate",
                           "[E]lapsed Timer",
                           "[F]ailed Connections",
                           "[D]ropped Connections",
                           "[L]ED Enable");
                    break;

            }//end switch

      } //end qret if

    }//end while

  printf("\n");
  }


void RtcSetup()
  {
  char   cmd;
  short  qret = TRUE;
  uchar  DS1994_ret;
  int    i;
  ulong  input_var;

  printf("\n/* LOBO TT8 & DS1994 RTC Setup Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_SETUP_RTC>", NULL, "^[GSZWTPRACLH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {

            case '^[' :
                    break;

            case 'G' :
                    DisplayTimes(DS1994_ROM, tzoffset);
                    break;

            case 'S' :
                    pic_secs = RtcToCtm();     // get time from TT8 PIC
                    DS1994_secs = (time_t)RdDS1994Long(TIMEVAL_PTR, DS1994_ROM);
                    printf("\n  TT8    Date/Time is %s", ctime(&DS1994_secs));
                    printf("  DS1994 Date/Time is %s", ctime(&DS1994_secs));
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      QueryDateTime("\n  Enter new Date and Time Value", TRUE, tp);
                      SetTimeTM(tp, NULL);       // set new time into PIC
                      pic_secs = RtcToCtm();     // get the new time from PIC
                      DS1994_ret = WrDS1994Long(TIMEVAL_PTR, pic_secs, DS1994_ROM);
                      printf("\n  Entered Time was %s\n", asctime(tp));
                      DisplayTimes(DS1994_ROM, tzoffset);
                      }
                    break;

            case 'Z' :
                    printf("\n  Offset of Local Time Zone from GMT ( [+] is W [-] is E ) %+02d", tzoffset);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      input_var = (long)tzoffset;
                      QueryNum("\n  Enter local time zone offset in hours", "%ld", "%ld", &input_var);
                      if((long)input_var != (long)tzoffset){
                        if( ((long)input_var >= -12) && ((long)input_var <= 12) ){
                          tzoffset = (int)input_var;
                          if(RtcDevice == 1)
                            WrDS1994Short(TZOFFSET_PTR, tzoffset, DS1994_ROM);
                          }
                        else
                          RangeError(-12L, 12L);
                        }
                      }
                    break;

            case 'W' :
                    tp = localtime(&last_sample);
                    printf("\n  Last Sample    Time = %02d/%02d/%02d %02d:%02d:%02d\n", tp->tm_mon+1, tp->tm_mday, tp->tm_year+1900, tp->tm_hour, tp->tm_min, tp->tm_sec);
                    tp = localtime(&wakeup.secs);
                    printf("\n  Current Wakeup Time = %02d/%02d/%02d %02d:%02d:%02d\n", tp->tm_mon+1, tp->tm_mday, tp->tm_year+1900, tp->tm_hour, tp->tm_min, tp->tm_sec);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to modify", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      tp = localtime(&wakeup.secs);
                      if( QueryDateTime("\n  Enter Wakeup Time", FALSE, tp) != TRUE){
                        printf("\n  Error, could not parse, value NOT saved!\n");
                        break;
                        }
                      pic_secs = RtcToCtm();
                      current_time = mktime(tp);  //on a real computer mktime expects the structure to be in localtime which it isn't in this case it's GMT!!!
                      if( current_time <= pic_secs ){
                        printf("\n  Error, wakeup set to a time of future past, value NOT saved!\n");
                        break;
                        }
                      else if(current_time == wakeup.secs){
                        printf("\n  Error, entry failed, value NOT saved!\n");
                        break;
                        }
                      else{
                        wakeup.secs = current_time;
                        printf("\n  Next Wakeup will be\n   %s", ctime(&wakeup.secs));
                        current_time = wakeup.secs - (tzoffset*3600L);
                        printf("  Adjusted Local Time\n   %s", ctime(&current_time));
                        }
                      }
                    break;

            case 'T' :
                    printf("\n  Transfering DS1994 RTC Values to TT8 RTC\n");
                    DS1994_secs = (time_t)RdDS1994Long(TIMEVAL_PTR, DS1994_ROM);
                    SetTimeSecs(DS1994_secs, NULL);  // set new time into PIC
                    break;

            case 'P' :
                    DS1994_pcc = (ulong)RdDS1994Long(PCCVAL_PTR, DS1994_ROM);
                    printf("\n  DS1994 Power Supply Cycles =  %lu\n", DS1994_pcc);
                    input_var = 0;
                    QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                    if(input_var == 1){
                      if(LoboPass() == TRUE){
                        DS1994_ret = WrDS1994Long(PCCVAL_PTR, 0L, DS1994_ROM);
                        printf("\n  Power Cycle Counter Cleared");
                        }
                      }
                    break;

            case 'R' :
                    if(RtcDevice == TRUE){
                      sys_reset_ctr  = (ulong)RdDS1994Long( (ushort)SYSRESETCTR_PTR, DS1994_ROM);
                      sys_reset_time = (ulong)RdDS1994Long( (ushort)SYSRESETTIME_PTR, DS1994_ROM);
                      printf("\n  Total Number of System Resets =  %lu\n", sys_reset_ctr);
                      printf("\n  Last System Reset =  %s", ctime(&sys_reset_time) );
                      input_var = 0;
                      QueryNum("\n  Enter [1] to clear", "%lu", "%lu", &input_var);
                      if(input_var == 1){
                        if(LoboPass() == TRUE){
                          sys_reset_ctr = sys_reset_time = 0L;
                          WrDS1994Long( (ushort)SYSRESETCTR_PTR, (ulong)sys_reset_ctr, DS1994_ROM);
                          WrDS1994Long( (ushort)SYSRESETTIME_PTR, (ulong)sys_reset_time, DS1994_ROM);
                          printf("\n  System Reset Counter Cleared");
                          }
                        }
                      }
                    else
                      printf("\n  NO RTC FOUND!\n");
                    break;

            case 'A' :
                    DS1994_ret = RdDS1994Byte(STATREG_PTR, DS1994_ROM);
                    printf("\n  DS1994 Status  Register = 0x%02Xh = ", DS1994_ret);
                    for(i = 0; i < 8; i++){
                      if((DS1994_ret & 0x80) != 0)
                        printf("1");
                      else
                        printf("0");
                      DS1994_ret = DS1994_ret << 1;
                      }
                    printf("b\n");
                    break;

            case 'C' :
                    DS1994_ret = RdDS1994Byte(CNTLREG_PTR, DS1994_ROM);
                    printf("\n  DS1994 Control Register = 0x%02Xh = ", DS1994_ret);
                    for(i = 0; i < 8; i++){
                      if((DS1994_ret & 0x80) != 0)
                        printf("1");
                      else
                        printf("0");
                      DS1994_ret = DS1994_ret << 1;
                      }
                    printf("b\n");
                    break;

            case 'L' :
                    if(LoboPass() == TRUE){ //make it bozo proof
                      LoadVarsNV((uchar)FALSE);
                      if(RtcDevice == 1)
                        InitVarsNV();
                      }
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n",
                           "[G]et Time Values",
                           "[S]et Time Values",
                           "Time [Z]one Offset",
                           "[W]akeup Time Value",
                           "[T]ransfer Time Values",
                           "[P]ower Cycle Counter",
                           "[R]eset Cycle Counter",
                           "St[A]tus Register Value",
                           "[C]ontrol Register Value",
                           "[L]oad LOBO defaults into RTC SRAM");
                    break;

            }//end switch

      }//end qret if

    }//end while

  printf("\n");
  }


/******************************************************************************/
/* LOBO Test Menu Routines                                                    */
/******************************************************************************/
//#TEST
void TestMenu(void)
  {
  char   fnbuf[MAXINBUFF];
  char   cmd;
  short  qret=TRUE;
  int    ret;
  long   rtcdelta;
  ulong  input_var;
  uchar  Port0, Port1, PortE;
  uchar  byte_mask;
  ushort relays;
  float  mean, min, max, stddev;
  FILE   *flash_file;

  printf("\n/* LOBO Test Menu <H> for Help */");
  fflush(stdout);

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_TEST>", NULL, "^[PLDSGCRTEIH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {
            case '^[' :
                    break;

            case 'P' :
                    if(modem_pwr == TRUE){
                      if(ModemPowerOff() == TRUE)
                        printf("\n  MODEM was powered OFF.\n");
                      }
                    else{
                      if(ModemPowerOn() == TRUE)
                        printf("\n  MODEM was powered ON and I2C I/O is responding.\n");
                      else
                        printf("\n  Could not power MODEM.\n");
                      }
                    break;

            case 'L' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else{
                      if( (ret=LinkToAccessPoint( LOBOSERV_USER_MODE )) == OK ){
                        printf("\n  Linked with Access Point in %.2f secs.\n", modem_connect_secs);
                        printf("\n  Signal Strength = %.2f = %.2f%%, StdDev = %.2f = %.2f%%\n", modem_rssi_avg, (modem_rssi_avg/127.0)*100.0, modem_rssi_sd, (modem_rssi_sd/modem_rssi_avg)*100.0);
                        }
                      else
                        printf("\n  COULD NOT Link with Access Point, RET = %d\n", ret);
                      }
                    break;

            case 'D' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else if( ModemCDActive() != TRUE )
                      printf("\n  Radio MODEM CD Inactive, NOT Connected with AP, exiting!\n");
                    else{
                      if( (ret=GetLinkRSSI(&mean, &stddev, LOBOSERV_USER_MODE)) == OK )
                        printf("\n  Signal Strength = %.2f = %.2f%%, StdDev = %.2f = %.2f%%\n", mean, (mean/127.0)*100.0, stddev, (stddev/mean)*100.0);
                      else
                        printf("\n  COULD NOT get RSSI Values, RET = %d\n", ret);
                      }
                    break;

            case 'S' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else if( ModemCDActive() != TRUE )
                      printf("\n  Radio MODEM CD Inactive, NOT Connected with AP, exiting!\n");
                    else{
                      input_var = 0;
                      QueryNum("\n  Select Server Cmd:\n  [1] Enter Talk Mode\n  [2] Ping the Server\n  [3] Sync RTC to Server\n  [4] Get PID from Server\n  [5] ZMODEM File to Server\n  Enter>", "%lu", "%lu", &input_var);
                      if( (input_var >= 1) && (input_var <= 5) ){
                        if( input_var == 1 ){
                          printf("\n  Attempting to connect to LOBO Talk Server\n");
                          if( (ret = LoboTalkMode(LOBOSERV_USER_MODE)) > 0 ){
                            printf("\n  Lobo Talk Server Returned OK, RET = %d\n", ret);
                            }
                          else
                            printf("\n  ERROR Connecting to Lobo Talk Server, RET = %d\n", ret);
                          break;
                          }
                        else if( input_var == 2 ){
                          input_var = 5;
                          QueryNum("\n  Enter # of pings", "%lu", "%lu", &input_var);
                          if( (input_var > 3) && (input_var <= 99) ){
                            if( (ret = PingServer((ushort)input_var, &mean, &min, &max, LOBOSERV_USER_MODE)) > 0 ){
                              printf("\n  Messages:  Sent = %d, Acknowledged = %d, Lost = %d\n", (short)input_var, ret, (short)(input_var - ret));
                              printf("  Approximate round trip times in milli-seconds:\n");
                              printf("  Minimum =  %.0fms, Maximum =  %.0fms, Average =  %.0fms\n", min, max, mean);
                              }
                            else
                              printf("\n  ERROR While Pinging Server, RET = %d\n", ret);
                            }
                          else
                            RangeError(3L, 99L);
                          break;
                          }
                        else if( input_var == 3 ){
                          if( (ret = SyncRtcToServer(&rtcdelta, LOBOSERV_USER_MODE)) > 0 )
                            printf("\n  Time Sync Delta (RTC - Server) = %ld\n", rtcdelta);
                          else
                            printf("\n  COULD NOT Sync Server Time, RET = %d\n", ret);
                          break;
                          }
                        else if( input_var == 4 ){
                          if( (ret = GetServerPID(&server_pid, LOBOSERV_USER_MODE )) > 0 )
                            printf("\n  Server PID value = %ld\n", server_pid);
                          else
                            printf("\n  COULD NOT Get Server PID, RET = %d\n", ret);
                          break;
                          }
                        else if( input_var == 5 ){
                          input_var = 0;
                          QueryNum("\n  Select File:\n  [1] Send a Specific File\n  [2] Send ALL Log Files\n  Enter>", "%lu", "%lu", &input_var);
                          if( (input_var >= 1) && (input_var <= 2) ){
                            if( input_var == 1 ){
                              printf("\nEnter Filename: ");
                              ret = safegets(fnbuf, MAXREAD);
                              if(ret != 0){
                                flash_file = fopen(fnbuf, "r");
                                if(flash_file == NULL){
                                  printf("Could not locate file: %s\n", fnbuf);
                                  fclose(flash_file);
                                  break;
                                  }
                                else{
                                  fclose(flash_file);
                                  if( (ret = ZmodemFilesToServer(1, fnbuf, LOBOSERV_USER_MODE)) == OK )
                                    printf("\n  ZmodemFilesToServer() RET = %d\n", ret);
                                  else
                                    printf("\n  ERROR!, ZmodemFilesToServer() RET = %d\n", ret);
                                  break;
                                  }
                                }
                              else{
                                printf("No name was entered\n");
                                break;
                                }
                              }
                            else if( input_var == 2 ){
                              if( (ret = ZmodemFilesToServer(20, "*.LOG", LOBOSERV_USER_MODE)) == OK )
                                printf("\n  ZmodemFilesToServer() RET = %d\n", ret);
                              else
                                printf("\n  ERROR!, ZmodemFilesToServer() RET = %d\n", ret);
                              break;
                              }
                            else{
                              RangeError(1L, 2L);
                              break;
                              }
                            } //end if input = 1 <-> 2
                          } //end else if = 5
                        } //end if input = 1 <-> 5
                      else
                        RangeError(1L, 5L);
                      }
                    break;

            case 'G' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else{
                      modem_id = ModemGetRadioID( modem_baud );
                      printf("\n  MODEM ID Return: 0x%06lX\n", modem_id);
                      }
                    break;

            case 'C' :
                    printf("\n  MODEM CTS (Clear To Send) toggle count: %lu\n", modem_cts_ctr);
                    break;

            case 'R' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else{
                      // pre  I2C port read, what is the status of BIT3, i.e., MODEM_STATUS
                      PortE = RdPortE();
                      DisplayByteVal("  CPU_PortE", PortE, TTY_DEVICE);
                      I2C_ReadInputPorts(&Port0, &Port1);
                      DisplayByteVal("  I2C_Port0", Port0, TTY_DEVICE);
                      DisplayByteVal("  I2C_Port1", Port1, TTY_DEVICE);
                      }
                    break;

            case 'T' :
                    if(modem_pwr == FALSE)
                      printf("\n  Radio MODEM is not powered, exiting!\n");
                    else{
                      input_var = 0;
                      QueryNum("\n  Select MODEM Bit:\n  [1] Toggle CFG\n  [2] Toggle RTS\n  [3] Toggle Sleep\n  [4] Toggle CD LED\n  [5] Toggle Standby LED\n  [6] Set/Reset K1\n  [7] Set/Reset K2\n  Enter>", "%lu", "%lu", &input_var);
                      if( (input_var >= 1) && (input_var <= 7) ){
                        I2C_ReadInputPorts(&Port0, &Port1);
                        if( input_var == 1 ){
                          if( Port0 & 0x01 ){
                            I2C_SetClrBitPort0(MODEM_CFG, TRUE);
                            printf("\n  MODEM CFG\ LINE ENABLED.\n");
                            }
                          else{
                            I2C_SetClrBitPort0(MODEM_CFG, FALSE);
                            printf("\n  MODEM CFG\ LINE DISABLED.\n");
                            }
                          break;
                          }
                        else if( input_var == 2 ){
                          if( Port0 & 0x02 ){
                            I2C_SetClrBitPort0(MODEM_RTS, TRUE);
                            printf("\n  MODEM RTS\ LINE ENABLED.\n");
                            }
                          else{
                            I2C_SetClrBitPort0(MODEM_RTS, FALSE);
                            printf("\n  MODEM RTS\ LINE DISABLED.\n");
                            }
                          break;
                          }
                        else if( input_var == 3 ){
                          if( Port0 & 0x04 ){
                            I2C_SetClrBitPort0(MODEM_SLEEP, FALSE);
                            printf("\n  MODEM SLEEP LINE DISABLED.\n");
                            }
                          else{
                            I2C_SetClrBitPort0(MODEM_SLEEP, TRUE);
                            printf("\n  MODEM SLEEP LINE ENABLED.\n");
                            }
                          break;
                          }
                        else if( input_var == 4 ){
                          if( Port1 & 0x80 ){
                            I2C_SetClrBitPort1(MODEM_CARRIER_LED, TRUE);
                            printf("\n  MODEM Board CD LED ENABLED.\n");
                            }
                          else{
                            I2C_SetClrBitPort1(MODEM_CARRIER_LED, FALSE);
                            printf("\n  MODEM Board LEDs DISABLED.\n");
                            }
                          break;
                          }
                        else if( input_var == 5 ){
                          if( Port1 & 0x40 ){
                            I2C_SetClrBitPort1(MODEM_STANDBY_LED, TRUE);
                            printf("\n  MODEM Board Stnadby LED ENABLED.\n");
                            }
                          else{
                            I2C_SetClrBitPort1(MODEM_STANDBY_LED, FALSE);
                            printf("\n  MODEM Board Stnadby LED DISABLED.\n");
                            }
                          break;
                          }
                        else if( input_var == 6 ){
                          if( (ret=ModemSetK1()) != TRUE){
                            printf("\nK1 Relay COULD NOT BE SET!, ret = %d\n", ret);
                            if( UsbActive() == TRUE )
                              printfUSB("\nK1 Relay COULD NOT BE SET!, ret = %d\n", ret);
                            }
                          else{
                            if( UsbActive() == TRUE )
                              printfUSB("\nK1 Relay SET, ret = %d\n", ret);
                            }
                          if( (ret=ModemResetK1()) != TRUE){
                            printf("\nK1 Relay COULD NOT BE RESET!, ret = %d\n", ret);
                            if( UsbActive() == TRUE )
                              printfUSB("\nK1 Relay COULD NOT BE RESET!, ret = %d\n", ret);
                            }
                          else{
                            if( UsbActive() == TRUE )
                              printfUSB("\nK1 Relay RESET, ret = %d\n", ret);
                            }
                          break;
                          }
                        else if( input_var == 7 ){
                          if( (ret=ModemSetK2()) != TRUE){
                            printf("\nK2 Relay COULD NOT BE SET!, ret = %d\n", ret);
                            if( UsbActive() == TRUE )
                              printfUSB("\nK2 Relay COULD NOT BE SET!, ret = %d\n", ret);
                            }
                          else{
                            if( UsbActive() == TRUE )
                              printfUSB("\nK2 Relay SET, ret = %d\n", ret);
                            }
                          if( (ret=ModemResetK2()) != TRUE){
                            printf("\nK2 Relay COULD NOT BE RESET!, ret = %d\n", ret);
                            if( UsbActive() == TRUE )
                              printfUSB("\nK2 Relay COULD NOT BE RESET!, ret = %d\n", ret);
                            }
                          else{
                            if( UsbActive() == TRUE )
                              printfUSB("\nK2 Relay RESET, ret = %d\n", ret);
                            }
                          break;
                          }
                        }
                      else
                        RangeError(1L, 7L);
                      }
                    break;

            case 'E' :
                    relays = Get_K1_K8_State();
                    DisplayByteVal("  K1 - K8 Relay State", relays, TTY_DEVICE);
                    input_var = 0;
                    QueryNum("\n  Enter Relay Number [K1-K11]", "%lu", "%lu", &input_var);
                    if( (input_var > 0) && (input_var <= 8) ){
                      byte_mask = 0x01;
                      byte_mask = byte_mask << (input_var-1);
                      if(relays & byte_mask){
                        printf("\n  K%ld is currently ENABLED, toggling state.\n", input_var);
                        relays = ((relays & byte_mask) << 8) & 0xFF00;
                        Set_K1_K8_State(relays);
                        }
                      else{
                        printf("\n  K%ld is currently DISABLED, toggling state.\n", input_var);
                        relays = (relays | byte_mask) & 0x00FF;
                        Set_K1_K8_State(relays);
                        }
                      }
                    else if( (input_var > 8) && (input_var <= 11) ){
                      printf("\n  Not yet supported, try back later!\n");
                      }
                    else
                      RangeError(1L, 11L);
                    break;

            case 'I' :
                    input_var = 3;
                    QueryNum("  Enter # of readings", "%lu", "%lu", &input_var);
                    if( (input_var > 0) && (input_var <= 10) ){
                      printf("\n");
                      print_sht75((int)input_var);
                      }
                    else
                      RangeError(1L, 10L);
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n",
                             "[P]ower Toggle MODEM",
                             "[L]ink to Access Point",
                             "[D]isplay RSSI Values",
                             "[S]]erver Commands",
                             "[G]et MODEM Serial Num",
                             "[C]urrent CTS Toggles",
                             "[R]ead MODEM I2C Ports",
                             "[T]oggle MODEM I2C Bit",
                             "[E]nable Disable Relay",
                             "[I]nternal Temp/Humidity");
                     break;

            }//end switch

      } //end qret if

    } //end while
  }

/******************************************************************************/
/* LOBO File Menu Routines                                                    */
/******************************************************************************/
//#FILE
void FileMenu(void)
  {
  char   cmd;
  short  qret = TRUE;

  printf("\n/* LOBO File Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_FILE>", NULL, "^[FDUOREMH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {

            case '^[' :
                    break;

            case 'F' :
                    execstr("DIR");
                    break;

            case 'D' :
                    DownloadFile();
                    break;

            case 'U' :
                    UploadFile();
                    break;

            case 'O' :
                    DisplayFile();
                    break;

            case 'R' :
                    RenameFile();
                    break;

            case 'E' :
                    if(LoboPass() == TRUE){ //make it bozo proof
                      EraseFile();
                      }
                    break;

            case 'M' :
                    if(LoboPass() == TRUE){ //make it bozo proof
                      EraseFiles();
                      }
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n %s\n %s\n",
                           "[F]lash Directory",
                           "[D]ownload File",
                           "[U]pload File",
                           "[O]utput File",
                           "[R]ename File",
                           "[E]rase File",
                           "[M]ulti Erase");
                    break;

            }//end switch

      }//end qret if

    }//end while

  }

void DownloadFile(void)
  {
  char   fnbuf[MAXINBUFF];
  char   pico_cmd[85];      //PicoDOS command line buff is only 81 chars
  char   enbuf[20];
  char   wcbuf[20];
  int    ret, i, j;
  ulong  proto, baud, recs_found, rec_ctr;
  ulong  UsbBytesSent, UsbuSecsTaken;
  double UsbSecsTaken;
  long   old_baud, old_freq, new_baud, new_freq;
  size_t lenext;
  FILE   *flash_file;
  ushort files = 100;    // allocate listing for 100 files at 24chars each
  DirStrEntry *dlist;

    printf("\n/* LOBO File Download */");

    proto = 0;
    QueryNum("\nSelect Protocol:\n  [1] Xmodem\n  [2] Ymodem\n  [3] YmodemBatch\n  [4] USB Xfer\n  Enter>", "%lu", "%lu", &proto);
    if((proto < 1) || (proto > 4)){
      printf("No Protocol Selected\n");
      return();
      }

    if((proto == 1) || (proto == 2) ){
      printf("\n\nEnter Filename: ");
      ret = safegets(fnbuf, MAXREAD);
      if(ret != 0){
        flash_file = fopen(fnbuf, "r");
        if(flash_file == NULL){
          printf("Could not locate file: %s\n", fnbuf);
          fclose(flash_file);
          return();
          }
        fclose(flash_file);
        }
      else{
        printf("No name was entered\n");
        return();
        }
      } //end proto=1or2

    else if((proto == 3) || (proto == 4) ){
      printf("\nEnter Common Extension Name of Multiple Files: ");
      ret = safegets(enbuf, 15);
      if(ret != 0){
        lenext=strlen(enbuf);
        if( lenext > 3 ){
          printf("Filename extension can't be greater than 3 chars!\n");
          return();
          }
        dlist = AllocateDirListingMem(files);
        if(dlist == NULL){
          printf("Could not allocate DirMem\n");
          free(dlist);
          return();
          }
        sprintf(wcbuf, "*.%s", enbuf);
        if( (recs_found = CreateDirListing(dlist, wcbuf, files)) <= 0){
          printf("No Files with that extension where found!\n");
          free(dlist);
          return();
          }
        else{
          printf("There were %lu files with that extension found!\n", recs_found);
          }
        } // end ret if
      else{
        printf("No extension name was entered\n");
        return();
        }
      } //end proto=3or4

    baud = 0;
    if(proto != 4){
      QueryNum("\nSelect BaudRate:\n  [0] CurrentBaud\n  [1] 9600\n  [2] 19200\n  [3] 38400\n  [4] 57600\n  [5] 115200\n  Enter>", "%lu", "%lu", &baud);
      if((baud < 0) || (baud > 5)){
        printf("\nInvalid BaudRate Selected\n");
        free(dlist);
        return();
        }

      old_freq = SimGetFSys();
      old_baud = SerGetBaud(0L, 0L);

      if(baud != 0){
        printf("\n\nSwitching BaudRate in 30 secs!\n");
        Sleep(0L);
        Sleep(30000L);
        if(baud == 1)
          new_baud = SerSetBaud(9600L, 0L);
        else if(baud == 2)
          new_baud = SerSetBaud(19200L, 0L);
        else if(baud == 3)
          new_baud = SerSetBaud(38400L, 0L);
        else if(baud == 4){
          new_freq = SimSetFSys(14720000L);
          new_baud = SerSetBaud(57600L, new_freq);
          }
        else if(baud == 5){
          new_freq = SimSetFSys(14720000L);
          new_baud = SerSetBaud(115200L, new_freq);
          }
        printf("BaudRate switched to %ld\n", new_baud);
        }
      else
        printf("\n\n");
      }

    if(proto == 1){
      printf("Starting XMODEM Transfer of %s\n", fnbuf);
      sprintf(pico_cmd, "XS -Q %s", fnbuf);
      execstr(pico_cmd);
      }
    else if(proto == 2){
      printf("Starting YMODEM Transfer of %s\n", fnbuf);
      sprintf(pico_cmd, "YS -Q %s", fnbuf);
      execstr(pico_cmd);
      }
    else if(proto == 3){
      j = 0;
      rec_ctr = recs_found;
      while( rec_ctr > 0 ){
        i = 1;
        //we know there is at least 1
        if(rec_ctr == 1)
          sprintf(pico_cmd, "YS -Q %s", dlist->name);
        else{
          sprintf(pico_cmd, "YS -Q %s,", dlist->name);
          --rec_ctr;
          if(rec_ctr != 0)
            ++dlist;
          }
        //we've done 1, now let's do up to 5 or how many are left
        while( (rec_ctr > 0) && (i < 5) ){
          ++i;
          if( (rec_ctr == 0) || (i == 5) )
            sprintf((strrchr(pico_cmd, ',') + 1), "%s", dlist->name);
          else
            sprintf((strrchr(pico_cmd, ',') + 1), "%s,", dlist->name);
          --rec_ctr;
          if(rec_ctr != 0)
            ++dlist;
          }
        ++j;
        printf("\nStarting YMODEM Batch Transfer #%d of %d files out of %lu\n", j, i, recs_found);
        //printf("%s\n", pico_cmd);
        execstr(pico_cmd);
        } //end rec_ctr for
      free(dlist);
      } //end elseif
    else if(proto == 4){
      rec_ctr = recs_found;
      printf("%lu Records Found\n", recs_found);
      while( rec_ctr > 0 ){
        printf("Starting USB Transfer of %s with %s bytes\n", dlist->name, dlist->lenstr);
        printfUSB("\n<%s><START>\n", dlist->name);
        ret = Send_USB_File(dlist->name, &UsbBytesSent, &UsbuSecsTaken);
        printfUSB("\n<%s><FINISH>\n", dlist->name);
        if( ret == TRUE ){
          UsbSecsTaken = (double)UsbuSecsTaken / 1000000.0;
          printf("\nUSB ASCII Transfer ret = %d\n", ret);
          printf("\nTransfer of %lu Bytes in %lf secs\n", UsbBytesSent, UsbSecsTaken);
          printf("\nTransfer rate = %.0lf Bytes/Sec = %.0lf Bits/Sec\n", (double) (UsbBytesSent) / UsbSecsTaken, ((double) (UsbBytesSent) / UsbSecsTaken) * 8.0 );
          }
        else
          printf("\nERROR, USB ASCII Transfer ret = %d\n", ret);
        --rec_ctr;
        if(rec_ctr != 0)
          ++dlist;
        } //end rec_ctr for
      free(dlist);
      } //end elseif

    if(baud != 0){
      printf("Switching BaudRate back to %ld in 30 secs!\n", old_baud);
      Sleep(0L);
      Sleep(30000L);
      if(baud >= 4){
        new_freq = SimSetFSys(old_freq);
        SerSetBaud(old_baud, new_freq);
        }
      else
        SerSetBaud(old_baud, 0L);
      }

    printf("\nDownload complete\n");

  }

void FNameError(void){
     printf("Filename can only have 8 char NAME and 3 char EXTENSION!\n");
     }

void UploadFile(void)
  {
  char   fnbuf[MAXINBUFF];
  char   cmdbuff[MAXINBUFF];
  char   legal[] = ".-_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  int    lchar, ret, i;
  size_t lentot, lenfn;

    printf("\nEnter Filename: ");
    ret = safegets(fnbuf, MAXREAD);
    if(ret != 0){
      strupr(fnbuf);
      lentot=strlen(fnbuf);
      lenfn=strcspn(fnbuf, ".");
      if( lentot > (8+4) ){
        FNameError();  // file name + any ext is > 12
        return();
        }
      if( lenfn > 8 ){                                 // when '.' is or isn't found
        FNameError();  //file name is > 8
        return();
        }
      if( lenfn == 1 ){                                // when '.' is found
        FNameError();  //no file name just extension
        return();
        }
      if( (lenfn != lentot) & ((lentot-lenfn) > (3+1) ) ){ // when '.' is found
        FNameError();  //file ext  is > 3
        return();
        }
      for(i = 0; i < lentot; i++ ){
        lchar = fnbuf[i];
        if(strchr(legal, lchar) == NULL){
          printf("Illegal char %c at %d in filename!\n", lchar, i+1);
          return();
          }
        }
      } // end ret if
    else{
      printf("No name was entered\n");
      return();
      }

    printf("Starting XMODEM Upload of %s\n", fnbuf);
    sprintf(cmdbuff, "XR -X %s", fnbuf);
    execstr(cmdbuff);

  }

void DisplayFile(void)
  {
  char   fnbuf[MAXINBUFF];
  char   cmdbuff[MAXINBUFF];
  int    ret;
  FILE   *flash_file;

    printf("\nEnter Filename: ");
    ret = safegets(fnbuf, MAXREAD);
    if(ret != 0){
      flash_file = fopen(fnbuf, "r");
      if(flash_file == NULL){
        printf("Could not locate file: %s\n", fnbuf);
        fclose(flash_file);
        return();
        }
      fclose(flash_file);
      }
    else{
      printf("No name was entered\n");
      return();
      }

    printf("\nOutputFileStart\n");
    sprintf(cmdbuff, "type %s", fnbuf);
    execstr(cmdbuff);
    printf("OutputFileEnd\n");

  }

void RenameFile(void)
  {
  char   fn1buf[MAXINBUFF];
  char   fn2buf[MAXINBUFF];
  char   legal[] = ".-_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  int    lchar, ret, i;
  size_t lentot, lenfn;
  FILE   *flash_file;

    printf("\nEnter Old Filename: ");
    ret = safegets(fn1buf, MAXREAD);
    if(ret != 0){
      flash_file = fopen(fn1buf, "r");
      if(flash_file == NULL){
        printf("Could not locate file: %s\n", fn1buf);
        fclose(flash_file);
        return();
        }
      fclose(flash_file);
      }
    else{
      printf("No name was entered\n");
      return();
      }

    printf("\nEnter New Filename: ");
    ret = safegets(fn2buf, MAXREAD);
    if(ret != 0){
      strupr(fn2buf);
      lentot=strlen(fn2buf);
      lenfn=strcspn(fn2buf, ".");
      if( lentot > (8+4) ){
        FNameError();  // file name + any ext is > 12
        return();
        }
      if( lenfn > 8 ){                                 // when '.' is or isn't found
        FNameError();  //file name is > 8
        return();
        }
      if( lenfn == 1 ){                                // when '.' is found
        FNameError();  //no file name just extension
        return();
        }
      if( (lenfn != lentot) & ((lentot-lenfn) > (3+1) ) ){ // when '.' is found
        FNameError();  //file ext  is > 3
        return();
        }
      for(i = 0; i < lentot; i++ ){
        lchar = fn2buf[i];
        if(strchr(legal, lchar) == NULL){
          printf("Illegal char %c at %d in filename!\n", lchar, i+1);
          return();
          }
        }
      } // end ret if
    else{
      printf("No name was entered\n");
      return();
      }

    if(strcmp(strupr(fn1buf), fn2buf) == 0){
      printf("Filenames are the same!\n");
      return();
      }

    rename(fn1buf, fn2buf);

    flash_file = fopen(fn2buf, "r");
    if(flash_file == NULL){
      printf("%s could not be renamed!\n", fn1buf);
      fclose(flash_file);
      return();
      }
    fclose(flash_file);
    printf("%s was renamed to %s!\n", fn1buf, fn2buf);

  }

void EraseFile(void)
  {
  char   fnbuf[MAXINBUFF];
  int    ret;
  ulong  input_var;
  FILE   *flash_file;

    printf("\nEnter Filename: ");
    ret = safegets(fnbuf, MAXREAD);
    if(ret != 0){
      flash_file = fopen(fnbuf, "r");
      if(flash_file == NULL){
        printf("Could not locate file: %s\n", fnbuf);
        fclose(flash_file);
        return();
        }
      fclose(flash_file);
      }
    else{
      printf("No name was entered\n");
      return();
      }

    input_var = 0;
    input_var = QueryYesNo(fnbuf, TRUE);
    if(input_var == TRUE){
      printf("\nBe patient it could take awhile.\n");
      ret = remove(fnbuf);
      if(ret == 0)
        printf("\n%s Was Deleted!\n", fnbuf);
      else
        printf("\n%s Could NOT be Deleted!\n", fnbuf);
      }

  }

void EraseFiles(void)
  {
  char   enbuf[20];
  char   wcbuf[20];
  int    ret;
  ulong  input_var;
  ulong  recs_found, rec_ctr, del_ctr;
  size_t lenext;
  ushort files = 100;     // allocate listing for 100 files at 24chars each
  DirStrEntry *dlist;

    printf("\n/* LOBO Multiple File Erase */");
    printf("\nBe patient, erasing can take awhile.\n");

    printf("\nEnter Common Extension Name of Multiple Files: ");
    ret = safegets(enbuf, 15);
    if(ret != 0){
      lenext=strlen(enbuf);
      if( lenext > 3 ){
        printf("Filename extension can't be greater than 3 chars!\n");
        return();
        }

      dlist = AllocateDirListingMem(files);
      if(dlist == NULL){
        printf("Could not allocate DirMem\n");
        free(dlist);
        return();
        }

      sprintf(wcbuf, "*.%s", enbuf);
      if( (recs_found = CreateDirListing(dlist, wcbuf, files)) <= 0){
        printf("No Files with that extension where found!\n");
        free(dlist);
        return();
        }
      else{
        printf("There were %lu files with that extension found!\n", recs_found);
        }
      } // end ret if
    else{
      printf("No extension name was entered\n");
      return();
      }

    del_ctr = 0;
    rec_ctr = recs_found;
    while( rec_ctr > 0 ){
      input_var = 0;
      input_var = QueryYesNo(dlist->name, TRUE);
      if(input_var == TRUE){
        ret = remove(dlist->name);
        if(ret == 0){
          printf(" *\n");
          ++del_ctr;
          }
        else
          printf("\n%s Could NOT be Deleted!\n", dlist->name);
        }  //end input_var if
      else
        printf("\n");

      --rec_ctr;
      if(rec_ctr != 0)
        ++dlist;
      } //end while

    free(dlist);
    printf("\nMulti Erase Complete, %lu files removed\n", del_ctr);

  }


/******************************************************************************/
/* LOBO Info Menu Routines                                                    */
/******************************************************************************/
//#INFO
void InfoMenu(void)
  {
  char   cmd;
  short  qret = TRUE;
  ushort relays;
  ulong  input_var;
  ulong  *pPrgSize = (ulong *)((long)&_H0_end - (long)&_H0_org) + 1L;
  ulong  *pVarSize = (ulong *)((long)&_H1_end - (long)&_H1_org) + 1L;
  float  battv, battsd;

  printf("\n/* LOBO Info Menu <H> for Help */");

  while(qret == TRUE){
    printf("\n");
    qret=QueryChar("LOBO_INFO>", NULL, "^[AFTCSH", &cmd);
    printf("\n");

    if(qret == TRUE){
      switch (cmd)
            {

            case '^[' :
                    break;

            case 'A' :
                    printf("\n  LOBO Build: %s Date: %s %s\n", strupr(bfile), bdate, btime);
                    printf("  Program Size: %lu Bytes\n", pPrgSize);
                    printf("  InitVar Size: %lu Bytes\n", pVarSize);
                    InfoTT8(shortDisplay);  // use fullDisplay for register info
                    break;

            case 'F' :
                    printf("\n  Persistor S/N - PicoDOS Ver: %s\n", picodosver());
                    pdcfinfo("A:", &size, &avail);
                    printf("  CF Card: Size=%ld Free=%ld \n", size, avail);
                    break;

            case 'T' :
                    if(RtcDevice == 1){
                      printf("\n  DS1994");
                      TouchRomPrint(DS1994_ROM);
                      }
                    if(RamDevice == 1){
                      printf("\n  DS1996");
                      TouchRomPrint(DS1996_ROM);
                      }
                    if(TempDevices >= 1){
                      printf("\n  DS1820 #1");
                      TouchRomPrint(DS1820_ROM1);
                      }
                    if(TempDevices >= 2){
                      printf("\n  DS1820 #2");
                      TouchRomPrint(DS1820_ROM2);
                      }

                    break;

            case 'C' :
                    DisplayChipSelectSettings();
                    break;

            case 'S' :
    //clean up later!
    DisplayTimes(DS1994_ROM, tzoffset);

    RdBattVoltage(&battv, &battsd);
    printf("\n  System Voltage = %.2f StdDev = %.2lf\n", battv, battsd);

    relays = Get_K1_K8_State();
    DisplayByteVal("  Comm Relay State", relays, TTY_DEVICE);

    print_sht75(1);

    printf("  System Power Cycles = %lu\n", DS1994_pcc);
    printf("  System Reset Cycles = %lu\n", sys_reset_ctr);
    printf("  Watchdog RST Cycles = %lu\n", watchdog_ctr);

    printf("\n  Dropped Connections = %lu\n", carrier_drop_ctr);
    printf("  Last Drop Time      = %s", ctime(&carrier_drop_time));

    printf("  Connection Failures = %lu\n", connect_fail_ctr);
    printf("  Last Failure Time   = %s", ctime(&connect_fail_time));

    hdiv = ldiv(DS1994_elp, 3600L);
    mdiv = ldiv(hdiv.rem, 60L);
    printf("  Connection Odometer = %02ld:%02ld:%02ld = %lu secs\n", hdiv.quot, mdiv.quot, mdiv.rem, DS1994_elp);
                    break;

            case 'H' :
                    printf(" %s\n %s\n %s\n %s\n %s\n",
                           "[A]pplication Ver",
                           "[F]LASH Adapter",
                           "[T]ouch Memory",
                           "[C]hip Selects",
                           "[S]ystem Status");
                    break;
            }//end switch

      }//end qret if

    }//end while

  }

/******************************************************************************/
/* LOBO Misc Menu Routines                                                    */
/******************************************************************************/
//#MISC

void RangeError(long val1, long val2)
  {
    printf("\n  Invalid Entry, valid range = %ld - %ld\n", val1, val2);
  }

int LoboPass()
  {
  char   inbuff[MAXINBUFF];
  ulong  input_var;

    input_var = -1;
    printf("\n  Enter LOBO Password: ");
//  SerShutDown(TRUE, FALSE);
    if( (safegets(inbuff, MAXREAD)) != 0){
      input_var = strcmp(strupr(inbuff), "!BOZO");
      }
//  SerActivate();
    if(input_var == 0)
      return(TRUE);
    else{
      printf("\n  Invalid Password!\n");
      return(FALSE);
      }
  }