7 #ifndef AS_CORE_LIBRARY 9 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
12 case DLL_PROCESS_ATTACH:
16 case DLL_PROCESS_DETACH:
35 DeviceContext_t *deviceContext = NULL;
37 if (!deviceContextPtr) {
41 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
43 hid_close(deviceContext->handle);
44 free(deviceContext->serial);
47 *deviceContextPtr = 0;
55 wchar_t *serialWChar = NULL;
56 int cLen = serialNumber? strlen(serialNumber) : 0;
58 DeviceContext_t *deviceContext = NULL;
60 if (!deviceContextPtr) {
61 return NO_DEVICE_CONTEXT_ERROR;
64 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
67 deviceContext = malloc(
sizeof(DeviceContext_t));
68 *deviceContext = NULL_DEVICE_CONTEXT;
72 serialWChar = calloc(
sizeof(
wchar_t) * cLen,
sizeof(
wchar_t));
73 mbstowcs(serialWChar, serialNumber, cLen);
76 if (deviceContext->handle) {
77 hid_close(deviceContext->handle);
78 deviceContext->handle = NULL;
81 deviceContext->handle = hid_open(USBD_VID, USBD_PID, (
const wchar_t *)serialWChar);
82 if (deviceContext->handle == NULL) {
84 return CONNECT_ERROR_FAILED;
88 if (serialNumber != deviceContext->serial) {
89 free(deviceContext->serial);
90 deviceContext->serial = calloc(
sizeof(
char) * cLen,
sizeof(
char));
91 strcpy(deviceContext->serial, serialNumber);
102 int cBytesCount = 0, wcLen = 0;
104 struct hid_device_info *devices = hid_enumerate(USBD_VID, USBD_PID),
105 *deviceIterator = devices;
107 wchar_t *serialWChar = NULL;
109 DeviceContext_t *deviceContext = NULL;
111 if (!deviceContextPtr) {
112 return NO_DEVICE_CONTEXT_ERROR;
115 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
117 *deviceContextPtr = 0;
119 deviceContext = malloc(
sizeof(DeviceContext_t));
120 *deviceContext = NULL_DEVICE_CONTEXT;
122 while (deviceIterator) {
125 if (index == count - 1) {
126 serialWChar = deviceIterator->serial_number;
129 deviceIterator = deviceIterator->next;
134 hid_free_enumeration(devices);
135 return CONNECT_ERROR_NOT_FOUND;
138 if (deviceContext->handle) {
139 hid_close(deviceContext->handle);
140 deviceContext->handle = NULL;
142 deviceContext->handle = hid_open(USBD_VID, USBD_PID, (
const wchar_t *)serialWChar);
144 if (deviceContext->handle == NULL) {
145 hid_free_enumeration(devices);
146 return CONNECT_ERROR_FAILED;
149 wcLen = wcslen(serialWChar);
150 cBytesCount = wcstombs(NULL, serialWChar, wcLen);
152 free(deviceContext->serial);
153 deviceContext->serial = calloc(cBytesCount + 1,
sizeof(
char));
154 wcstombs(deviceContext->serial, serialWChar, wcLen);
156 hid_free_enumeration(devices);
158 *deviceContextPtr = (uintptr_t)deviceContext;
166 struct hid_device_info *devices = hid_enumerate(USBD_VID, USBD_PID),
169 while (device != NULL) {
171 device = device->next;
174 hid_free_enumeration(devices);
184 int cBytesCount = 0, wcLen = 0;
186 struct hid_device_info *devices = hid_enumerate(USBD_VID, USBD_PID),
189 wchar_t *serialWChar = NULL;
194 serialWChar = device->serial_number;
195 wcLen = wcslen(serialWChar);
196 cBytesCount = wcstombs(NULL, serialWChar, wcLen);
198 current->serialNumber = calloc(cBytesCount + 1,
sizeof(
char));
199 wcstombs(current->serialNumber, serialWChar, wcLen);
200 current->next = NULL;
202 if (resultList == NULL) {
203 resultList = current;
206 if (parent != NULL) {
207 parent->next = current;
211 device = device->next;
214 hid_free_enumeration(devices);
220 _recursiveClearing(devices);
224 int setFrameFormat(uint16_t numOfStartElement, uint16_t numOfEndElement, uint8_t reductionMode, uint16_t *numOfPixelsInFrame, uintptr_t* deviceContextPtr)
226 unsigned char report[EXTENDED_PACKET_SIZE];
229 DeviceContext_t *deviceContext = NULL;
231 result = _verifyDeviceContextByPtr(deviceContextPtr);
235 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
237 report[0] = ZERO_REPORT_ID;
238 report[1] = SET_FRAME_FORMAT_REQUEST;
239 report[2] = LOW_BYTE(numOfStartElement);
240 report[3] = HIGH_BYTE(numOfStartElement);
241 report[4] = LOW_BYTE(numOfEndElement);
242 report[5] = HIGH_BYTE(numOfEndElement);
243 report[6] = reductionMode;
245 result = _writeReadFunction(report, CORRECT_SET_FRAME_FORMAT_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
250 errorCode = report[1];
252 deviceContext->numOfPixelsInFrame = (report[3] << 8) | report[2];
254 if (numOfPixelsInFrame) {
255 *numOfPixelsInFrame = deviceContext->numOfPixelsInFrame;
262 int setExposure(uint32_t timeOfExposure, uint8_t force, uintptr_t* deviceContextPtr)
264 unsigned char report[EXTENDED_PACKET_SIZE];
268 result = _verifyDeviceContextByPtr(deviceContextPtr);
272 report[0] = ZERO_REPORT_ID;
273 report[1] = SET_EXPOSURE_REQUEST;
274 report[2] = LOW_BYTE(LOW_WORD(timeOfExposure));
275 report[3] = HIGH_BYTE(LOW_WORD(timeOfExposure));
276 report[4] = LOW_BYTE(HIGH_WORD(timeOfExposure));
277 report[5] = HIGH_BYTE(HIGH_WORD(timeOfExposure));
280 result = _writeReadFunction(report, CORRECT_SET_EXPOSURE_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
285 errorCode = report[1];
289 int setAcquisitionParameters(uint16_t numOfScans, uint16_t numOfBlankScans, uint8_t scanMode, uint32_t timeOfExposure, uintptr_t* deviceContextPtr)
291 uint8_t report[EXTENDED_PACKET_SIZE];
295 result = _verifyDeviceContextByPtr(deviceContextPtr);
299 report[0] = ZERO_REPORT_ID;
300 report[1] = SET_ACQUISITION_PARAMETERS_REQUEST;
301 report[2] = LOW_BYTE(numOfScans);
302 report[3] = HIGH_BYTE(numOfScans);
303 report[4] = LOW_BYTE(numOfBlankScans);
304 report[5] = HIGH_BYTE(numOfBlankScans);
305 report[6] = scanMode;
306 report[7] = LOW_BYTE(LOW_WORD(timeOfExposure));
307 report[8] = HIGH_BYTE(LOW_WORD(timeOfExposure));
308 report[9] = LOW_BYTE(HIGH_WORD(timeOfExposure));
309 report[10] = HIGH_BYTE(HIGH_WORD(timeOfExposure));
311 result = _writeReadFunction(report, CORRECT_SET_ACQUISITION_PARAMETERS_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
316 errorCode = report[1];
320 int setMultipleParameters(uint16_t numOfScans, uint16_t numOfBlankScans, uint8_t scanMode, uint32_t timeOfExposure, uint8_t enableMode, uint8_t signalFrontMode, uintptr_t* deviceContextPtr)
322 unsigned char report[EXTENDED_PACKET_SIZE];
326 result = _verifyDeviceContextByPtr(deviceContextPtr);
330 report[0] = ZERO_REPORT_ID;
331 report[1] = SET_ALL_PARAMETERS_REQUEST;
332 report[2] = LOW_BYTE(numOfScans);
333 report[3] = HIGH_BYTE(numOfScans);
334 report[4] = LOW_BYTE(numOfBlankScans);
335 report[5] = HIGH_BYTE(numOfBlankScans);
336 report[6] = scanMode;
337 report[7] = LOW_BYTE(LOW_WORD(timeOfExposure));
338 report[8] = HIGH_BYTE(LOW_WORD(timeOfExposure));
339 report[9] = LOW_BYTE(HIGH_WORD(timeOfExposure));
340 report[10] = HIGH_BYTE(HIGH_WORD(timeOfExposure));
341 report[11] = enableMode;
342 report[12] = signalFrontMode;
344 result = _writeReadFunction(report, CORRECT_GET_ACQUISITION_PARAMETERS_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
349 errorCode = report[1];
355 unsigned char report[EXTENDED_PACKET_SIZE];
359 result = _verifyDeviceContextByPtr(deviceContextPtr);
363 report[0] = ZERO_REPORT_ID;
364 report[1] = SET_EXTERNAL_TRIGGER_REQUEST;
365 report[2] = enableMode;
366 report[3] = signalFrontMode;
368 result = _writeReadFunction(report, CORRECT_SET_EXTERNAL_TRIGGER_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
373 errorCode = report[1];
377 int setOpticalTrigger(uint8_t enableMode, uint16_t pixel, uint16_t threshold, uintptr_t* deviceContextPtr)
379 uint8_t report[EXTENDED_PACKET_SIZE];
383 result = _verifyDeviceContextByPtr(deviceContextPtr);
387 report[0] = ZERO_REPORT_ID;
388 report[1] = SET_OPTICAl_TRIGGER_REQUEST;
389 report[2] = enableMode;
390 report[3] = LOW_BYTE(pixel);
391 report[4] = HIGH_BYTE(pixel);
392 report[5] = LOW_BYTE(threshold);
393 report[6] = HIGH_BYTE(threshold);
395 result = _writeReadFunction(report, CORRECT_SET_OPTICAL_TRIGGER_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
400 errorCode = report[1];
406 unsigned char report[EXTENDED_PACKET_SIZE];
409 result = _verifyDeviceContextByPtr(deviceContextPtr);
413 report[0] = ZERO_REPORT_ID;
414 report[1] = SET_SOFTWARE_TRIGGER_REQUEST;
416 result = _writeOnlyFunction(report, deviceContextPtr);
420 int getStatus(uint8_t *statusFlags, uint16_t *framesInMemory, uintptr_t* deviceContextPtr)
422 unsigned char report[EXTENDED_PACKET_SIZE];
425 result = _verifyDeviceContextByPtr(deviceContextPtr);
429 report[0] = ZERO_REPORT_ID;
430 report[1] = STATUS_REQUEST;
432 result = _writeReadFunction(report, CORRECT_STATUS_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
438 *statusFlags = report[1];
441 if (framesInMemory) {
442 *framesInMemory = (report[3] << 8) | (report[2]);
448 int getAcquisitionParameters(uint16_t* numOfScans, uint16_t* numOfBlankScans, uint8_t *scanMode, uint32_t* timeOfExposure, uintptr_t* deviceContextPtr)
450 uint8_t report[EXTENDED_PACKET_SIZE];
453 result = _verifyDeviceContextByPtr(deviceContextPtr);
457 report[0] = ZERO_REPORT_ID;
458 report[1] = GET_ACQUISITION_PARAMETERS_REQUEST;
460 result = _writeReadFunction(report, CORRECT_GET_ACQUISITION_PARAMETERS_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
466 *numOfScans = (report[2] << 8) | report[1];
469 if (numOfBlankScans) {
470 *numOfBlankScans = (report[4] << 8) | report[3];
474 *scanMode = report[5];
477 if (timeOfExposure) {
478 *timeOfExposure = (report[9] << 24) | (report[8] << 16) | (report[7] << 8) | report[6];
484 int getFrameFormat(uint16_t *numOfStartElement, uint16_t *numOfEndElement, uint8_t *reductionMode, uint16_t *numOfPixelsInFrame, uintptr_t* deviceContextPtr)
486 unsigned char report[EXTENDED_PACKET_SIZE];
488 DeviceContext_t *deviceContext = NULL;
490 result = _verifyDeviceContextByPtr(deviceContextPtr);
494 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
496 report[0] = ZERO_REPORT_ID;
497 report[1] = GET_FRAME_FORMAT_REQUEST;
499 result = _writeReadFunction(report, CORRECT_GET_FRAME_FORMAT_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
504 if (numOfStartElement) {
505 *numOfStartElement = (report[2] << 8) | report[1];
508 if (numOfEndElement) {
509 *numOfEndElement = (report[4] << 8) | report[3];
513 *reductionMode = report[5];
516 deviceContext->numOfPixelsInFrame = (report[7] << 8) | report[6];
518 if (numOfPixelsInFrame) {
519 *numOfPixelsInFrame = deviceContext->numOfPixelsInFrame;
525 int getFrame(uint16_t *framePixelsBuffer, uint16_t numOfFrame, uintptr_t* deviceContextPtr)
527 uint8_t report[EXTENDED_PACKET_SIZE];
531 uint16_t pixelOffset = 0;
532 uint8_t numOfPacketsToGet = 0, numOfPacketsLeft = 0, numOfPacketsReceived = 0;
534 bool continueGetInReport =
true;
535 uint16_t totalNumOfReceivedPixels = 0;
537 uint8_t indexOfPixelInPacket = 0;
538 int indexInPacket = 0;
540 DeviceContext_t *deviceContext = NULL;
542 result = _verifyDeviceContextByPtr(deviceContextPtr);
546 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
548 if (!deviceContext->handle) {
549 result = _reconnect(deviceContextPtr);
555 if (!framePixelsBuffer) {
556 return INPUT_PARAMETER_NOT_INITIALIZED;
559 if (!deviceContext->numOfPixelsInFrame) {
560 result =
getFrameFormat(NULL, NULL, NULL, NULL, deviceContextPtr);
565 numOfPacketsToGet = (deviceContext->numOfPixelsInFrame) / NUM_OF_PIXELS_IN_PACKET;
566 numOfPacketsToGet += (deviceContext->numOfPixelsInFrame % NUM_OF_PIXELS_IN_PACKET)? 1 : 0;
568 if (numOfPacketsToGet > MAX_PACKETS_IN_FRAME) {
569 return NUM_OF_PACKETS_IN_FRAME_ERROR;
572 report[0] = ZERO_REPORT_ID;
573 report[1] = GET_FRAME_REQUEST;
574 report[2] = LOW_BYTE(pixelOffset);
575 report[3] = HIGH_BYTE(pixelOffset);
576 report[4] = LOW_BYTE(numOfFrame);
577 report[5] = HIGH_BYTE(numOfFrame);
578 report[6] = numOfPacketsToGet;
580 result = _tryWrite(report, deviceContextPtr);
584 continueGetInReport =
true;
585 while (continueGetInReport) {
586 result = hid_read_timeout(deviceContext->handle, report, EXTENDED_PACKET_SIZE, STANDARD_TIMEOUT_MILLISECONDS);
587 if (result != HID_OPERATION_READ_SUCCESS){
588 return READING_PROCESS_FAILED;
591 if (report[0] != CORRECT_GET_FRAME_REPLY) {
595 ++numOfPacketsReceived;
597 numOfPacketsLeft = report[3];
598 if (numOfPacketsLeft >= REMAINING_PACKETS_ERROR ||
599 (numOfPacketsLeft != numOfPacketsToGet - numOfPacketsReceived)) {
600 return GET_FRAME_REMAINING_PACKETS_ERROR;
603 if (numOfPacketsLeft != numOfPacketsToGet - numOfPacketsReceived) {
604 return GET_FRAME_REMAINING_PACKETS_ERROR;
607 continueGetInReport = (numOfPacketsLeft > 0)?
true :
false;
609 pixelOffset = (report[2] << 8) | report[1];
612 indexOfPixelInPacket = 0;
614 while ((totalNumOfReceivedPixels < deviceContext->numOfPixelsInFrame) && (indexOfPixelInPacket < NUM_OF_PIXELS_IN_PACKET)) {
615 uint16_t pixel = (report[indexInPacket + 1] << 8) | report[indexInPacket];
616 framePixelsBuffer[pixelOffset + indexOfPixelInPacket] = pixel;
619 ++indexOfPixelInPacket;
620 ++totalNumOfReceivedPixels;
629 unsigned char report[EXTENDED_PACKET_SIZE];
633 result = _verifyDeviceContextByPtr(deviceContextPtr);
637 report[0] = ZERO_REPORT_ID;
638 report[1] = CLEAR_MEMORY_REQUEST;
640 result = _writeReadFunction(report, CORRECT_CLEAR_MEMORY_REPLY, STANDARD_TIMEOUT_MILLISECONDS, deviceContextPtr);
645 errorCode = report[1];
653 uint8_t report[EXTENDED_PACKET_SIZE];
655 result = _verifyDeviceContextByPtr(deviceContextPtr);
659 report[0] = ZERO_REPORT_ID;
660 report[1] = ERASE_FLASH_REQUEST;
662 result = _writeReadFunction(report, CORRECT_ERASE_FLASH_REPLY, ERASE_FLASH_TIMEOUT_MILLISECONDS, deviceContextPtr);
667 errorCode = report[1];
671 int readFlash(uint8_t *buffer, uint32_t absoluteOffset, uint32_t bytesToRead, uintptr_t* deviceContextPtr)
674 uint8_t report[EXTENDED_PACKET_SIZE];
676 uint32_t numOfPacketsToGet = 0;
677 uint8_t numOfPacketsToGetCurrent = 0, numOfPacketsReceivedCurrent = 0, numOfPacketsLeftCurrent = 0;
679 bool continueGetInReport =
true;
680 uint16_t localOffset = 0;
681 uint32_t totalNumOfReceivedBytes = 0;
683 uint8_t indexOfByteInPacket;
686 uint32_t offsetIncrement = 0;
687 uint8_t payloadSize = PACKET_SIZE - 4;
689 DeviceContext_t *deviceContext = NULL;
691 result = _verifyDeviceContextByPtr(deviceContextPtr);
696 return INPUT_PARAMETER_NOT_INITIALIZED;
699 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
701 if (!deviceContext->handle) {
702 result = _reconnect(deviceContextPtr);
708 numOfPacketsToGet = bytesToRead / payloadSize;
709 numOfPacketsToGet += (bytesToRead % payloadSize)? 1 : 0;
711 while(numOfPacketsToGet) {
712 numOfPacketsToGetCurrent = (numOfPacketsToGet > MAX_READ_FLASH_PACKETS)? MAX_READ_FLASH_PACKETS : numOfPacketsToGet;
714 report[0] = ZERO_REPORT_ID;
715 report[1] = READ_FLASH_REQUEST;
716 report[2] = LOW_BYTE(LOW_WORD(absoluteOffset + offsetIncrement));
717 report[3] = HIGH_BYTE(LOW_WORD(absoluteOffset + offsetIncrement));
718 report[4] = LOW_BYTE(HIGH_WORD(absoluteOffset + offsetIncrement));
719 report[5] = HIGH_BYTE(HIGH_WORD(absoluteOffset + offsetIncrement));
720 report[6] = numOfPacketsToGetCurrent;
722 result = hid_write(deviceContext->handle, (
const unsigned char*)report, EXTENDED_PACKET_SIZE);
723 if (result != HID_OPERATION_WRITE_SUCCESS) {
724 return WRITING_PROCESS_FAILED;
727 numOfPacketsReceivedCurrent = 0;
728 continueGetInReport =
true;
729 while (continueGetInReport) {
730 result = hid_read_timeout(deviceContext->handle, report, EXTENDED_PACKET_SIZE, STANDARD_TIMEOUT_MILLISECONDS);
731 if (result != HID_OPERATION_READ_SUCCESS){
732 return READING_PROCESS_FAILED;
735 ++numOfPacketsReceivedCurrent;
737 if (report[0] != CORRECT_READ_FLASH_REPLY) {
741 numOfPacketsLeftCurrent = report[3];
743 if (numOfPacketsLeftCurrent >= REMAINING_PACKETS_ERROR || (numOfPacketsLeftCurrent != numOfPacketsToGetCurrent - numOfPacketsReceivedCurrent)) {
744 return READ_FLASH_REMAINING_PACKETS_ERROR;
746 continueGetInReport = (numOfPacketsLeftCurrent > 0)?
true :
false;
748 localOffset = (report[2] << 8) | report[1];
751 indexOfByteInPacket = 0;
753 while ((totalNumOfReceivedBytes < bytesToRead) && (indexOfByteInPacket < payloadSize)) {
754 buffer[offsetIncrement + localOffset + indexOfByteInPacket++] = report[indexInPacket++];
755 ++totalNumOfReceivedBytes;
759 if (numOfPacketsToGet > MAX_READ_FLASH_PACKETS) {
760 numOfPacketsToGet -= MAX_READ_FLASH_PACKETS;
761 offsetIncrement += MAX_READ_FLASH_PACKETS * payloadSize;
763 numOfPacketsToGet = 0;
771 int writeFlash(uint8_t *buffer, uint32_t absoluteOffset, uint32_t bytesToWrite, uintptr_t* deviceContextPtr)
774 uint8_t report[EXTENDED_PACKET_SIZE];
775 uint8_t errorCode = -1;
777 uint32_t index, byteIndex = 0;
778 uint32_t bytesLeftToWrite = bytesToWrite;
780 DeviceContext_t *deviceContext = NULL;
782 result = _verifyDeviceContextByPtr(deviceContextPtr);
787 return INPUT_PARAMETER_NOT_INITIALIZED;
790 deviceContext = (DeviceContext_t*)(*deviceContextPtr);
792 if (deviceContext->handle == NULL) {
793 result = _reconnect(deviceContextPtr);
799 while (bytesLeftToWrite) {
800 report[0] = ZERO_REPORT_ID;
801 report[1] = WRITE_FLASH_REQUEST;
802 report[2] = LOW_BYTE(LOW_WORD(absoluteOffset));
803 report[3] = HIGH_BYTE(LOW_WORD(absoluteOffset));
804 report[4] = LOW_BYTE(HIGH_WORD(absoluteOffset));
805 report[5] = HIGH_BYTE(HIGH_WORD(absoluteOffset));
806 report[6] = (bytesLeftToWrite > MAX_FLASH_WRITE_PAYLOAD) ? MAX_FLASH_WRITE_PAYLOAD : bytesLeftToWrite;
809 while ((byteIndex < bytesToWrite) && (index < EXTENDED_PACKET_SIZE)) {
810 report[index++] = buffer[byteIndex++];
813 result = hid_write(deviceContext->handle, (
const unsigned char*)report, EXTENDED_PACKET_SIZE);
814 if (result != HID_OPERATION_WRITE_SUCCESS) {
815 return WRITING_PROCESS_FAILED;
818 result = hid_read_timeout(deviceContext->handle, report, EXTENDED_PACKET_SIZE, STANDARD_TIMEOUT_MILLISECONDS);
819 if (result != HID_OPERATION_READ_SUCCESS){
820 return READING_PROCESS_FAILED;
823 if (report[0] != CORRECT_WRITE_FLASH_REPLY) {
827 errorCode = report[1];
828 if (errorCode != OK) {
832 if (bytesLeftToWrite > MAX_FLASH_WRITE_PAYLOAD) {
833 bytesLeftToWrite -= MAX_FLASH_WRITE_PAYLOAD;
834 absoluteOffset += MAX_FLASH_WRITE_PAYLOAD;
836 bytesLeftToWrite = 0;
844 unsigned char report[EXTENDED_PACKET_SIZE];
847 result = _verifyDeviceContextByPtr(deviceContextPtr);
851 report[0] = ZERO_REPORT_ID;
852 report[1] = RESET_REQUEST;
854 result = _writeOnlyFunction(report, deviceContextPtr);
860 unsigned char report[EXTENDED_PACKET_SIZE];
863 result = _verifyDeviceContextByPtr(deviceContextPtr);
867 report[0] = ZERO_REPORT_ID;
868 report[1] = DETACH_REQUEST;
870 result = _writeOnlyFunction(report, deviceContextPtr);
int disconnectDeviceContext(uintptr_t *deviceContextPtr)
Free a device handle.
LIBSHARED_AND_STATIC_EXPORT uint32_t getDevicesCount()
Returns the number of the connected devices.
int getFrame(uint16_t *framePixelsBuffer, uint16_t numOfFrame, uintptr_t *deviceContextPtr)
Gets frame.
int eraseFlash(uintptr_t *deviceContextPtr)
Erases user flash memory.
int getAcquisitionParameters(uint16_t *numOfScans, uint16_t *numOfBlankScans, uint8_t *scanMode, uint32_t *timeOfExposure, uintptr_t *deviceContextPtr)
Returns the same values as set by setAcquisitionParameters.
int setFrameFormat(uint16_t numOfStartElement, uint16_t numOfEndElement, uint8_t reductionMode, uint16_t *numOfPixelsInFrame, uintptr_t *deviceContextPtr)
Sets frame parameters Note: this function clears the memory and stops the current acquisition...
int setExposure(uint32_t timeOfExposure, uint8_t force, uintptr_t *deviceContextPtr)
Sets exposure parameter.
int triggerAcquisition(uintptr_t *deviceContextPtr)
Start acquisition by software.
int clearMemory(uintptr_t *deviceContextPtr)
Clears memory.
int connectToDeviceByIndex(unsigned int index, uintptr_t *deviceContextPtr)
Connects to the required device by index This function or its analog connectToSingleDeviceBySerial sh...
int connectToDeviceBySerial(const char *const serialNumber, uintptr_t *deviceContextPtr)
Finds the requested device by the provided serial number and connects to it. This function or its ana...
int setExternalTrigger(uint8_t enableMode, uint8_t signalFrontMode, uintptr_t *deviceContextPtr)
Sets the external acquisition trigger.
int getFrameFormat(uint16_t *numOfStartElement, uint16_t *numOfEndElement, uint8_t *reductionMode, uint16_t *numOfPixelsInFrame, uintptr_t *deviceContextPtr)
Returns the same values as set by setFrameFormat.
int setMultipleParameters(uint16_t numOfScans, uint16_t numOfBlankScans, uint8_t scanMode, uint32_t timeOfExposure, uint8_t enableMode, uint8_t signalFrontMode, uintptr_t *deviceContextPtr)
Sets multiple parameters - combination of setAcquisitionParametersOnSingleDevice and setExternalTrigg...
int readFlash(uint8_t *buffer, uint32_t absoluteOffset, uint32_t bytesToRead, uintptr_t *deviceContextPtr)
Reads from user flash memory Reads bytesToRead from user flash memory starting at offset and copies t...
int getStatus(uint8_t *statusFlags, uint16_t *framesInMemory, uintptr_t *deviceContextPtr)
Gets the device status.
int detachDevice(uintptr_t *deviceContextPtr)
Disconnects the device The device will be disconnected from USB, and any interaction with it will not...
int resetDevice(uintptr_t *deviceContextPtr)
Resets all the device parameters to their default values and clears the memory.
LIBSHARED_AND_STATIC_EXPORT DeviceInfo_t * getDevicesInfo()
Obtains the list of all connected devices. Run clearDevicesInfo() with the result of this function to...
LIBSHARED_AND_STATIC_EXPORT void clearDevicesInfo(DeviceInfo_t *devices)
Clears the list of all connected devices obtained by getDevicesInfo() function.
int setOpticalTrigger(uint8_t enableMode, uint16_t pixel, uint16_t threshold, uintptr_t *deviceContextPtr)
Sets the optical atrigger.
int setAcquisitionParameters(uint16_t numOfScans, uint16_t numOfBlankScans, uint8_t scanMode, uint32_t timeOfExposure, uintptr_t *deviceContextPtr)
Sets acquisition parameters.
int writeFlash(uint8_t *buffer, uint32_t absoluteOffset, uint32_t bytesToWrite, uintptr_t *deviceContextPtr)
Writes bytesToWrite bytes from the buffer to the user flash memory starting at offset.