Manual Experiments

Here, we will cover how to operate a Squidstat in Manual Mode. The Squistat API provides a set of manual mode commands as functions, which allow the user to control the squidstat while an experiment is running. Which can be useful for for scenarios where the user needs to change parameters on the fly (i.e. in a GUI application). See the manual experiments tab in the Squidstat User Interface software for an example use case of this feature.

Manual Mode Commands

The following commands are provided by the AisInstrumentHandler to control the Squidstat.

AisErrorCode AisInstrumentHandler::setManualModeSamplingInterval(uint8_t channel, double value) const;
 
AisErrorCode AisInstrumentHandler::setManualModeOCP(uint8_t channel) const;
 
AisErrorCode AisInstrumentHandler::setManualModeConstantVoltage(uint8_t channel, double value) const;
 
AisErrorCode AisInstrumentHandler::setManualModeCurrentRange(uint8_t channel, int currentRangeIndex) const;
 
AisErrorCode AisInstrumentHandler::setManualModeCurrentAutorange(uint8_t channel) const;
 
AisErrorCode AisInstrumentHandler::setManualModeVoltageRange(uint8_t channel, int voltageRangeIndex) const;
 
AisErrorCode AisInstrumentHandler::setManualModeVoltageAutorange(uint8_t channel) const;
 
AisErrorCode AisInstrumentHandler::setManualModeConstantCurrent(uint8_t channel, double value) const;

Start the Experiment

Before calling any of the above commands, the manual experiment must be started.

• C++

          //The default starting mode is always Open Circuit Potential
          qDebug() << "Starting manual mode at open circuit potential";
          AisErrorCode error = handler.startManualExperiment(CHANNEL);
          if (error != AisErrorCode::Success) {
              qDebug() << error.message();
              QCoreApplication::quit();
          }

• Python

   
      # The default starting mode is always Open Circut Potential.
   
      print("Starting manual mode at open circuit potential")
      error = handler.startManualExperiment(CHANNEL)
      if error.value() != AisErrorCode.Success:
          print(error.message())
          app.quit()

Now our experiment will run indefinitely, until AisInstrumentHandler::stopExperiment is called.

Manual Modes

The three main operational modes are OCP (Open Circuit Potential), Potentiostatic, and Galvanostatic, defined below:

• OCP: Measures the open circuit potential of the system.
• Potentiostatic: Maintains a constant potential while measuring current.
• Galvanostatic: Maintains a constant current while measuring potential.

Here is an example of how to set each at timed intervals after an experiment has started.

• C++

          // In this section we connect singleshot QTimers to lambda functions that call our mode changing functions.
          // These lambdas are called asynchronously when the QTimers expire.
   
          // 5 seconds after starting experiment, change to Constant Current at .1A
          QTimer::singleShot(5000, [=, &handler]() {
              qDebug() << "Switching to constant current at .1A";
              AisErrorCode error = handler.setManualModeConstantCurrent(CHANNEL, .1);
              if (error != AisErrorCode::Success) {
                  qDebug() << error.message();
              }
          });
   
          // 15 seconds after starting experiment, change to Constant Voltage at 1V
          QTimer::singleShot(15000, [=, &handler]() {
              qDebug() << "Switching to constant voltage at 1V";
              AisErrorCode error = handler.setManualModeConstantVoltage(CHANNEL, 1);
              if (error != AisErrorCode::Success) {
                  qDebug() << error.message();
              }
          });
   
          // 25 seconds after starting experiment, change back into Open Circuit Potential mode.
          QTimer::singleShot(25000, [=, &handler]() {
              qDebug() << "Switching to open circuit potential";
              AisErrorCode error = handler.setManualModeOCP(CHANNEL);
              if (error != AisErrorCode::Success) {
                  qDebug() << error.message();
              }
          });

• Python

   
      # In this section we create wrapper functions for the manual mode changing functions.
      # These wrappers are called asynchronously when singleshot QTimers expire.
   
      # This function changes the instrument to Constant Current at .1A
      def setConstantCurrent(channel):
          print("Switching to constant current at .1A")
          error = handler.setManualModeConstantCurrent(channel, .1)
          if error.value() != AisErrorCode.Success:
              print(error.message())
      # It is called 5 seconds after the experiment starts
      QTimer.singleShot(5000, lambda:setConstantCurrent(CHANNEL))
   
      # This function changes the instrument to Constant Voltage at 1V
      def setConstantVoltage(channel):
          print("Switching to constant voltage at 1V")
          error = handler.setManualModeConstantVoltage(channel, 1)
          if error.value() != AisErrorCode.Success:
              print(error.message())
      # It is called 15 seconds after the experiment starts
      QTimer.singleShot(15000, lambda:setConstantVoltage(CHANNEL))
   
      # This function changes the instrument to Open Circuit Potential
      def setOpenCircuit(channel):
          print("Switching to open circuit potential")
          error = handler.setManualModeOCP(channel)
          if error.value() != AisErrorCode.Success:
              print(error.message())
      # It is called 25 seconds after the experiment starts
      QTimer.singleShot(25000, lambda:setOpenCircuit(CHANNEL))
   

Note: As a reminder, it is always a good idea to check the error code returned by each command to ensure successful execution. See AisErrorCode for more information.

Stop the Experiment

Stopping the manual experiment uses the same command as stopping a normal experiment (AisInstrumentHandler::stopExperiment). In this case, we use a SingleShot timer (C++ | Python) to stop the experiment after 30 seconds.

• C++

          // Stop the experiment after 30 seconds
          QTimer::singleShot(30000, [=, &handler]() {
              qDebug() << "Stopping experiment";
              if (handler.stopExperiment(CHANNEL) != AisErrorCode::Success) {
                  qDebug() << error.message();
              }
          });

• Python

   
      # Stop experiment after 30 seconds
      def stopExperiment(channel):
          print("Stopping experiment.")
          error = handler.stopExperiment(channel)
          if error.value() != AisErrorCode.Success:
              print(error.message())
      QTimer.singleShot(30000, lambda:stopExperiment(CHANNEL))
   

See the full example here

Previous	Next
Advanced Experiment Logic	Extra Examples