LiquidLens#

#include <stdio.h>
#include <stdlib.h>
#include "ItalaApiC/ItalaC.h"

#define STRING_LENGTH 255

ItalaError ErrorManager(ItalaError e) {
  size_t sizeMessage = 255;
  char* message = (char*)malloc(sizeof(char) * sizeMessage);
  ERR_GetLastErrorMessage(message, &sizeMessage);
  printf("\nITALA ERROR (%d):\t%s, %zu char", ERR_GetLastErrorCode(), message, sizeMessage);
  free(message);
  return e;
}

int main(int argc, char** argv) {
  printf("***** LiquidLens example started. *****\n");
  ItalaError error = ItalaErrorSuccess;

  error = SYS_Initialize();
  if (error) return ErrorManager(error);

  size_t devicesInfoSize = 0;
  error = SYS_EnumerateDevices(700);
  if (error) return ErrorManager(error);
  error = SYS_GetDeviceCount(&devicesInfoSize);
  if (error) return ErrorManager(error);
  if (devicesInfoSize == 0) {
    printf("No devices found. Example canceled.\n");
    return ItalaErrorError;
  }
  DeviceInfo deviceInfo;
  error = SYS_GetDeviceByIndex(0, &deviceInfo);
  if (error) return ErrorManager(error);
  if (deviceInfo.AccessStatus != AvailableReadWrite) {
    printf("Target device is unaccessible in RW mode. Example canceled.\n");
    return ItalaErrorError;
  }

  H_DEVICE hDevice = NULL;
  error = SYS_CreateDevice(deviceInfo, &hDevice);
  if (error) return ErrorManager(error);
  printf("First device found is initialized.\n\n");

  H_NODEMAP hNodeMap = NULL;
  error = DEV_GetNodeMap(hDevice, &hNodeMap);
  if (error) return ErrorManager(error);

  // Enable the liquid lens functionality. Keep the original activation state and restore
  // it at the end of the program.
  H_NODE hNodeOeLiquidLensEnable = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensEnable", &hNodeOeLiquidLensEnable);
  if (error) return ErrorManager(error);
  bool isWritable = false;
  error = IsNodeWritable(hNodeOeLiquidLensEnable, &isWritable);
  if (error) return ErrorManager(error);
  if (!isWritable) {
    printf("Unable to activate liquid lens functionality. Aborting.\n");
    return ItalaErrorError;
  }
  bool originalOeLiquidLensEnable = false;
  error = NODE_BooleanGetValue(hNodeOeLiquidLensEnable, &originalOeLiquidLensEnable);
  if (error) ErrorManager(error);
  error = NODE_BooleanSetValue(hNodeOeLiquidLensEnable, true);
  if (error) return ErrorManager(true);

  printf("Liquid lens functionality enabled.\n");

  // Gather some information about the connected liquid lens.
  H_NODE hNodeOeLiquidLensTemperature = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensTemperature", &hNodeOeLiquidLensTemperature);
  if (error) return ErrorManager(error);
  bool isReadable = false;
  error = IsNodeReadable(hNodeOeLiquidLensTemperature, &isReadable);
  if (error) return ErrorManager(error);
  if (!isReadable) {
    printf("Unable to read liquid lens temperature. Aborting.\n");
    return ItalaErrorError;
  }
  double temperature = 0;
  error = NODE_FloatGetValue(hNodeOeLiquidLensTemperature, &temperature);
  if (error) return ErrorManager(error);

  H_NODE hNodeOeLiquidLensSerialNumber = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensSerialNumber", &hNodeOeLiquidLensSerialNumber);
  if (error) return ErrorManager(error);
  isReadable = false;
  error = IsNodeReadable(hNodeOeLiquidLensSerialNumber, &isReadable);
  if (error) return ErrorManager(error);
  if (!isReadable) {
    printf("Unable to read liquid lens serial number. Aborting.\n");
    return ItalaErrorError;
  }
  size_t stringSerialNumberSize = STRING_LENGTH;
  char stringSerialNumber[STRING_LENGTH];
  error = NODE_StringGetValue(hNodeOeLiquidLensSerialNumber, stringSerialNumber,
                              &stringSerialNumberSize);
  if (error) return ErrorManager(error);
  printf("Connected lens is %s\n", stringSerialNumber);
  printf("Lens temperature: %fC\370\n", temperature);

  // Liquid lenses can be controlled in current or power mode. In the first case, the
  // input given to the lens is an amount of current which results in certain
  // optical power. The second case is the opposite: by specifing the optical power
  // as input, the liquid lens absorbs a certain amount of current.
  // Let's start with current mode.
  H_NODE hNodeOeLiquidLensMode = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensMode", &hNodeOeLiquidLensMode);
  if (error) return ErrorManager(error);
  isWritable = false;
  error = IsNodeWritable(hNodeOeLiquidLensMode, &isWritable);
  if (error) return ErrorManager(error);
  if (!isWritable) {
    printf("Unable to configure the liquid lens mode. Aborting.\n");
    return ItalaErrorError;
  }
  error = NODE_FromString(hNodeOeLiquidLensMode, "CurrentMode");
  printf("\tCurrent mode enabled.\n");

  // Define the amount of current to be set in mA.
  double lensCurrent = 10.0;

  // Write it to the node.
  H_NODE hNodeOeLiquidLensCurrent = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensCurrent", &hNodeOeLiquidLensCurrent);
  if (error) return ErrorManager(error);
  isWritable = false;
  error = IsNodeWritable(hNodeOeLiquidLensCurrent, &isWritable);
  if (error) return ErrorManager(error);
  if (!isWritable) {
    printf("Unable to configure the amount of current of the lens. Aborting.\n");
    return ItalaErrorError;
  }
  error = NODE_FloatSetValue(hNodeOeLiquidLensCurrent, lensCurrent);
  if (error) return ErrorManager(error);

  // Read the amount of optical power resulting from the electrical current set.
  H_NODE hNodeOeLiquidLensResultingPower = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensResultingPower", &hNodeOeLiquidLensResultingPower);
  if (error) return ErrorManager(error);
  isReadable = false;
  error = IsNodeReadable(hNodeOeLiquidLensResultingPower, &isReadable);
  if (error) return ErrorManager(error);
  if (!isReadable) {
    printf("Unable to read the resulting amount of power from the lens. Aborting.\n");
    return ItalaErrorError;
  }
  double resultingLensPower = 0;
  error = NODE_FloatGetValue(hNodeOeLiquidLensResultingPower, &resultingLensPower);
  if (error) return ErrorManager(error);

  printf("\tLens current set to %f mA.\n", lensCurrent);
  printf("\tResulting lens power is %f dpt.\n", resultingLensPower);

  // Switch to power mode.
  error = NODE_FromString(hNodeOeLiquidLensMode, "PowerMode");
  if (error) return ErrorManager(error);
  printf("\tPower mode enabled.\n");

  // Define the lens power to be set in dpt.
  double lensPower = 2.0;

  // Write it to the node.
  H_NODE hNodeOeLiquidLensPower = NULL;
  error = NODEMAP_GetNode(hNodeMap, "oeLiquidLensPower", &hNodeOeLiquidLensPower);
  if (error) return ErrorManager(error);
  isWritable = false;
  error = IsNodeWritable(hNodeOeLiquidLensPower, &isWritable);
  if (error) return ErrorManager(error);
  if (!isWritable) {
    printf("Unable to configure the amount of power of the lens. Aborting.\n");
    return ItalaErrorError;
  }
  error = NODE_FloatSetValue(hNodeOeLiquidLensPower, lensPower);
  if (error) return ErrorManager(error);

  // Read the amount of current resulting from the optical power set.
  H_NODE hNodeOeLiquidLensResultingCurrent = NULL;
  error =
      NODEMAP_GetNode(hNodeMap, "oeLiquidLensResultingCurrent", &hNodeOeLiquidLensResultingCurrent);
  if (error) return ErrorManager(error);
  isReadable = false;
  error = IsNodeReadable(hNodeOeLiquidLensResultingCurrent, &isReadable);
  if (error) return ErrorManager(error);
  if (!isReadable) {
    printf("Unable to read the resulting amount of current from the lens. Aborting.\n");
    return ItalaErrorError;
  }
  double resultingLensCurrent = 0;
  error = NODE_FloatGetValue(hNodeOeLiquidLensResultingCurrent, &resultingLensCurrent);
  if (error) return ErrorManager(error);

  printf("\tLens set to %f dpt.\n", lensPower);
  printf("\tResulting lens current is %f mA.\n\n", resultingLensCurrent);

  // Restore the original lens activation state.
  error = NODE_BooleanSetValue(hNodeOeLiquidLensEnable, originalOeLiquidLensEnable);
  if (error) return ErrorManager(error);

  error = DEV_Dispose(hDevice);
  hDevice = NULL;
  if (error) return ErrorManager(error);
  printf("Device instance disposed.\n");

  error = SYS_Dispose();
  if (error) return ErrorManager(error);
  printf("System instance disposed.\n");
  return 0;
}