#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;
}