diff --git a/camerad/archon.cpp b/camerad/archon.cpp
index 55001dca..fa5a5030 100644
--- a/camerad/archon.cpp
+++ b/camerad/archon.cpp
@@ -36,7 +36,7 @@ namespace Archon {
     this->image_data = nullptr;
     this->image_data_bytes = 0;
     this->image_data_allocated = 0;
-    this->is_longexposure = false;
+    this->is_longexposure_set = false;
     this->is_window = false;
     this->is_autofetch = false;
     this->win_hstart = 0;
@@ -230,12 +230,12 @@ namespace Archon {
     this->camera_info.port = -1;
     this->archon.setport( -1 );
 
-    this->is_longexposure = false;
     this->n_hdrshift = 16;
 
     this->camera.firmware[0] = "";
 
     this->exposeparam = "";
+    this->longexposeparam.clear();
     this->trigin_exposeparam = "";
     this->trigin_untimedparam = "";
     this->trigin_readoutparam = "";
@@ -300,6 +300,14 @@ namespace Archon {
         applied++;
       }
 
+      if ( config.param[entry] == "LONGEXPOSE_PARAM" ) {                       // LONGEXPOSE_PARAM
+        this->longexposeparam = config.arg[entry];
+        message.str(""); message << "CONFIG:" << config.param[entry] << "=" << config.arg[entry];
+        logwrite( function, message.str() );
+        this->camera.async.enqueue( message.str() );
+        applied++;
+      }
+
       if (config.param[entry].compare(0, 19, "TRIGIN_EXPOSE_PARAM")==0) {      // TRIGIN_EXPOSE_PARAM
         this->trigin_exposeparam = config.arg[entry];
         message.str(""); message << "CONFIG:" << config.param[entry] << "=" << config.arg[entry];
@@ -1756,14 +1764,6 @@ namespace Archon {
 
     this->modeselected = false;           // require that a mode be selected after loading new firmware
 
-    // Even if exptime, longexposure were previously set, a new ACF could have different
-    // default values than the server has, so reset these to "undefined" in order to
-    // force the server to ask for them.
-    //
-    this->camera_info.exposure_time   = -1;
-    this->camera_info.exposure_factor = -1;
-    this->camera_info.exposure_unit.clear();
-
     return error;
   }
   /**************** Archon::Interface::load_acf *******************************/
@@ -3756,34 +3756,43 @@ namespace Archon {
     // same default values that the ACF has, rather than hope that the ACF programmer picks
     // their defaults to match mine.
     //
-    if ( this->camera_info.exposure_time   == -1 ) {
+    if ( ! this->camera_info.exposure_time.is_set() ) {
       logwrite( function, "NOTICE:exptime has not been set--will read from Archon" );
       this->camera.async.enqueue( "NOTICE:exptime has not been set--will read from Archon" );
 
       // read the Archon configuration memory
       //
       std::string etime;
-      if ( read_parameter( "exptime", etime ) != NO_ERROR ) { logwrite( function, "ERROR: reading \"exptime\" parameter from Archon" ); return ERROR; }
+      if ( read_parameter( "exptime", etime ) != NO_ERROR ) {
+        logwrite( function, "ERROR: reading \"exptime\" parameter from Archon" );
+        return ERROR;
+      }
 
       // Tell the server these values
       //
       std::string retval;
       if ( this->exptime( etime, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting exptime" ); return ERROR; }
     }
-    if ( this->camera_info.exposure_factor == -1 ||
-         this->camera_info.exposure_unit.empty() ) {
+
+    if ( ! this->is_longexposure_set && ! this->longexposeparam.empty() ) {
       logwrite( function, "NOTICE:longexposure has not been set--will read from Archon" );
       this->camera.async.enqueue( "NOTICE:longexposure has not been set--will read from Archon" );
 
       // read the Archon configuration memory
       //
       std::string lexp;
-      if ( read_parameter( "longexposure", lexp ) != NO_ERROR ) { logwrite( function, "ERROR: reading \"longexposure\" parameter from Archon" ); return ERROR; }
+      if ( read_parameter( this->longexposeparam, lexp ) != NO_ERROR ) {
+        logwrite( function, "ERROR reading \""+this->longexposeparam+"\" parameter from Archon" );
+        return ERROR;
+      }
 
       // Tell the server these values
       //
       std::string retval;
-      if ( this->longexposure( lexp, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting longexposure" ); return ERROR; }
+      if ( this->longexposure( lexp, retval ) != NO_ERROR ) {
+        logwrite( function, "ERROR: setting longexposure" );
+         return ERROR;
+       }
     }
 
     // If nseq_in is not supplied then set nseq to 1.
@@ -3915,7 +3924,7 @@ namespace Archon {
           message.str(""); message << "pre-exposure " << expcount << " of " << this->camera_info.num_pre_exposures;
           logwrite( function, message.str() );
 
-          if ( this->camera_info.exposure_time != 0 ) {                 // wait for the exposure delay to complete (if there is one)
+          if ( this->camera_info.exposure_time.value() != 0 ) {         // wait for the exposure delay to complete (if there is one)
             error = this->wait_for_exposure();
             if ( error != NO_ERROR ) {
               logwrite( function, "ERROR: waiting for pre-exposure" );
@@ -3966,7 +3975,7 @@ namespace Archon {
           }
         }
 
-        if ( this->camera_info.exposure_time != 0 ) {                   // wait for the exposure delay to complete (if there is one)
+        if ( this->camera_info.exposure_time.value() != 0 ) {           // wait for the exposure delay to complete (if there is one)
           error = this->wait_for_exposure();
           if ( error != NO_ERROR ) {
             logwrite( function, "ERROR: waiting for exposure" );
@@ -4521,34 +4530,43 @@ namespace Archon {
         // This ensures that, if the client doesn't set these values then the server will have the
         // same default values that the ACF has, rather than hope that the ACF programmer picks
         // their defaults to match mine.
-        if ( this->camera_info.exposure_time   == -1 ) {
+        if ( ! this->camera_info.exposure_time.is_set() ) {
             logwrite( function, "NOTICE:exptime has not been set--will read from Archon" );
             this->camera.async.enqueue( "NOTICE:exptime has not been set--will read from Archon" );
 
             // read the Archon configuration memory
             //
             std::string etime;
-            if ( read_parameter( "exptime", etime ) != NO_ERROR ) { logwrite( function, "ERROR: reading \"exptime\" parameter from Archon" ); return ERROR; }
+            if ( read_parameter( "exptime", etime ) != NO_ERROR ) {
+              logwrite( function, "ERROR: reading \"exptime\" parameter from Archon" );
+               return ERROR;
+            }
 
             // Tell the server these values
             //
             std::string retval;
             if ( this->exptime( etime, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting exptime" ); return ERROR; }
         }
-        if ( this->camera_info.exposure_factor == -1 ||
-             this->camera_info.exposure_unit.empty() ) {
+
+        if ( ! this->is_longexposure_set && ! this->longexposeparam.empty() ) {
             logwrite( function, "NOTICE:longexposure has not been set--will read from Archon" );
             this->camera.async.enqueue( "NOTICE:longexposure has not been set--will read from Archon" );
 
             // read the Archon configuration memory
             //
             std::string lexp;
-            if ( read_parameter( "longexposure", lexp ) != NO_ERROR ) { logwrite( function, "ERROR: reading \"longexposure\" parameter from Archon" ); return ERROR; }
+            if ( read_parameter( this->longexposeparam, lexp ) != NO_ERROR ) {
+              logwrite( function, "ERROR: reading \"longexposure\" parameter from Archon" );
+               return ERROR;
+            }
 
             // Tell the server these values
             //
             std::string retval;
-            if ( this->longexposure( lexp, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting longexposure" ); return ERROR; }
+            if ( this->longexposure( lexp, retval ) != NO_ERROR ) {
+              logwrite( function, "ERROR setting longexposure" );
+              return ERROR;
+            }
         }
 
         // If nseq_in is not supplied then set nseq to 1.
@@ -4642,7 +4660,7 @@ namespace Archon {
             // }
 
             // wait for the exposure delay to complete (if there is one)
-            if ( this->camera_info.exposure_time != 0 ) {
+            if ( this->camera_info.exposure_time.value() != 0 ) {
                 error = this->wait_for_exposure();
                 if ( error != NO_ERROR ) {
                     logwrite( function, "ERROR: waiting for exposure" );
@@ -4752,7 +4770,7 @@ namespace Archon {
       // same default values that the ACF has, rather than hope that the ACF programmer picks
       // their defaults to match mine.
       //
-      if ( this->camera_info.exposure_time   == -1 ) {
+      if ( ! this->camera_info.exposure_time.is_set() ) {
           logwrite( function, "NOTICE:exptime has not been set--will read from Archon" );
           this->camera.async.enqueue( "NOTICE:exptime has not been set--will read from Archon" );
 
@@ -4766,20 +4784,25 @@ namespace Archon {
           std::string retval;
           if ( this->exptime( etime, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting exptime" ); return ERROR; }
       }
-      if ( this->camera_info.exposure_factor == -1 ||
-           this->camera_info.exposure_unit.empty() ) {
+      if ( ! this->is_longexposure_set && ! this->longexposeparam.empty() ) {
           logwrite( function, "NOTICE:longexposure has not been set--will read from Archon" );
           this->camera.async.enqueue( "NOTICE:longexposure has not been set--will read from Archon" );
 
           // read the Archon configuration memory
           //
           std::string lexp;
-          if ( read_parameter( "longexposure", lexp ) != NO_ERROR ) { logwrite( function, "ERROR: reading \"longexposure\" parameter from Archon" ); return ERROR; }
+          if ( read_parameter( this->longexposeparam, lexp ) != NO_ERROR ) {
+            logwrite( function, "ERROR: reading \"longexposure\" parameter from Archon" );
+             return ERROR;
+          }
 
           // Tell the server these values
           //
           std::string retval;
-          if ( this->longexposure( lexp, retval ) != NO_ERROR ) { logwrite( function, "ERROR: setting longexposure" ); return ERROR; }
+          if ( this->longexposure( lexp, retval ) != NO_ERROR ) {
+            logwrite( function, "ERROR setting longexposure" );
+            return ERROR;
+          }
       }
 
       // If nseq_in is not supplied then set nseq to 1.
@@ -4894,7 +4917,7 @@ namespace Archon {
                   message.str(""); message << "pre-exposure " << expcount << " of " << this->camera_info.num_pre_exposures;
                   logwrite( function, message.str() );
 
-                  if ( this->camera_info.exposure_time != 0 ) {                 // wait for the exposure delay to complete (if there is one)
+                  if ( this->camera_info.exposure_time.value() != 0 ) {         // wait for the exposure delay to complete (if there is one)
                       error = this->wait_for_exposure();
                       if ( error != NO_ERROR ) {
                           logwrite( function, "ERROR: waiting for pre-exposure" );
@@ -4945,7 +4968,7 @@ namespace Archon {
                   }
               }
 
-              if ( this->camera_info.exposure_time != 0 ) {                   // wait for the exposure delay to complete (if there is one)
+              if ( this->camera_info.exposure_time.value() != 0 ) {           // wait for the exposure delay to complete (if there is one)
                   error = this->wait_for_exposure();
                   if ( error != NO_ERROR ) {
                       logwrite( function, "ERROR: waiting for exposure" );
@@ -5047,12 +5070,10 @@ namespace Archon {
     /**************** Archon::Interface::video *********************************/
 
 
-    /**************** Archon::Interface::wait_for_exposure **********************/
+  /***** Archon::Interface::wait_for_exposure *********************************/
   /**
-   * @fn     wait_for_exposure
-   * @brief  creates a wait until the exposure delay has completed
-   * @param  none
-   * @return ERROR or NO_ERROR
+   * @brief      creates a wait until the exposure delay has completed
+   * @return     ERROR | NO_ERROR
    *
    * This is not the actual exposure delay, nor does it accurately time the exposure
    * delay. This function merely creates a reasonably accurate wait on the host to
@@ -5071,49 +5092,74 @@ namespace Archon {
     std::stringstream message;
     long error = NO_ERROR;
 
-    int exposure_timeout_time;  // Time to wait for the exposure delay to time out
-    unsigned long int timer, increment=0;
+    // Predicting when the exposure ends requires knowing when it started.
+    // The Archon timer was read when the exposure was initiated but that
+    // may generate multiple frames so each time through here requires
+    // getting the start time. It's not accurate but good enough for this.
+    //
+    unsigned long int archon_start_time;
+    error = this->get_timer(&archon_start_time);                  // Archon internal timer (one tick=10 nsec)
 
-    // For long exposures, waittime is 1 second less than the exposure time.
-    // For short exposures, waittime is an integral number of msec below 90% of the exposure time
-    // and will be used to keep track of elapsed time, for timeout errors.
+    // set a max timeout time of 1000 ms more than the exposure time
     //
-    double waittime;
-    if ( this->is_longexposure ) {
-      waittime = this->camera_info.exposure_time - 1;
+    uint32_t exposure_timeout_time = this->camera_info.exposure_time.ms() + 1000;  // Time to wait in msec for the exposure delay to time out
 
-    } else {
-      waittime = floor( 0.9 * this->camera_info.exposure_time / this->camera_info.exposure_factor );  // in units of this->camera_info.exposure_unit
+    // Wait for 1000 ms less than the exposure time
+    // unless the waittime works out to be less than 1000 ms then
+    // don't wait at all, just start polling.
+    //
+    uint32_t waittime=0;
+    if ( this->camera_info.exposure_time.ms() > 1000 ) {
+      waittime = this->camera_info.exposure_time.ms() - 1000;
     }
+    waittime = ( waittime < 1000 ? 0 : waittime );
 
     // Wait, (don't sleep) for the above waittime.
     // This is a period that could be aborted by setting the this->abort flag. //TODO not yet implemented?
     // All that is happening here is a wait -- there is no Archon polling going on here.
     //
-    double start_time = get_clock_time();  // get the current clock time from host (in seconds)
-    double now = start_time;
 
     // Prediction is the predicted finish_timer, used to compute exposure time progress,
     // and is computed as start_time + exposure_time in Archon ticks.
-    // Each Archon tick is 10 nsec (1e8 sec). Divide by exposure_factor (=1 for sec, =1000 for msec).
+    // Each Archon tick is 10 nsec (1e8 sec) and exposure_time.value() is in ms so multiply
+    // exposure time by MSEC_TO_TICK.
     //
-    unsigned long int prediction = this->start_timer + this->camera_info.exposure_time * 1e8 / this->camera_info.exposure_factor;
+    unsigned long int prediction = archon_start_time + this->camera_info.exposure_time.ms() * MSEC_TO_TICK;
+
+    {
+    auto tstart  = std::chrono::steady_clock::now();
+    while (true) {
+      auto tnow    = std::chrono::steady_clock::now();
+      auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(tnow - tstart).count();
+      if ( elapsed > waittime ) break;
+      std::this_thread::sleep_for( std::chrono::microseconds( 10 ));
+    }
+    }
 
+    // If the waittime is more than 1000 ms then publish exposure progress
+    //
+/*** TODO optionally broadcast progress
+    {
     std::cerr << "exposure progress: ";
-    while ((now - (waittime + start_time) < 0) && !this->abort) {
-      // sleep 10 msec = 1e6 Archon ticks
-      std::this_thread::sleep_for( std::chrono::milliseconds( 10 ));
-      increment += 1000000;
-      now = get_clock_time();
-      this->camera_info.exposure_progress = (double)increment / (double)(prediction - this->start_timer);
-      if (this->camera_info.exposure_progress < 0 || this->camera_info.exposure_progress > 1) this->camera_info.exposure_progress=1;
-      std::cerr << std::setw(3) << (int)(this->camera_info.exposure_progress*100) << "\b\b\b";
+    auto tstart  = std::chrono::steady_clock::now();
+    auto tend    = tstart + std::chrono::seconds( static_cast<uint32_t>(std::ceil( total_s )) );
+    while ( !this->abort && std::chrono::steady_clock::now() < tend ) {
+      auto elapsed = std::chrono::steady_clock::now() - tstart;
+      double elapsed_s = std::chrono::duration<double>(elapsed).count();
+      this->camera_info.exposure_progress = 100.0 * ( elapsed_s / total_s );
+      std::cerr << std::setw(3) << static_cast<int>(std::round(this->camera_info.exposure_progress)) << "\b\b\b";
 
       // ASYNC status message reports the elapsed time in the chosen unit
       //
-      message.str(""); message << "EXPOSURE:" << (int)(this->camera_info.exposure_time - (this->camera_info.exposure_progress * this->camera_info.exposure_time));
+      message.str(""); message << "EXPOSURE:" << (int)(this->camera_info.exposure_time.value() - (this->camera_info.exposure_progress * this->camera_info.exposure_time.value()));
       this->camera.async.enqueue( message.str() );
+//    auto tnow    = std::chrono::steady_clock::now();
+//    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(tnow - tstart).count();
+//    if ( elapsed > waittime ) break;
+      std::this_thread::sleep_for( std::chrono::milliseconds( 1 ));
     }
+    }
+***/
 
     if (this->abort) {
       std::cerr << "\n";
@@ -5121,24 +5167,16 @@ namespace Archon {
       return NO_ERROR;
     }
 
-    // Set the time-out value in ms. If the exposure time is less than a second, set
-    // the timeout to 1 second. Otherwise, set it to the exposure time plus
-    // 1 second.
-    //
-    if ( this->camera_info.exposure_time / this->camera_info.exposure_factor < 1 ) {
-      exposure_timeout_time = 1000; //ms
-
-    } else {
-      exposure_timeout_time = (this->camera_info.exposure_time / this->camera_info.exposure_factor) * 1000 + 1000;
-    }
-
-    // Now start polling the Archon for the last remaining portion of the exposure delay
+    // Now start polling the Archon for the last remaining portion of the exposure delay.
+    // Record the start time to compare against current time and allow timing out.
     //
     bool done = false;
+    std::chrono::steady_clock::time_point tstart = std::chrono::steady_clock::now();
     while (!done && !this->abort) {
       // Poll Archon's internal timer
       //
-      if ( (error=this->get_timer(&timer)) == ERROR ) {
+      unsigned long int archon_time_now;
+      if ( (error=this->get_timer(&archon_time_now)) == ERROR ) {
         std::cerr << "\n";
         logwrite( function, "ERROR: could not get Archon timer" );
         break;
@@ -5146,41 +5184,40 @@ namespace Archon {
 
       // update progress
       //
-      this->camera_info.exposure_progress = (double)(timer - this->start_timer) / (double)(prediction - this->start_timer);
+      this->camera_info.exposure_progress = (double)(archon_time_now - archon_start_time) / (double)(prediction - archon_start_time);
       if (this->camera_info.exposure_progress < 0 || this->camera_info.exposure_progress > 1) this->camera_info.exposure_progress=1;
 
       // ASYNC status message reports the elapsed time in the chosen unit
       //
-      message.str(""); message << "EXPOSURE:" << (int)(this->camera_info.exposure_time - (this->camera_info.exposure_progress * this->camera_info.exposure_time));
+      message.str(""); message << "EXPOSURE:" << (int)(this->camera_info.exposure_time.value() - (this->camera_info.exposure_progress * this->camera_info.exposure_time.value()));
       this->camera.async.enqueue( message.str() );
 
       std::cerr << std::setw(3) << (int)(this->camera_info.exposure_progress*100) << "\b\b\b";  // send to stderr in case anyone is watching
 
-      // Archon timer ticks are in 10 nsec (1e-8) so when comparing to exposure_time,
-      // multiply exposure_time by 1e8/exposure_factor, where exposure_factor=1 or =1000 for exposure_unit sec or msec.
+      // Archon timer ticks are in 10 nsec (1e-8) and exposure_time.value() is in msec
+      // so multiply exposure_time.value() by MSEC_TO_TICK.
       //
-      if ( (timer - this->start_timer) >= ( this->camera_info.exposure_time * 1e8 / this->camera_info.exposure_factor ) ) {
-        this->finish_timer = timer;
+      if ( (archon_time_now - archon_start_time) >= ( this->camera_info.exposure_time.ms() * MSEC_TO_TICK ) ) {
+        this->finish_timer = archon_time_now;
         done  = true;
         break;
       }
 
       // a little pause to slow down the requests to Archon
-      std::this_thread::sleep_for( std::chrono::milliseconds( 1 ));
-      // Added protection against infinite loops, probably will never be invoked
-      // because an Archon error getting the timer would exit the loop.
-      // exposure_timeout_time is in msec, and it's a little more than 1 msec to get
-      // through this loop. If this is decremented each time through then it should
-      // never hit zero before the exposure is finished, unless there is a serious
-      // problem.
+      std::this_thread::sleep_for( std::chrono::microseconds( 100 ));
+
+      // There's a limit to how long we let this polling loop last
       //
-      if (--exposure_timeout_time < 0) {
+      std::chrono::steady_clock::time_point tnow = std::chrono::steady_clock::now();
+      auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(tnow - tstart).count();
+      if ( elapsed > exposure_timeout_time ) {
         std::cerr << "\n";
         error = ERROR;
         this->camera.log_error( function, "timeout waiting for exposure" );
         break;
       }
     }  // end while (done == false && this->abort == false)
+    logwrite( function, "exposure complete" );
 
     std::cerr << "\n";
 
@@ -5190,7 +5227,7 @@ namespace Archon {
 
     return error;
   }
-  /**************** Archon::Interface::wait_for_exposure **********************/
+  /***** Archon::Interface::wait_for_exposure *********************************/
 
 
   /**************** Archon::Interface::wait_for_readout ***********************/
@@ -5208,7 +5245,6 @@ namespace Archon {
     std::stringstream message;
     long error = NO_ERROR;
     int currentframe=this->lastframe;
-    int busycount=0;
     bool done = false;
 
     message.str("");
@@ -5220,7 +5256,7 @@ namespace Archon {
     //
     double waittime;
     try {
-      waittime = this->camera.readout_time.at(0) * 1.1;        // this is in msec
+      waittime = ceil( 1.1* this->camera.readout_time[0] );
 
     } catch(std::out_of_range &) {
       message.str(""); message << "readout time for Archon not found from config file";
@@ -5236,22 +5272,9 @@ namespace Archon {
     //
     while (!done && !this->abort) {
 
-      if (this->is_longexposure) usleep( 10000 );  // reduces polling frequency
+      if ( this->camera_info.exposure_time.is_longexposure() ) std::this_thread::sleep_for( std::chrono::microseconds( 10 ) );
       error = this->get_frame_status();
 
-      // If Archon is busy then ignore it, keep trying for up to ~ 3 second
-      // (300 attempts, ~10000us between attempts)
-      //
-      if (error == BUSY) {
-        if ( ++busycount > 300 ) {
-	        done = true;
-	        this->camera.log_error( function, "received BUSY from Archon too many times trying to get frame status" );
-	        break;
-
-        } else continue;
-
-      } else busycount=0;
-
       if (error == ERROR) {
         done = true;
         logwrite( function, "ERROR: unable to get frame status" );
@@ -5455,12 +5478,14 @@ namespace Archon {
   /**************** Archon::Interface::set_parameter **************************/
 
 
-  /**************** Archon::Interface::exptime ********************************/
+  /***** Archon::Interface::exptime *******************************************/
   /**
-   * @fn     exptime
-   * @brief  set/get the exposure time
-   * @param  string
-   * @return ERROR or NO_ERROR
+   * @brief      set/get the exposure time
+   * @details    exposure time is in the units set by longexposure() or the
+   *             unit can be optionally set here
+   * @param[in]  exptime_in  "<time> [ s | ms ]" exposure time in current units
+   * @param[out] retstring   return string
+   * @return     ERROR | NO_ERROR
    *
    * This function calls "set_parameter()" and "get_parameter()" using
    * the "exptime" parameter (which must already be defined in the ACF file).
@@ -5470,52 +5495,77 @@ namespace Archon {
     std::string function = "Archon::Interface::exptime";
     std::stringstream message;
     long ret=NO_ERROR;
-    int32_t exp_time = -1;
 
     if ( !exptime_in.empty() ) {
-      // Convert to integer to check the value
-      //
+      if ( exptime_in.find(".") != std::string::npos ) {
+      this->camera.log_error( function, "must be a whole number" );
+      retstring="invalid_argument";
+      return ERROR;
+      }
+      std::vector<std::string> tokens;
+      Tokenize( exptime_in, tokens, " " );
       try {
-        exp_time = std::stoi( exptime_in );
+        uint32_t exptime=0;
+        std::string unit;
+        if ( tokens.size() > 0 ) exptime = static_cast<uint32_t>( std::stoul( tokens.at(0) ) );
+        if ( tokens.size() > 1 ) unit    = tokens.at(1);
+        if ( tokens.size() < 1 || tokens.size() > 2 ) {
+          this->camera.log_error( function, "expected <exptime> [ s | ms ]" );
+          retstring="invalid_argument";
+          return ERROR;
+        }
 
-      } catch (std::invalid_argument &) {
-        message.str(""); message << "converting exposure time: " << exptime_in << " to integer";
-        this->camera.log_error( function, message.str() );
-        return ERROR;
+        if ( exptime < 0 || exptime > Archon::MAX_EXPTIME ) throw std::out_of_range("value out of range");
 
-      } catch (std::out_of_range &) {
-        message.str(""); message << "requested exposure time: " << exptime_in << " outside integer range";
-        this->camera.log_error( function, message.str() );
-        return ERROR;
-      }
+        // If a unit was supplied then call longexposure() to handle that
+        //
+        if ( ! unit.empty() ) {
+          if ( unit=="s" )  ret = this->longexposure( "true", retstring );
+          else
+          if ( unit=="ms" ) ret = this->longexposure( "false", retstring );
+          else {
+            this->camera.log_error( function, "expected <exptime> [ s | ms ]" );
+            return ERROR;
+          }
+          // longexposure() could fail if there's an error talking to Archon
+          // or if longexposure is not supported by the ACF.
+          //
+          if ( ret != NO_ERROR ) {
+            this->camera.log_error( function, "unable to set selected unit. exptime not set." );
+            retstring="invalid_argument";
+            return ERROR;
+          }
+        }
 
-      // Archon allows only 20 bit parameters
-      //
-      if ( exp_time < 0 || exp_time > 0xFFFFF ) {
-        message.str(""); message << "requested exposure time: " << exptime_in << " out of range {0:1048575}";
+        // set the parameter on the Archon
+        //
+        std::stringstream cmd;
+        cmd << "exptime " << tokens.at(0);
+        ret = this->set_parameter( cmd.str() );
+
+        // If Archon was updated then update the class
+        //
+        if ( ret == NO_ERROR ) {
+          if ( ! unit.empty() ) this->camera_info.exposure_time.unit( unit );
+          this->camera_info.exposure_time.value( exptime );
+        }
+      }
+      catch (std::exception &e) {
+        message.str(""); message << "parsing exposure time: " << exptime_in << ": " << e.what();
         this->camera.log_error( function, message.str() );
         return ERROR;
       }
-
-      // Now that the value is OK set the parameter on the Archon
-      //
-      std::stringstream cmd;
-      cmd << "exptime " << exptime_in;
-      ret = this->set_parameter( cmd.str() );
-
-      // If parameter was set OK then save the new value
-      //
-      if ( ret==NO_ERROR ) this->camera_info.exposure_time = exp_time;
     }
 
     // add exposure time to system keys db
     //
-    message.str(""); message << "EXPTIME=" << this->camera_info.exposure_time << " // exposure time in " << ( this->is_longexposure ? "sec" : "msec" );
+    message.str(""); message << "EXPTIME=" << this->camera_info.exposure_time.value()
+                             << " // exposure time in " << this->camera_info.exposure_time.unit();
     this->systemkeys.addkey( message.str() );
 
     // prepare the return value
     //
-    message.str(""); message << this->camera_info.exposure_time << ( this->is_longexposure ? " sec" : " msec" );
+    message.str(""); message << this->camera_info.exposure_time.value() << " " << this->camera_info.exposure_time.unit();
     retstring = message.str();
 
     message.str(""); message << "exposure time is " << retstring;
@@ -5523,7 +5573,7 @@ namespace Archon {
 
     return ret;
   }
-  /**************** Archon::Interface::exptime ********************************/
+  /***** Archon::Interface::exptime *******************************************/
 
 
   /** Camera::Camera::shutter *************************************************/
@@ -6082,7 +6132,7 @@ namespace Archon {
             }
           }
 
-          if (error==NO_ERROR && this->camera_info.exposure_time != 0) {  // wait for the exposure delay to complete (if there is one)
+          if (error==NO_ERROR && this->camera_info.exposure_time.value() != 0) {  // wait for the exposure delay to complete (if there is one)
             error = this->wait_for_exposure();
           }
 
@@ -6175,57 +6225,65 @@ namespace Archon {
   /**************** Archon::Interface::copy_keydb *****************************/
 
 
-  /**************** Archon::Interface::longexposure ***************************/
+  /***** Archon::Interface::longexposure **************************************/
   /**
-   * @fn     longexposure
-   * @brief  set/get longexposure mode
-   * @param  string
-   * @return ERROR or NO_ERROR
+   * @brief      set/get longexposure mode
+   * @param[in]  string
+   * @return     ERROR | NO_ERROR
    *
    */
-  long Interface::longexposure(std::string state_in, std::string &state_out) {
+  long Interface::longexposure(std::string state_in, std::string &retstring) {
     std::string function = "Archon::Interface::longexposure";
     std::stringstream message;
     long error = NO_ERROR;
 
+    if ( this->longexposeparam.empty() ) {
+      this->camera.log_error( function, "longexposure not supported" );
+      retstring="not_supported";
+      return ERROR;
+    }
+
     // If something is passed then try to use it to set the longexposure state
     //
     if ( !state_in.empty() ) {
       try {
         std::transform( state_in.begin(), state_in.end(), state_in.begin(), ::toupper );  // make uppercase
-        if ( state_in == "FALSE" || state_in == "0" ) this->is_longexposure = false;
+        if ( state_in == "FALSE" || state_in == "0" ) this->camera_info.exposure_time.longexposure( false );
         else
-        if ( state_in == "TRUE" || state_in == "1" ) this->is_longexposure = true;
+        if ( state_in == "TRUE" || state_in == "1" ) this->camera_info.exposure_time.longexposure( true );
         else {
           message.str(""); message << "longexposure state " << state_in << " is invalid. Expecting {true,false,0,1}";
+          retstring="invalid_argument";
           this->camera.log_error( function, message.str() );
           return ERROR;
         }
+        this->is_longexposure_set = true;
 
-      } catch (...) {
-        message.str(""); message << "unknown exception converting longexposure state " << state_in << " to uppercase";
+        // Set the longexposure param and re-set the exposure time in the current unit
+        //
+        std::stringstream cmd;
+        cmd << this->longexposeparam << " " << ( this->camera_info.exposure_time.is_longexposure() ? 1 : 0 );
+        error |= this->set_parameter( cmd.str() );
+        cmd.str(""); cmd << "exptime " << this->camera_info.exposure_time.value();
+        error |= this->set_parameter( cmd.str() );
+
+      } catch ( std::exception &e ) {
+        message.str(""); message << "exception converting longexposure state: " << e.what();
         this->camera.log_error( function, message.str() );
         return ERROR;
       }
     }
 
-    // error or not, the state reported now will be whatever was last successfully set
-    //
-    this->camera_info.exposure_unit   = ( this->is_longexposure ? "sec" : "msec" );
-    this->camera_info.exposure_factor = ( this->is_longexposure ? 1 : 1000 );
-    state_out = ( this->is_longexposure ? "true" : "false" );
-
-    // if no error then set the parameter on the Archon
+    // prepare the return value
     //
-    if ( error==NO_ERROR ) {
-      std::stringstream cmd;
-      cmd << "longexposure " << ( this->is_longexposure ? 1 : 0 );
-      if ( error==NO_ERROR ) error = this->set_parameter( cmd.str() );
-    }
+    message.str(""); message << ( this->camera_info.exposure_time.is_longexposure() ? "true " : "false " )
+                             << this->camera_info.exposure_time.value() << " "
+                             << this->camera_info.exposure_time.unit();
+    retstring = message.str();
 
     return error;
   }
-  /**************** Archon::Interface::longexposure ***************************/
+  /***** Archon::Interface::longexposure **************************************/
 
 
   /**************** Archon::Interface::heater *********************************/
@@ -7939,7 +7997,7 @@ namespace Archon {
           }
         }
 
-        if (this->camera_info.exposure_time != 0) {                 // wait for the exposure delay to complete (if there is one)
+        if (this->camera_info.exposure_time.value() != 0) {         // wait for the exposure delay to complete (if there is one)
           error = this->wait_for_exposure();
           if (error==ERROR) {
             logwrite( function, "ERROR: exposure delay error" );
diff --git a/camerad/archon.h b/camerad/archon.h
index dd976902..273104a3 100644
--- a/camerad/archon.h
+++ b/camerad/archon.h
@@ -60,6 +60,8 @@
 namespace Archon {
 
     constexpr std::string_view QUIET = "quiet";  // allows sending commands without logging
+    constexpr uint32_t MSEC_TO_TICK = 100000;    // Archon clock ticks per millisecond
+    constexpr uint32_t MAX_EXPTIME  = 0xFFFFF;   // Archon parameters are limited to 20 bits
 
     // Archon hardware-based constants.
     // These shouldn't change unless there is a significant hardware change.
@@ -111,7 +113,7 @@ namespace Archon {
         std::vector<int> offset; //!< digital CDS offset (from TAPLINE definition)
         bool modeselected; //!< true if a valid mode has been selected, false otherwise
         bool firmwareloaded; //!< true if firmware is loaded, false otherwise
-        bool is_longexposure; //!< true for long exposure mode (exptime in sec), false for exptime in msec
+        bool is_longexposure_set; //!< true for long exposure mode (exptime in sec), false for exptime in msec
         bool is_window; //!< true if in window mode for h2rg, false if not
         bool is_autofetch;
         int win_hstart;
@@ -152,6 +154,7 @@ namespace Archon {
         std::mutex archon_mutex;
         //!< protects Archon from being accessed by multiple threads,
                                                     //!< use in conjunction with archon_busy flag
+        std::string longexposeparam; //!< param name to control longexposure in ACF (empty=not supported)
         std::string exposeparam; //!< param name to trigger exposure when set =1
 
         std::string shutenableparam; //!< param name to enable shutter open on expose
diff --git a/camerad/camera.h b/camerad/camera.h
index 7c48c0df..2d44d4a2 100644
--- a/camerad/camera.h
+++ b/camerad/camera.h
@@ -133,6 +133,172 @@ namespace Camera {
         "RAW"
     };
 
+
+    /***** Camera::ExposureTime ***********************************************/
+    /**
+     * @class  ExposureTime
+     * @brief  creates object that encapsulates exposure time with its unit
+     *
+     * This class allows setting and getting an exposure time together with
+     * its unit. The default unit and value is msec and 0. Internally, the
+     * class stores the exposure time as an unsigned 32 bit value in the
+     * units of _unit but a specific unit can be requested with .s() and .ms()
+     * functions. Standard operators + - * / > < >= <= == are overloaded here
+     * to operate on scalars only.
+     *
+     */
+    class ExposureTime {
+      private:
+        uint32_t    _value;            // exposure time in the current units
+        bool        _is_set;           // has it been set using the class value() function?
+        std::string _unit;             // "s" for seconds, "ms" for milliseconds
+        bool        _is_longexposure;  // true for s, false for ms
+
+      public:
+        /**
+         * @brief      class constructor optionally sets exposure time and unit
+         * @param[in]  time  exposure time, defaults to 0 if not provided
+         * @param[in]  u     unit, "s" or "ms", defaults to ms if not provided
+         *
+         * Since this is a generic class, there is no range check on the
+         * exposure time value; that must be done by whatever instantiates
+         * an ExposureTime object.
+         *
+         */
+        explicit ExposureTime( uint32_t time=0, const std::string &u="ms" )
+                   : _value(0), _is_set(false), _unit(u), _is_longexposure(u=="s") {
+          if ( u != "ms" && u != "s" ) throw std::invalid_argument("invalid unit, expected \"s\" or \"ms\"");
+          this->value(time);
+        }
+
+        /**
+         * @brief      set the unit
+         * @details    this will modify the value as necessary
+         * @param[in]  u  "ms" or "s" for milliseconds or seconds
+         */
+        void unit( const std::string &newunit ) {
+          if ( newunit == "s" || newunit == "ms" ) {
+            if ( _unit != newunit ) {
+              _value = ( newunit == "ms" ? _value*1000 : _value/1000 );
+              _unit = newunit;
+              _is_longexposure = ( newunit == "s" );
+            }
+          }
+          else throw std::invalid_argument("invalid unit, expected \"s\" or \"ms\"");
+        }
+
+        /**
+         * @brief      return the current unit
+         * @return     "s" | "ms"
+         */
+        std::string unit() const { return _unit; }
+
+        /**
+         * @brief      set the longexposure state
+         * @details    uses the class unit() function to both set the unit
+         *             and modify the value as necessary.
+         * @param[in]  true | false
+         */
+        void longexposure( bool state ) { this->unit( state ? "s" : "ms" ); }
+
+        /**
+         * @brief      return the longexposure state
+         * @return     true | false
+         */
+	bool is_longexposure() const { return _is_longexposure; }
+
+        /**
+         * @brief      return the exposure time in units of milliseconds
+         * @return     exposure time
+         */
+        uint32_t ms() const {
+          return ( _unit == "ms" ? _value : _value * 1000 );
+        }
+
+        /**
+         * @brief      return the exposure time in units of seconds
+         * @return     exposure time
+         */
+        uint32_t s() const {
+          return ( _unit == "s" ? _value : _value / 1000 );
+        }
+
+        /**
+         * @brief      return the exposure time in the current units
+         * @return     exposure time
+         */
+        uint32_t value() const {
+          return _value;
+        }
+
+        /**
+         * @brief      set the exposure time
+         * @details    There is no range check on the value; that must be done
+         *             by whatever instantiates an ExposureTime object.
+         * @param[in]  time  exposure time in the current unit
+         */
+        void value( uint32_t time ) {
+          _value = time;
+          _is_set = true;
+        }
+
+        /**
+         * @brief      return _is_set flag
+         * @details    allows checking if a user has explicitly set the exposure time.
+         * @return     true | false
+         */
+	bool is_set() const { return _is_set; }
+
+        /**
+         * @brief      overload operators to perform in the correct units
+         * @details    Use .s() or .ms() to operate on seconds or milliseconds.
+         *             These only work on scalars (not other ExposureTime objects).
+         *
+         * E.G. .ms() +/- 1000 will add/subtract 1000 msec to/from the current value
+         *       .s() +/- 1    will add/subtract 1 sec to/from the current value
+         *       .s() == xxx   will compare value in seconds to xxx
+         */
+        ExposureTime operator+( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() );
+          return ExposureTime( val + scalar, _unit );
+        }
+        ExposureTime operator-( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() );
+          return ExposureTime( val - scalar, _unit );
+        }
+        ExposureTime operator*( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return ExposureTime( val * scalar );
+        }
+        ExposureTime operator/( uint32_t scalar ) const {
+          if ( scalar == 0 ) throw std::invalid_argument("division by zero");
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return ExposureTime( val / scalar );
+        }
+        bool operator<( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return val < scalar;
+        }
+        bool operator>( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return val > scalar;
+        }
+        bool operator==( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return val == scalar;
+        }
+        bool operator<=( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return val <= scalar;
+        }
+        bool operator>=( uint32_t scalar ) const {
+          uint32_t val = ( _unit == "ms" ? ms() : s() * 1000 );
+          return val >= scalar;
+        }
+    };
+    /***** Camera::ExposureTime ***********************************************/
+
+
     /**************** Camera::Information ***************************************/
     //
     class Information {
@@ -162,9 +328,6 @@ namespace Camera {
         int extension; //!< extension number for data cubes
         bool shutterenable; //!< set true to allow the controller to open the shutter on expose, false to disable it
         std::string shutteractivate; //!< shutter activation state
-        int32_t exposure_time; //!< exposure time in exposure_unit
-        std::string exposure_unit; //!< exposure time unit
-        int exposure_factor; //!< multiplier for exposure_unit relative to 1 sec (=1 for sec, =1000 for msec, etc.)
         double exposure_progress; //!< exposure progress (fraction)
         int num_pre_exposures; //!< pre-exposures are exposures taken but not saved
         std::string fits_name; //!< contatenation of Camera's image_dir + image_name + image_num
@@ -172,6 +335,8 @@ namespace Camera {
 
         std::vector<std::vector<long> > amp_section;
 
+        ExposureTime exposure_time;
+
         Common::FitsKeys userkeys; /// create a FitsKeys object for FITS keys specified by the user
         Common::FitsKeys systemkeys; /// create a FitsKeys object for FITS keys imposed by the software
 
@@ -190,9 +355,6 @@ namespace Camera {
             this->iscube = false;
             this->datatype = -1;
             this->type_set = false; //!< set true when datatype has been defined
-            this->exposure_time = -1; //!< default exposure time is undefined
-            this->exposure_unit = ""; //!< default exposure unit is undefined
-            this->exposure_factor = -1; //!< default factor is undefined
             this->shutteractivate = "";
             this->num_pre_exposures = 0; //!< default is no pre-exposures
         }
diff --git a/camerad/camerad.cpp b/camerad/camerad.cpp
index 266a27c3..720e9cfe 100644
--- a/camerad/camerad.cpp
+++ b/camerad/camerad.cpp
@@ -761,22 +761,17 @@ void doit(Network::TcpSocket sock) {
 #endif
         else if (cmd == "expose") {
             ret = server.expose(args);
-        } else if (cmd == "exptime") {
-            // Neither controller allows fractional exposure times
-            // so catch that here.
-            //
-            if (args.find(".") != std::string::npos) {
-                ret = ERROR;
-                logwrite(function, "ERROR: fractional exposure times not allowed");
-                // empty the args string so that a call to exptime returns the current exptime
-                //
-                args = "";
-                server.exptime(args, retstring);
-            } else { ret = server.exptime(args, retstring); }
+        }
+        else if (cmd == "exptime") {
+            ret = server.exptime(args, retstring);
             if (!retstring.empty()) {
                 sock.Write(retstring);
                 sock.Write(" ");
             }
+        }
+        else if (!retstring.empty()) {
+                sock.Write(retstring);
+                sock.Write(" ");
         } else if (cmd == "bias") {
             ret = server.bias(args, retstring);
             if (!retstring.empty()) {