commit 7fa17639a2e498e75b41d1258422ac80bacc6326 Author: Sebastian H. Gabrielli Date: Fri Jan 24 23:01:50 2025 +0100 Initial commit diff --git a/.vs/Project1/project-colors.json b/.vs/Project1/project-colors.json new file mode 100644 index 0000000..3475367 --- /dev/null +++ b/.vs/Project1/project-colors.json @@ -0,0 +1,11 @@ +{ + "Version": 1, + "ProjectMap": { + "261558be-3639-413c-8c33-8adbb775d19e": { + "ProjectGuid": "261558be-3639-413c-8c33-8adbb775d19e", + "DisplayName": "Project1", + "ColorIndex": 0 + } + }, + "NextColorIndex": 1 +} \ No newline at end of file diff --git a/.vs/Project1/v17/.suo b/.vs/Project1/v17/.suo new file mode 100644 index 0000000..667c6cd Binary files /dev/null and b/.vs/Project1/v17/.suo differ diff --git a/.vs/Project1/v17/Browse.VC.db b/.vs/Project1/v17/Browse.VC.db new file mode 100644 index 0000000..c27fc79 Binary files /dev/null and b/.vs/Project1/v17/Browse.VC.db differ diff --git a/.vs/Project1/v17/ipch/AutoPCH/1a0796af3c58895d/SOURCE.ipch b/.vs/Project1/v17/ipch/AutoPCH/1a0796af3c58895d/SOURCE.ipch new file mode 100644 index 0000000..b5c3e67 Binary files /dev/null and b/.vs/Project1/v17/ipch/AutoPCH/1a0796af3c58895d/SOURCE.ipch differ diff --git a/Debug/Project1.exe b/Debug/Project1.exe new file mode 100644 index 0000000..6b08f6e Binary files /dev/null and b/Debug/Project1.exe differ diff --git a/Debug/Project1.pdb b/Debug/Project1.pdb new file mode 100644 index 0000000..907dbf5 Binary files /dev/null and b/Debug/Project1.pdb differ diff --git a/Project1.sln b/Project1.sln new file mode 100644 index 0000000..a8d6bcf --- /dev/null +++ b/Project1.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31919.166 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Project1", "Project1\Project1.vcxproj", "{261558BE-3639-413C-8C33-8ADBB775D19E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {261558BE-3639-413C-8C33-8ADBB775D19E}.Debug|x64.ActiveCfg = Debug|Win32 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Debug|x64.Build.0 = Debug|Win32 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Debug|x86.ActiveCfg = Debug|Win32 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Debug|x86.Build.0 = Debug|Win32 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Release|x64.ActiveCfg = Release|x64 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Release|x64.Build.0 = Release|x64 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Release|x86.ActiveCfg = Release|Win32 + {261558BE-3639-413C-8C33-8ADBB775D19E}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {6857DD2F-4B36-4FF2-973D-BCC64B76719C} + EndGlobalSection +EndGlobal diff --git a/Project1/Debug/Project1.exe.recipe b/Project1/Debug/Project1.exe.recipe new file mode 100644 index 0000000..c75eb35 --- /dev/null +++ b/Project1/Debug/Project1.exe.recipe @@ -0,0 +1,11 @@ + + + + + C:\Users\sebgab\source\repos\Project1\Debug\Project1.exe + + + + + + \ No newline at end of file diff --git a/Project1/Debug/Project1.ilk b/Project1/Debug/Project1.ilk new file mode 100644 index 0000000..afefeac Binary files /dev/null and b/Project1/Debug/Project1.ilk differ diff --git a/Project1/Debug/Project1.log b/Project1/Debug/Project1.log new file mode 100644 index 0000000..ba527e0 --- /dev/null +++ b/Project1/Debug/Project1.log @@ -0,0 +1,2 @@ + Source.cpp + Project1.vcxproj -> C:\Users\sebgab\source\repos\Project1\Debug\Project1.exe diff --git a/Project1/Debug/Project1.tlog/CL.command.1.tlog b/Project1/Debug/Project1.tlog/CL.command.1.tlog new file mode 100644 index 0000000..952e631 Binary files /dev/null and b/Project1/Debug/Project1.tlog/CL.command.1.tlog differ diff --git a/Project1/Debug/Project1.tlog/CL.read.1.tlog b/Project1/Debug/Project1.tlog/CL.read.1.tlog new file mode 100644 index 0000000..6c99977 Binary files /dev/null and b/Project1/Debug/Project1.tlog/CL.read.1.tlog differ diff --git a/Project1/Debug/Project1.tlog/CL.write.1.tlog b/Project1/Debug/Project1.tlog/CL.write.1.tlog new file mode 100644 index 0000000..6c4dda5 Binary files /dev/null and b/Project1/Debug/Project1.tlog/CL.write.1.tlog differ diff --git a/Project1/Debug/Project1.tlog/Project1.lastbuildstate b/Project1/Debug/Project1.tlog/Project1.lastbuildstate new file mode 100644 index 0000000..f4abbd0 --- /dev/null +++ b/Project1/Debug/Project1.tlog/Project1.lastbuildstate @@ -0,0 +1,2 @@ +PlatformToolSet=v143:VCToolArchitecture=Native32Bit:VCToolsVersion=14.30.30705:TargetPlatformVersion=10.0.26100.0: +Debug|Win32|C:\Users\sebgab\source\repos\Project1\| diff --git a/Project1/Debug/Project1.tlog/link.command.1.tlog b/Project1/Debug/Project1.tlog/link.command.1.tlog new file mode 100644 index 0000000..bf1baa9 Binary files /dev/null and b/Project1/Debug/Project1.tlog/link.command.1.tlog differ diff --git a/Project1/Debug/Project1.tlog/link.read.1.tlog b/Project1/Debug/Project1.tlog/link.read.1.tlog new file mode 100644 index 0000000..b56fdfa Binary files /dev/null and b/Project1/Debug/Project1.tlog/link.read.1.tlog differ diff --git a/Project1/Debug/Project1.tlog/link.write.1.tlog b/Project1/Debug/Project1.tlog/link.write.1.tlog new file mode 100644 index 0000000..0726ec3 Binary files /dev/null and b/Project1/Debug/Project1.tlog/link.write.1.tlog differ diff --git a/Project1/Debug/Source.obj b/Project1/Debug/Source.obj new file mode 100644 index 0000000..2f4c3f8 Binary files /dev/null and b/Project1/Debug/Source.obj differ diff --git a/Project1/Debug/vc143.idb b/Project1/Debug/vc143.idb new file mode 100644 index 0000000..80140ad Binary files /dev/null and b/Project1/Debug/vc143.idb differ diff --git a/Project1/Debug/vc143.pdb b/Project1/Debug/vc143.pdb new file mode 100644 index 0000000..9d2e86d Binary files /dev/null and b/Project1/Debug/vc143.pdb differ diff --git a/Project1/PTRobot.dll b/Project1/PTRobot.dll new file mode 100644 index 0000000..ad598df Binary files /dev/null and b/Project1/PTRobot.dll differ diff --git a/Project1/PTRobot.h b/Project1/PTRobot.h new file mode 100644 index 0000000..8a786d1 --- /dev/null +++ b/Project1/PTRobot.h @@ -0,0 +1,1748 @@ +///////////////////////////////////////////////////////////////////////////// +// // +// PTRobot API Definition // +// // +// PTRobot is an API to allow third parties to integrate // +// Primera disc publishing systems into their application. // +// // +// // +// Copyright (C) 2005-6 Primera Technology Inc. // +// // +///////////////////////////////////////////////////////////////////////////// + + +// NOTE: See end of this file for pseudo-code example usage of the PTRobot API + + +/////////////////////////////////////////////////////////////////// +// +// PTRobot Definitions +// +/////////////////////////////////////////////////////////////////// +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#pragma once + +////////////////////////////////////////////////// +// +// Return Values from PTRobot_xxxx API functions +// +/////////////////////////////////////////////////// +#define PTROBOT_OK 0 +#define PTROBOT_INTERNAL 500 +#define PTROBOT_SEQUENCE 501 +#define PTROBOT_INVALID_ROBOT 502 +#define PTROBOT_INVALID_DRIVE 503 +#define PTROBOT_INVALID_BIN 504 +#define PTROBOT_NODRIVES 505 +#define PTROBOT_OPENCLOSE_FAILED 506 +#define PTROBOT_OVERFLOW 507 +#define PTROBOT_NO_PRINTER 508 +#define PTROBOT_PRINTFILE_INVALID 509 +#define PTROBOT_PRINTAPP_NOT_INSTALLED 510 +#define PTROBOT_PRINTFILE_NOT_FOUND 511 +#define PTROBOT_PRN_INVALID 512 +#define PTROBOT_UNSUPPORTED_OPTION 513 +#define PTROBOT_DIRNOTFOUND 514 +#define PTROBOT_INVALID_LOCATION 515 +#define PTROBOT_MULTDRIVES 516 +#define PTROBOT_INVALID_PRINTER_SETTINGS 517 +#define PTROBOT_INVALID_DRIVE_POSITION 518 +#define PTROBOT_INVALID_ACTION 519 +#define PTROBOT_FEATURE_NOT_IMPLEMENTED 520 +#define PTROBOT_PRINTAPP_OPEN 521 +#define PTROBOT_MISSING_DLL 522 +#define PTROBOT_DRIVE_NOT_READY 523 +#define PTROBOT_INVALID_MEDIA 524 +#define PTROBOT_NO_MEDIA 525 +#define PTROBOT_INVALID_LANG 526 +#define PTROBOT_INVALID_ERROR 527 +#define PTROBOT_BUSY 528 +#define PTROBOT_INVALID_EXTENSION 529 + +/////////////////////////// +// +// System Errors +// (used by PTRobotStatus.dwSystemError) +// +/////////////////////////// +#define SYSERR_NONE 0 +#define SYSERR_PTR_TRAY 1 +#define SYSERR_CART_CODE 2 +#define SYSERR_INPUT_EMPTY 3 +#define SYSERR_PTR_COMM 4 +#define SYSERR_CLR_EMPTY 5 +#define SYSERR_BLK_EMPTY 6 +#define SYSERR_BOTH_EMPTY 7 +#define SYSERR_PICK 8 +#define SYSERR_ARM_MOVE 9 +#define SYSERR_CART_MOVE 10 +// 11 not used +#define SYSERR_INTERNAL_SW 12 +#define SYSERR_NO_ROBODRIVES 13 +#define SYSERR_OFFLINE 14 +#define SYSERR_COVER_OPEN 15 +#define SYSERR_PRINTER_PICK 16 +#define SYSERR_MULTIPLE_PICK 17 +#define SYSERR_MULTIPLEDISCS_IN_PRINTER 18 +#define SYSERR_MULTIPLEDISCS_IN_RECORDER 19 +#define SYSERR_DROPPED_DISC_RECORDER 20 +#define SYSERR_DROPPED_DISC_BIN1 28 +#define SYSERR_DROPPED_DISC_BIN2 29 +#define SYSERR_DROPPED_DISC_BIN3 30 +#define SYSERR_DROPPED_DISC_BIN4 31 +#define SYSERR_DROPPED_DISC_BIN5 32 +#define SYSERR_DROPPED_DISC_PRINTER 33 +#define SYSERR_DROPPED_DISC_REJECT 34 +#define SYSERR_DROPPED_DISC_UNKNOWN 35 +#define SYSERR_ALIGNNEEDED 36 +#define SYSERR_COLOR_INVALID 37 +#define SYSERR_BLACK_INVALID 38 +#define SYSERR_BOTH_INVALID 39 +#define SYSERR_NOCARTS 40 +#define SYSERR_K_IN_CMY 41 +#define SYSERR_CMY_IN_K 42 +#define SYSERR_SWAPPED 43 +#define SYSERR_PIGONPRO 44 +#define SYSERR_ALIGNFAILED 45 +#define SYSERR_DROPPED_DISC_PRINTER_FATAL 46 +#define SYSERR_MULTIPLEDISCS_IN_RIGHTBIN 47 +#define SYSERR_MULTIPLEDISCS_IN_LEFTBIN 48 +#define SYSERR_CLR_EMPTY_FINAL 49 +#define SYSERR_BLK_EMPTY_FINAL 50 +#define SYSERR_BOTH_EMPTY_FINAL 51 +#define SYSERR_WAITING_FOR_PRINTER 52 +#define SYSERR_NO_DISC_IN_PRINTER 53 +#define SYSERR_BUSY 54 +#define SYSERR_PURGE 55 +#define SYSERR_DOCK_SENSOR 56 +#define SYSERR_ALREADY_PRINTED 57 +#define SYSERR_UNKNOWN_HARDWARE 58 +#define SYSERR_CARR_SERVO 59 +#define SYSERR_CARR_STALL 60 +#define SYSERR_PEN_DATA 61 +#define SYSERR_PRINT_IMAGE 62 +#define SYSERR_AMB_TEMP 63 +#define SYSERR_PEN_SHORT 64 +#define SYSERR_MODEL_NUM 65 +#define SYSERR_BUFF_OVR 66 + + +/////////////////////////// +// +// System State +// (used by PTRobotStatus.dwSystemState) +// +////////////////////////// +#define SYSSTATE_IDLE 0 +#define SYSSTATE_BUSY 1 +#define SYSSTATE_ERROR 2 + +/////////////////////////// +// +// Robot Type +// +/////////////////////////// +#define ROBOT_DISCPUBLISHER 0 +#define ROBOT_DISCPUBLISHERII 1 +#define ROBOT_DISCPUBLISHERPRO 2 +#define ROBOT_COMPOSERMAX 3 +#define ROBOT_RACKMOUNT_DPII 4 +#define ROBOT_DISCPUBLISHER_XRP 5 +#define ROBOT_DISCPUBLISHER_SE 6 +#define ROBOT_DISCPUBLISHERPRO_XI 7 +#define ROBOT_DISCPUBLISHER_4100 8 +#define ROBOT_DISCPUBLISHER_4100_XRP 9 +#define ROBOT_DISCPUBLISHER_4051 10 +#define ROBOT_DISCPUBLISHER_SE3 11 +#define ROBOT_DISCPUBLISHER_4200 12 +#define ROBOT_DISCPUBLISHER_4200_XRP 13 +#define ROBOT_DISCPUBLISHER_4052 14 + +/////////////////////////// +// +// Bin Auto Use +// +/////////////////////////// +#define BIN_INPUT 0 +#define BIN_OUTPUT 1 + +/////////////////////////// +// +// Robot Options +// +/////////////////////////// +#define PTOPT_KIOSKMODE 0x00000001 + + + +/////////////////////////// +// +// Robot Actions +// +/////////////////////////// +#define PTACT_ALIGNPRINTER 0x00000001 +#define PTACT_IGNOREINKLOW 0x00000002 +#define PTACT_DISABLEPWRBUTTON 0x00000004 +#define PTACT_REINIT_DRIVES 0x00000008 +#define PTACT_IDENTIFY 0x00000010 +#define PTACT_CANCELCMD 0x00000020 +#define PTACT_ENABLEPWRBUTTON 0x00000040 +#define PTACT_RESETSYSTEM 0x00000080 +#define PTACT_CHECKDISCS 0x00000100 // Check the number of discs in the bins +#define PTACT_CLEANCARTRIDGES 0x00000200 // Clean the cartridges +#define PTACT_CALIBRATE_ONE_DISC 0x00000400 // SE, II, Pro: Calibrate for one disc (user must put one disc in each bin). +#define PTACT_CHANGE_CARTRIDGE 0x00000800 // SE, II, Pro: Start the cartridge change procedure +#define PTACT_END_CARTRIDGE_CHANGE 0x00001000 // SE: End the cartridge change (can close lid also) +#define PTACT_SHIP_POSITION 0x00002000 // SE, II, Pro: Move the picker to the shipping position +#define PTACT_RESET_LEFT_INK_LEVELS 0x00004000 // II: Clears the ink spits for the LEFT cartridge +#define PTACT_RESET_RIGHT_INK_LEVELS 0x00008000 // II: Clears the ink spits for the RIGHT cartridge +#define PTACT_ALLOW_NO_CARTRIDGES 0x00010000 // SE, II, Pro: Allows unit to operate non-printing robotics without a cartridge +#define PTACT_XI_LIGHT_OFF 0x00020000 +#define PTACT_XI_LIGHT_ON 0x00040000 +#define PTACT_XI_LIGHT_FLASH 0x00080000 +#define PTACT_UNHOOK_PICKER 0x00100000 +#define PTACT_AUTOPRINTER_MODE 0x00200000 // DP4100: can perform a faster multiple copy print-only job by calling PTRobot_SetPrintCopies() + // prior to calling the print function (e.g. PTRobot_PrintFile()). +#define PTACT_FAN_ON 0x00400000 // DP4100: turn on system fan +#define PTACT_FAN_OFF 0x00800000 // DP4100: turn off system fan + + +/////////////////////////// +// +// Print Quality +// +/////////////////////////// +#define PQ_LOW 0 +#define PQ_MED 1 +#define PQ_BETTER 2 +#define PQ_HIGH 3 +#define PQ_BEST 4 + +/////////////////////////// +// +// Drive Open/Close +// +/////////////////////////// +#define DRIVE_OPEN 0 +#define DRIVE_CLOSE 1 + + +/////////////////////////// +// +// Locations +// +/////////////////////////// +#define LOCATION_AUTO 0 +#define LOCATION_PRINTER 100 +#define LOCATION_REJECT 200 + +/////////////////////////// +// +// Drive Bus Types +// +/////////////////////////// +#define BUSTYPE_USB 0 +#define BUSTYPE_1394 1 + +/////////////////////////// +// +// Clear Drive +// +/////////////////////////// +#define CLEARDRIVE_NO 0 +#define CLEARDRIVE_YES 1 + + +/////////////////////////// +// +// Languages +// +/////////////////////////// +#define ENGLISH 0 +#define JAPANESE 1 +#define GERMAN 2 +#define FRENCH 3 +#define SPANISH 4 +#define ITALIAN 5 +#define CHINESE 6 // Simplified +#define KOREAN 7 +#define POLISH 8 +#define CHINESE_TRAD 9 // Traditional +#define CZECH 10 +#define LAST_LANGUAGE CZECH + + +////////////////////////////// +// +// Printer Tray Status +// +////////////////////////////// +#define PRINT_TRAY_IN_WITH_DISC 'D' +#define PRINT_TRAY_IN_NO_DISC 'I' +#define PRINT_TRAY_OUT 'O' + + +//////////////////////////////// +// +// Disc Pick Switch Status +// +//////////////////////////////// +#define DISC_PICKER_NO_DISC 'X' +#define DISC_PICKER_HAS_DISC 'O' + + +///////////////////////////////// +// +// Cartridge Types +// +///////////////////////////////// +#define CARTRIDGE_NONE 0 +#define CARTRIDGE_COLOR 1 +#define CARTRIDGE_BLACK 2 +#define CARTRIDGE_YELLOW 3 +#define CARTRIDGE_CYAN 4 +#define CARTRIDGE_MAGENTA 5 +#define CARTRIDGE_COLORLOTUS 6 +#define CARTRIDGE_RESERVED 7 + +///////////////////////////////// +// +// Cartridges Installed +// +///////////////////////////////// +#define CARTRIDGE_INSTALLED_NONE 0 +#define CARTRIDGE_INSTALLED_COLOR 1 +#define CARTRIDGE_INSTALLED_BLACK 2 +#define CARTRIDGE_INSTALLED_COLOR_AND_BLACK 3 +#define CARTRIDGE_INSTALLED_COLOR_AND_COLOR 4 + + + +/////////////////////////////////////////////////////////////////// +// +// PTRobot Data Structures +// +/////////////////////////////////////////////////////////////////// + +/////////////////////////// +// +// PTDriveInfo Structure +// +/////////////////////////// +typedef struct +{ + HANDLE hDrive; //Drive Handle. + TCHAR tszDriveName[132]; //Drive String (reported from drive) + TCHAR tszFirmwareVer[40]; //Drive FW version + TCHAR tszSerialNum[40]; //Drive Serial Number (bridge) + HANDLE hRobot; + DWORD dwDriveColumn; //Drive Column (0 based - 0 is leftmost column) + DWORD dwDriveRow; //Drive Row (0 based - 0 is the top row) +}PTDriveInfo, *pPTDriveInfo; + + +/////////////////////////// +// +// PTDriveInfo2 Structure +// +/////////////////////////// +typedef struct +{ + PTDriveInfo DriveInfo; // PTDriveInfo structure + TCHAR tszDriveSerialNum[40]; // Drive Serial Number +}PTDriveInfo2, *pPTDriveInfo2; + + +/////////////////////////// +// +// PTRobotInfo Structure +// +/////////////////////////// +#define MAX_ROBOT_DRIVES 10 +typedef struct +{ + HANDLE hRobot; //Robot Handle + TCHAR tszRobotDesc[100]; //Robot Description + DWORD dwRobotType; //See "Robot Type" section above + DWORD dwNumDrives; //Number of Recorders on this robot + DWORD dwNumPrinters; //Number of Printers on this robot (0 or 1) + DWORD dwNumBins; //Number of Bins on this robot + DWORD dwDriveColumns; //Number of Drive Columns + DWORD dwDriveRows; //Number of Drive Rows + TCHAR tszRobotFirmware[20]; //String Containing the FW Version of the Robot + DWORD dwSupportedOptions; //See "Robot Options" section above + DWORD dwSupportedActions; //See "Robot Actions" section above + HANDLE hDrives[MAX_ROBOT_DRIVES]; + DWORD dwDriveBusType; //BusType of the Drives +}PTRobotInfo, *pPTRobotInfo; + + +/////////////////////////// +// +// PTRobotInfo2 Structure +// +/////////////////////////// +#define MAX_CARTRIDGE_TYPES 8 +typedef struct +{ + DWORD dwNumCartridges; //Max Number of cartridges robot can hold + DWORD dwCartridgeType[MAX_CARTRIDGE_TYPES]; // First element is left-most cartridge and last element is right-most cartridge + // (from the user's viewpoint) + // see "Cartridge Types" above + DWORD dwFirmware2Code; + DWORD dwPGA; + DWORD dwModel; + DWORD dwUSBSerialNum; + DWORD dwMaxDiscsPerBin; // Added Version 1.22 + DWORD dwReserved[9]; // reserved for future data +}PTRobotInfo2, *pPTRobotInfo2; + + + +//To determine the BinLocation 1 represents the leftmost bin on the +//duplicator and N represents the rightmost bin (where N is the number +//of bins in the robot). + +/////////////////////////// +// +// PTRobotStatus Structure +// +/////////////////////////// +typedef struct +{ + DWORD dwSystemState; //See "System State" section above + DWORD dwSystemError; //See "System Errors" section above + DWORD dwCurrColorSpits; + DWORD dwCurrBlackSpits; + DWORD dwFullColorSpits; + DWORD dwFullBlackSpits; +}PTRobotStatus, *pPTRobotStatus; + + + +// Cartridge Status Information Values for bCartridgeStatus[] in PTRobotStatus2 below (for Bravo 4100) +typedef enum +{ + CARTRIDGE_INFO_STILL_READING, + CARTRIDGE_INFO_UNUSED, + CARTRIDGE_INFO_MISSING, + CARTRIDGE_INFO_INVALID, + CARTRIDGE_INFO_COMM_ERROR, + CARTRIDGE_INFO_BAD_POSITION, + CARTRIDGE_INFO_BAD_INSTALL, + CARTRIDGE_INFO_INVALID2, + CARTRIDGE_INFO_EMPTY, + CARTRIDGE_INFO_EMPTY2, + CARTRIDGE_INFO_EMPTY3, + CARTRIDGE_INFO_OK // Valid cartridge +} CartridgeInfoType; + + +/////////////////////////// +// +// PTRobotStatus2 Structure +// +/////////////////////////// +#define MAX_BINS 5 +#define UNKNOWN_NUM_DISCS 255 +#define NO_CARTRIDGE_INSTALLED 0 +#define VALID_CARTRIDGE 1 +#define INVALID_CARTRIDGE 2 +typedef struct +{ + DWORD dwCartridgeTypes; // See "Cartridges Installed" section above + DWORD dwNumDiscsInBins[MAX_BINS]; // 0th element is left-most bin (values are UNKNOWN_NUM_DISCS if unknown) + DWORD dwTotalPrints; // Total # of prints + DWORD dwTotalPicks; // Total # of picks from input bin + long lVerticalOffset; // Vertial print offset (300dpi units) - Ver 1.25 updated to long (can be negative) + long lHorizontalOffset; // Horizontal print offset (300dpi units) - Ver 1.25 updated to long (can be negative) + DWORD dwPrinterTrayStatus; // See "Printer Tray Status" section above + DWORD dwDiscPickSwitchStatus; // See "Disc Pick Switch Status" section above + DWORD dwCoverBeenOpenedFlag; // set to 1 if cover has been opened + DWORD dwCartridgeInstalled[MAX_CARTRIDGE_TYPES]; // 0=not installed. 1=valid cartridge. 2=invalid cartridge (ver 1.22 added) + DWORD dwCartridgeNeedsAlign[MAX_CARTRIDGE_TYPES]; // set to TRUE (1) if cartridge needs alignment (ver 1.22 added) + DWORD dwSystemStateHW; // actual system state as reported directly from the printer (may be different than dwSystemState in PTRobotStatus) + long lYellowInkRemaining; // Yellow % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% + long lMagentaInkRemaining; // Magenta % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% + long lCyanInkRemaining; // Cyan % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% + long lBlackInkRemaining; // Black % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% + // -BELOW VALUES ONLY VALID FOR DISC PUBLISHER 4100- + BYTE bCartridgeStatusYellow; // See CartridgeInfoType above for valid values + BYTE bCartridgeStatusMagenta; // See CartridgeInfoType above for valid values + BYTE bCartridgeStatusCyan; // See CartridgeInfoType above for valid values + BYTE bCartridgeStatusBlack; // See CartridgeInfoType above for valid values + DWORD dwReserved[6]; // reserved for future data +}PTRobotStatus2, *pPTRobotStatus2; + + +/////////////////////////// +// +// PTPrinterSettings Structure +// +/////////////////////////// +typedef struct +{ + DWORD dwPrintQuality; //See "Print Quality" section above + DWORD dwInnerDiam; //units in .1mm increments (150 - 500) + DWORD dwOuterMargin; //units in .1mm increments (0 - 20) +}PTPrinterSettings, *pPTPrinterSettings; + + +/////////////////////////// +// +// PTPrinterSettings2 Structure +// +/////////////////////////// +typedef struct +{ + // NOTE: 0xffff is a special value depending on Get or Set-- + // Get: 0xffff means that the setting is not supported + // Set: 0xffff means to use the current driver setting + DWORD dwPrintQuality; //See "Print Quality" section above + DWORD dwInnerDiam; //units in .1mm increments (150 - 500) + DWORD dwOuterMargin; //units in .1mm increments (0 - 20) + DWORD dwCartridge; // Cartridge type to use. 1=Black 2=Color 3=Color+Black + DWORD dwColorMatchType; // Color Rendering type. 0=Best for Graphics 1=Best for Photos + DWORD dwColorTable; // Color Table number to use. Valid values: 1-6 + DWORD dwSaturation; // Amount of saturation. 0-100 where 100 is full saturation + DWORD dwPrintBidi; // Print bi-directionally or not. 0=No 1=Yes + DWORD dwRotate180; // Rotate the image 180 degrees or not. 0=No 1=Yes + DWORD dwKioskPrintOnly; // Kiosk mode when doing print-only. 0=No 1=Yes + DWORD dwReserved[9]; +}PTPrinterSettings2, *pPTPrinterSettings2; + + + +/////////////////////////// +// +// PTMediaInfo Structure +// +/////////////////////////// +typedef struct +{ + TCHAR tszMediaID[20]; + TCHAR tszMediaType[20]; +} PTMediaInfo, *pPTMediaInfo; + + +/////////////////////////// +// +// PTManufactureInfo Structure +// +/////////////////////////// +typedef struct +{ + TCHAR tszSerialNum[11]; + TCHAR tszManufactureDate[12]; + DWORD dwFiller[20]; +}PTManufactureInfo, *pPTManufactureInfo; + + + +//----------------------------------------------------------------- +// PTRobot API Prototypes +//----------------------------------------------------------------- + + +//***************************************************************** +// +// PTRobot Initialization Functions +// +//***************************************************************** + +/////////////////////////// +// +// PTRobot_Initialize +// +// Description: +// Function to initialize internal data structures of +// the PTRobot module. +// Params: +// None +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_INTERNAL if an internal error occurred. +// PTROBOT_MISSING_DLL if one of the support DLLs cannot be found +// +/////////////////////////// +DWORD WINAPI PTRobot_Initialize(); + +/////////////////////////// +// +// PTRobot_Destroy +// +// Description: +// Function to destroy internal data structures of +// the PTRobot module. +// Params: +// None +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// +/////////////////////////// +DWORD WINAPI PTRobot_Destroy(); + + +/////////////////////////// +// +// PTRobot_SetupDebugging +// +// Description: +// Function to setup logging in the PTRobot module. We advise that your +// application has a "back door" method of turning debugging on. All debugging +// is off by default. +// Params: +// szDbgFile full path to a debug file +// dwDbgLvl debug Level (0-5) +// 0 = off, 1 = errors, 2 = warnings +// 3 = Info, 4 and 5 = more info +// szTraceFile full path to a trace file +// Notes: +// If szDbgFile is NULL then debugging will be turned off. If szTraceFile is +// NULL then function tracing will be off. Function tracing just logs the +// API function calls including the parameters. +// This function should be the very first PTRobot_xxxx function to be called. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_INTERNAL if an internal error occurred +// +/////////////////////////// +DWORD WINAPI PTRobot_SetupDebugging(TCHAR * szDbgFile, DWORD dwDbgLvl, TCHAR * szTraceFile); + + +/////////////////////////// +// +// PTRobot_EnumRobots +// +// Description: +// Function to enumerate the Robots on the system. +// Params: +// phRobots points to an array of HANDLEs to store +// the Robots found. +// pdwNumRobots points to a DWORD containing the number of HANDLEs +// in the phRobots array. This value is an input +// and an output. The user should specify the size +// (number of HANDLEs) of the phRobots array on input. +// The value of the pdwNumRobots on output will be the +// number of robots found. +// +// Notes: +// Both params will be updated upon successful completion of this +// command. phRobots will contain handles to robots connected to +// this system. pdwNumRobots will will be updated with the number of +// robots found. +// Also, note that the hDrives[] array in the PTRobotInfo will not be +// valid until PTRobot_EnumDrives is called. +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_INVALID_ROBOT if no robots found +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_OVERFLOW if the number of robots found is > the value in +// pdwNumRobots +// +/////////////////////////// +DWORD WINAPI PTRobot_EnumRobots(HANDLE * phRobots, DWORD * pdwNumRobots); + +/////////////////////////// +// +// PTRobot_EnumDrives +// +// Description: +// Function to enumerate the drives on the system and +// determine which drives are under the control of this +// robot. +// Params: +// hRobot Handle to the robot to enumerate the drives of. +// phDrives points to an array of DWORDS to store +// the Drives found. +// pdwNumDrives points to a DWORD containing the number of HANDLEs +// in the phDrives array. This value is an input +// and an output. The user should specify the size +// (number of HANDLEs) of the phDrives array on input. +// The value of the pdwNumDrives on output will be the +// number of drives found. +// +// Notes: +// Both params will be updated upon successful completion of this +// command. phDrives will contain handles to drives connected to +// this system. pdwNumDrives will will be updated with the number of +// drives found. +// +// The format of the drive handles is the following: +// +// The least significant byte should contain the drive letter, the +// other three bytes should contain the SCSI triple. +// The drive can be identified by either of these methods. +// +// For Example: 0x01030044 would identify a drive with: +// Host=1, ID = 3, LUN = 0, and a drive letter of "D" +// +// To identify the same drive the client could pass +// down 0x01030000, 0x00000044, or 0x01030044. +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence or after +// PTRobot_EnumDrivesWithList +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_OVERFLOW if the number of drives found is > the value in +// pdwNumDrives +// PTROBOT_MULTDRIVES if the module cannot determine which drives are +// robotically controlled. The calling application +// needs to use PTRobot_SetRoboticDrive to resolve +// this error. +// +/////////////////////////// +DWORD WINAPI PTRobot_EnumDrives(HANDLE hRobot, HANDLE * phDrives, DWORD * pdwNumDrives); + +/////////////////////////// +// +// PTRobot_EnumDrivesWithList +// +// Description: +// Function to pass down drives enumerated by the calling app for +// PTRobot to use in determining which drives are robotically controlled. +// This is an alternative function to PTRobot_EnumDrives. +// Params: +// hRobot Handle to the robot. +// phDrives points to an array of HANDLEs that contains the +// drive handles of the drives in the system +// pdwNumDrives points to a DWORD containing the number of HANDLEs +// in the phDrives array. +// phRobotDrives points to an array of HANDLEs that contains the +// drive handles of the drives contained in this robot. +// pdwNumRobotDrives points to a DWORD containing the number of drives +// in the phRobotDrives array. +// +// Notes: +// phRobotDrives and pdwNumRobotDrives will be updated upon successful +// completion of this command. phRobotDrives will contain +// handles to drives contained in the robot. pdwNumRobotDrives will be +// updated with the number of drives found. +// +// The format of the drive handle is the following: +// +// The least significant byte should contain the drive letter, the +// other three bytes should contain the SCSI triple. The drive can +// be identified by either of these methods. +// +// For Example: 0x01030044 would identify a drive with: +// Host=1, ID = 3, LUN = 0, and a drive letter of "D" +// +// To identify the same drive the client could pass down +// 0x01030000, 0x00000044, or 0x01030044. +// +// This function should be called instead of PTRobot_EnumDrives if the +// calling application wants to enumerate the drives and have PTRobot +// select the Robotically controlled drives from the list the calling +// application provides. +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence or after +// PTRobot_EnumDrives +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_OVERFLOW if the number of robotic drives found is > the value +// in pdwDrives +// PTROBOT_MULTDRIVES if the module cannot determine which drives are +// robotically controlled. +// +/////////////////////////// +DWORD WINAPI PTRobot_EnumDrivesWithList(HANDLE hRobot, HANDLE * phDrives, + DWORD * pdwNumDrives, HANDLE * phRobotDrives, DWORD * pdwNumRobotDrives); + + +/////////////////////////// +// +// PTRobot_SetRoboticDrive +// +// Description: +// Function to set a drive's position within the duplicator when +// the PTROBOT_MULTDRIVES error is returned from either of the +// EnumDrives functions. +// Params: +// hRobots Handle to the Robot. +// hDrive Handle to the Drive +// dwColIndex Index identifying the column that the drive is in. +// (0 based where 0 is the left-most column) +// dwRowIndex Index identifying the row that the drive is in. +// (0 based where 0 is the top row) +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// PTROBOT_INVALID_DRIVE_POSITION if column/row ids are invalid. +// +/////////////////////////// +DWORD WINAPI PTRobot_SetRoboticDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwColIndex, + DWORD dwRowIndex); + +/////////////////////////// +// +// PTRobot_SetOpenCloseFunction +// +// Description: +// Function to set a calling application provided drive open/close +// function. +// Params: +// pvOpenClose pointer to a function to open and close the drive. +// (setting to NULL will cause non-callback open/close +// to be used). +// Notes: +// This function allows the calling application to provide the drive +// open/closing functionality through their recording engine. If this +// function is not called then the drive will be opened/closed via OS +// calls. The function pointed to by the pvOpenClose param should be +// defined as follows: +// +// void OpenCloseDrive(DWORD hDrive, DWORD dwOpen); +// +// Please see the "Drive Open/Close" definitions above for the dwOpen +// param. +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// +/////////////////////////// +DWORD WINAPI PTRobot_SetOpenCloseFunction(void * pvOpenClose); + +/////////////////////////// +// +// PTRobot_SetRobotOptions +// +// Description: +// Function to set the current robot options. +// Params: +// hRobot Handle to the robot +// dwRobotOptions DWORD containing the options to set. +// See "Robot Options" defines above +// Notes: +// You should call PTRobot_GetRobotOptions to get the current Options +// and then set the options you want to change prior to calling +// this function. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_UNSUPPORTED_OPTION if the option is unsupported on that robot +// +/////////////////////////// +DWORD WINAPI PTRobot_SetRobotOptions(HANDLE hRobot, DWORD dwRobotOptions); + +/////////////////////////// +// +// PTRobot_GetRobotOptions +// +// Description: +// Function to get the current robot options. +// Params: +// hRobot Handle to the robot +// pdwRobotOptions points to a DWORD. +// See "Robot Options" defines above +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_GetRobotOptions(HANDLE hRobot, DWORD *pdwRobotOptions); + + + + + +//***************************************************************** +// +// PTRobot Info/Status Functions +// +//***************************************************************** + +/////////////////////////// +// +// PTRobot_GetDriveInfo +// +// Description: +// Function to get the drive info for a particular +// drive handle. +// Params: +// hDrive Handle to the drive (from EnumDrives) +// pDrvInfo points to a PTDriveInfo structure. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_GetDriveInfo(HANDLE hDrive, PTDriveInfo* pDrvInfo); + + +// Adds Drive Serial number in addition to the bridge serial number +DWORD WINAPI PTRobot_GetDriveInfo2(HANDLE hDrive, PTDriveInfo2* pDrvInfo2); + + + +/////////////////////////// +// +// PTRobot_GetRobotInfo +// +// Description: +// Function to get the robot info for a particular +// robot handle. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pRobotInfo points to a PTRobotInfo structure. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_GetRobotInfo(HANDLE hRobot, PTRobotInfo *pRobotInfo); + +/////////////////////////// +// +// PTRobot_GetRobotInfo2 +// +// Description: +// Function to get ADDITIONAL robot info for a particular +// robot handle. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pRobotInfo2 points to a PTRobotInfo structure. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_GetRobotInfo2(HANDLE hRobot, PTRobotInfo2 *pRobotInfo2); + + +/////////////////////////// +// +// PTRobot_GetRobotStatus +// +// Description: +// Function to get the current status for a particular +// robot. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pRobotStatus points to a PTRobotStatus structure. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_GetRobotStatus(HANDLE hRobot, PTRobotStatus *pRobotStatus); + + +/////////////////////////// +// +// PTRobot_GetRobotStatus2 +// +// Description: +// Function to get the Additional current status for a particular +// robot. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pRobotStatus2 points to a PTRobotStatus2 structure. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_BUSY if no response from robot +// +/////////////////////////// +DWORD WINAPI PTRobot_GetRobotStatus2(HANDLE hRobot, PTRobotStatus2 *pRobotStatus2); + + +/////////////////////////// +// +// PTRobot_GetManufactureInfo +// +// Description: +// Function to get manufacture info +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pPTManufactureInfo points to a PTManufactureInfo structure. +// Notes: +// +// Return: +// PTROBOT_OK if Successful (and fills in pPTManufactureInfo) +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if invalid robot specified +// +/////////////////////////// +DWORD WINAPI PTRobot_GetManufactureInfo( HANDLE hRobot, PTManufactureInfo * pManufactureInfo); + + + +//***************************************************************** +// +// PTRobot Robotic Functions +// +//***************************************************************** + +/////////////////////////// +// +// PTRobot_LoadDrive +// +// Description: +// Function to load a drive from an input location +// Params: +// hRobot Handle to the robot (from EnumRobots) +// hDrive Handle to the drive (from EnumDrives) +// dwFromLocation DWORD containing the "from" location +// 0 = Auto +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// 100 = Printer +// dwClearDrive Clear drive before loading. +// (See Clear Drive section) +// +// Notes: +// Clear drive before loading should be done the first loading. This will +// cause the picker to attempt to pick discs out of the drive to determine +// if any discs were left in the drive from a previous job. +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// PTROBOT_INVALID_LOCATION if the location is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_LoadDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwFromLocation, DWORD dwClearDrive); + +/////////////////////////// +// +// PTRobot_LoadPrinter +// +// Description: +// Function to load the printer from an input bin location +// Params: +// hRobot Handle to the robot (from EnumRobots) +// dwFromLocation DWORD containing the "from" location +// 0 = Auto +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_INVALID_LOCATION if the location is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_LoadPrinter(HANDLE hRobot, DWORD dwFromLocation); + +/////////////////////////// +// +// PTRobot_LoadPrinterFromDrive +// +// Description: +// Function to load the printer from a drive +// Params: +// hRobot Handle to the robot (from EnumRobots) +// hDrive Handle to the drive (from EnumDrives) + +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// +/////////////////////////// +DWORD WINAPI PTRobot_LoadPrinterFromDrive(HANDLE hRobot, HANDLE hDrive); + +/////////////////////////// +// +// PTRobot_UnLoadDrive +// +// Description: +// Function to unload the drive to an output position. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// hDrive Handle to the drive (from EnumDrives) +// dwToLocation DWORD containing the "to" location +// 0 = Auto +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// 100 = Printer +// 200 = Reject +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// PTROBOT_INVALID_LOCATION if the location is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_UnLoadDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwToLocation); + +/////////////////////////// +// +// PTRobot_UnLoadPrinter +// +// Description: +// Function to unload the printer to an output position. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// dwToLocation DWORD containing the "to" location +// 0 = Auto +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// 200 = Reject +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_INVALID_LOCATION if the location is invalid +// +// +/////////////////////////// +DWORD WINAPI PTRobot_UnLoadPrinter(HANDLE hRobot, DWORD dwToLocation); + +/////////////////////////// +// +// PTRobot_MoveDiscBetweenLocations +// +// Description: +// Function to move disc from one bin to another bin +// Params: +// hRobot Handle to the robot (from EnumRobots) +// dwFromLocation DWORD containing the from location +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// dwToLocation DWORD containing the "to" location +// 1 = Bin1 (right-most bin) +// 2 = Bin2 +// ... +// 100 = Printer +// 200 = Reject +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_LOCATION if the location is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_MoveDiscBetweenLocations(HANDLE hRobot, DWORD dwFromLocation, DWORD dwToLocation); + + +/////////////////////////// +// +// PTRobot_SetPrintCopies +// +// Description: +// This function is used for a multiple auto-print job. +// This function is called each time prior to calling one of the print functions +// (e.g. PTRobot_PrintFile() ). The number of copies is set back to 1 after printing +// Not all robots support this feature (PTACT_AUTOPRINTER_MODE specifies support) +// e.g. Bravo 4100 prints mulitple copies faster with this method. +// +// +// Params: +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// +// +/////////////////////////// +DWORD WINAPI PTRobot_SetPrintCopies(HANDLE hRobot, DWORD dwCopies ); + + +/////////////////////////// +// +// PTRobot_PrintFile +// +// Description: +// Function to print a Surething image (.STD), raster image (.JPG, .BMP, .TIF, +// etc.), or .PRN file to the printer. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// tszFile File to print (.STD, .PRN, .JPG, .BMP) +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_PRN_INVALID if the prn file is not valid for the printer +// PTROBOT_PRINTFILE_INVALID if unknown print file +// PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist (or if Merge file not found) +// PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not installed. +// +/////////////////////////// +DWORD WINAPI PTRobot_PrintFile(HANDLE hRobot, TCHAR * tszFile, DWORD dwPrintIndex); + + + +/////////////////////////// +// +// PTRobot_PrintFileWithMerge +// +// Description: +// Function to print a Surething .STD file that has Merge Text/Photos. +// The Merge Text and/or Photos can be specified in a variable number of +// arguments passed into this function. The Surething file should be designed +// with the same number of merge strings passed in here. +// +// Params: +// hRobot Handle to the robot (from EnumRobots) +// tszFile Surething (.STD) File to print. +// dwNumMergeStrings Number of merge strings to follow +// ... Variable number of pointers to TCHAR strings +// These are the merge strings or photo names (including +// path) to be printed. +// NOTE: For the strings that follow dwMergeStrings to +// be used, the user must have �Set Merge File� within the .STD file +// ** Limit each string to 256 characters or less ** +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist +// PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not +// installed. +// PTROBOT_PRINTFILE_INVALID if the filename is not .STD +// +/////////////////////////// +DWORD WINAPI PTRobot_PrintFileWithMerge(HANDLE hRobot, + TCHAR * tszFile, + DWORD dwNumMergeStrings, + ...); + + +/////////////////////////////// +// +// PTRobot_PrintFileWithMerge2 +// +// Description: +// Function to print a Surething .STD file that has Merge Text/Photos. +// The Merge Text and/or Photos MUST be specified BEFORE THIS CALL, by +// calling PTRobot_AddMergeFields(). PTRobot_AddMergeFields() must be called +// once for every Merge field that is designed into the SureThing file. +// Then, this function is called to print the file with the specified Merge data. +// +// Params: +// hRobot Handle to the robot (from EnumRobots) +// tszFile Surething (.STD) File to print. +// fClearMergeList Whether or not to clear the list of merge strings (or photo names) +// that were stored from previous calls to PTRobot_AddMergeFields(). +// If doing mutiple discs with the same merge data then set to FALSE. +// If merge data will be changing for each disc then set to TRUE. +// +// NOTE: For this to work, the user must have �Set Merge File� within the .STD file +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist +// PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not +// installed. +// PTROBOT_PRINTFILE_INVALID if the filename is not .STD +// +////////////////////////////// +DWORD WINAPI PTRobot_PrintFileWithMerge2(HANDLE hRobot, + TCHAR * tszFile, + BOOL fClearMergeList); + + + + +DWORD WINAPI PTRobot_PrintFileWithMergeFile(HANDLE hRobot, + TCHAR * tszFile, + TCHAR * tszMergeFile); + +/////////////////////////// +// +// PTRobot_AddMergeFields +// +// Description: +// This function is used in conjuction with PTRobot_PrintMergeFile2() +// to print a SureThing file with merge/replaceable text fields (or photos). +// DESIGN TIME: +// User first designs a SureThing (.STD) file with replaceable Text and/or +// photos and then sets the Merge file (using Tools/Set Merge File). +// RUN TIME: +// This function is called repeatedly, passing in the text you want printed +// (and/or the name & path of the photo you want printed). +// The number of times this function is called should be equal to the number of +// Merge Fields inserted at design time. +// Then, call PTRobot_PrintFileWithMerge2() to print the SureThing file, using +// the merge fields set with this call. +// +// Params: +// dwAppID Application ID specified by Primera +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// +// +/////////////////////////// +DWORD WINAPI PTRobot_AddMergeFields(HANDLE hRobot, const TCHAR * tszField ); + + + +/////////////////////////// +// +// PTRobot_ClearMergeList +// +// Description: +// Function to clear the List of Merge strings (or photo names) +// that were stored from previous calls to PTRobot_AddMergeFields(). +// This function would be used if doing a print preview of a STD file +// that has merge fields (ie. using PTRobot_GetSureThingPreview() ). +// This function is NOT needed if only printing a SureThing file with merge fields +// because PTRobot_PrintFileWithMerge2() has a flag to clear the merge list after printing. +// So, the use of this function would be like this: +// PTRobot_AddMergeFields() +// PTRobot_AddMergeFields()... +// PTRobot_GetSureThingPreview() +// PTRobot_ClearMergeList() +// +// NOTE: For this to work, the user must have �Set Merge File� within the .STD file + +// Params: +// hRobot Handle to the robot (from EnumRobots) +// Return: +// PTROBOT_OK +// +/////////////////////////// +DWORD WINAPI PTRobot_ClearMergeList( HANDLE hRobot ); + + + +/////////////////////////// +// +// PTRobot_GetSureThingPreview +// +// Description: +// Function to get a preview of a SureThing file +// Params: +// tszSureThingFile The SureThing file to get a preview of +// tszOutputFile The file name (including path) of desired output file +// (NOTE: must have extension of .JPG, .BMP, or .PNG) +// dwResolution Resolution (in DPI) of output file (Valid values: 50-600) +// Notes: +// 1)This function returns immediately, but the output file may take several seconds +// to generate. Caller should keep checking for the output file's existence. +// 2)The output file is NOT deleted. Caller is responsible for deleting, if desired. +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_PRINTFILE_INVALID if fails to generate preview +// PTROBOT_INVALID_EXTENSION if not a valid output file extension (.JPG, .BMP, .PNG) +// +// +/////////////////////////// +DWORD WINAPI PTRobot_GetSureThingPreview(TCHAR * tszSureThingFile, + TCHAR * tszOutputFile, + DWORD dwResolution); + + +/////////////////////////// +// +// PTRobot_SetPrinterSettings +// +// Description: +// Function to set some printer driver settings +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pPrinterSettings points to a PTPrinterSettings structure. +// +// Notes: +// If this function is not called the default print settings will be used. This +// function will change the system default print settings. +// As of Version 1.2.0 the system default print settings will restored after a print +// is sent via PTRobot_PrintFile() or PTRobot_PrintFileWithMerge(). +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_INVALID_PRINTER_SETTINGS if the printer settings are invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_SetPrinterSettings(HANDLE hRobot, PTPrinterSettings *pPrinterSettings); + +/////////////////////////// +// +// PTRobot_GetPrinterSettings +// +// Description: +// Function to get some printer driver settings +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pPrinterSettings points to a PTPrinterSettings structure. +// +// Notes: +// If this function is not called the default print settings will be used. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// +/////////////////////////// +DWORD WINAPI PTRobot_GetPrinterSettings(HANDLE hRobot, PTPrinterSettings *pPrinterSettings); + + +/////////////////////////// +// +// PTRobot_SetPrinterSettings2 +// +// Description: +// Function to set additional printer driver settings +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pPrinterSettings2 points to a PTPrinterSettings2 structure. +// +// Notes: +// If this function is not called the default print settings will be used. This +// function will change the system default print settings. +// As of Version 1.2.0 the system default print settings will restored after a print +// is sent via PTRobot_PrintFile() or PTRobot_PrintFileWithMerge(). +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// PTROBOT_INVALID_PRINTER_SETTINGS if the printer settings are invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_SetPrinterSettings2(HANDLE hRobot, PTPrinterSettings2 *pPrinterSettings2); + +/////////////////////////// +// +// PTRobot_GetPrinterSettings2 +// +// Description: +// Function to get some additional printer driver settings +// Params: +// hRobot Handle to the robot (from EnumRobots) +// pPrinterSettings2 points to a PTPrinterSettings2 structure. +// +// Notes: +// If this function is not called the default print settings will be used. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_NO_PRINTER if the robot doesn't have a printer +// +/////////////////////////// +DWORD WINAPI PTRobot_GetPrinterSettings2(HANDLE hRobot, PTPrinterSettings2 *pPrinterSettings2); + + +/////////////////////////// +// +// PTRobot_KillSystemError +// +// Description: +// Function to kill a system error. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// dwResetPrinter DWORD to notify if the printer should be reset. +// 1 = Reset the printer +// 0 = do not reset the printer +// +// Notes: +// If there is no system error and dwResetPrinter is set to 1 the +// printer will be reset. Otherwise if there is a system error, that error +// will be cleared (if possible) and the printer will be reset if the +// dwResetPrinter is set to 1. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_KillSystemError(HANDLE hRobot, DWORD dwResetPrinter); + + +/////////////////////////// +// +// PTRobot_SystemAction +// +// Description: +// Function to instruct the system to perform a specifc action. +// Params: +// hRobot Handle to the robot (from EnumRobots) +// dwAction Action to perform +// +// Notes: +// This function is used to perform a specific function on a +// robot. The defined actions and their descriptions are detailed +// below. +// +// Action: +// PTACT_ALIGNPRINTER -> Align the Printer (Disc Publisher PRO only) +// Description: +// This will cause an alignment print to occur on the printer and +// this function will return when the alignment is complete. +// +// Action: +// PTACT_IGNOREINKLOW -> Ignore Ink Low (Disc Publisher PRO only) +// Description: +// This will cause an ink low system error to be ignored. +// +// Action: +// PTACT_DISABLEPWRBUTTON -> Disable Power Button +// Description: +// This will disable the power button on Disc Publisher II and PRO. +// +// Action: +// PTACT_REINIT_DRIVES -> Re-initialize drives +// Description: +// PTRobot maintains Registry values for persistent settings including drive +// serial numbers. This action will clear the drive serial numbers stored +// which will force the user to re-identify the robotically controlled drives. +// Action: +// PTACT_IDENTIFY -> Identify a robot +// Description: +// This will cause the robot to do something to visually identify itself +// For example the Bravo units will move their printer tray. +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_ROBOT if the robot handle is invalid +// PTROBOT_INVALID_ACTION if the robot action is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_SystemAction(HANDLE hRobot, DWORD dwAction); + +/////////////////////////// +// +// PTRobot_OpenCloseDrive +// +// Description: +// Function to open or close a drive +// Params: +// hDrive Handle to the drive (from EnumDrives) +// dwOpen See (Drive Open/Close) section above +// (DRIVE_OPEN=0 DRIVE_CLOSE=1) +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_SEQUENCE if this command is called out of sequence +// PTROBOT_INTERNAL if an internal error occurred +// PTROBOT_INVALID_DRIVE if the drive handle is invalid +// +/////////////////////////// +DWORD WINAPI PTRobot_OpenCloseDrive(HANDLE hDrive, DWORD dwOpen ); + +/////////////////////////// +// +// PTRobot_GetErrorString +// +// Description: +// Function to get the error string for a specific system +// error or PTRobot API Return error. +// +// Params: +// hRobot Robot that the error is on. +// dwErrorNum System Error Number +// pwszErrorString Error string returned +// (Note wide characters. Calling application must +// allocate this memory). +// dwMaxLength Length of buffer pointed to by pwszErrorString +// (number of wide characters) +// dwLanguage Language of string to return (See "Languages" +// definitions above) +// +// Notes: +// dwErrorNum can be either dwSystemError from PTRobotStatus structure (which is +// returned by PTRobot_GetRobotStatus()) or dwErrorNum can be an error returned +// from a PTRobot_xxxxx call (e.g. PTROBOT_INVALID_ROBOT). +// +// +// Return: +// PTROBOT_OK if Successful +// PTROBOT_INVALID_LANG if language is invalid +// PTROBOT_INVALID_ERROR if error is invalid +// PTROBOT_INTERNAL if buffer is undersized, etc. +// +/////////////////////////// +DWORD WINAPI PTRobot_GetErrorString(HANDLE hRobot, + DWORD dwErrorNum, + WCHAR * pwszErrorString, + DWORD dwMaxLength, + DWORD dwLanguage); + +/////////////////////////// +// +// PTRobot_GetMediaInfo +// +// Description: +// This function will get information on the media that +// is loaded in the drive. +// Params: +// hDrive Handle to the drive (from EnumDrives) +// PTMediaInfo * Media info +// +// Notes: +// Return: +// PTROBOT_OK if successful and media is found and the media is valid. +// PTROBOT_INVALID_MEDIA if the media is not valid +// PTROBOT_NO_MEDIA if no media is found +// PTROBOT_INVALID_DRIVE if the drive is not valid +// PTROBOT_INTERNAL some other error +// +/////////////////////////// +DWORD WINAPI PTRobot_GetMediaInfo(HANDLE hDrive, PTMediaInfo * pDiscInfo ); + +/////////////////////////// +// +// PTRobot_SetApplicationID +// +// Description: +// Function to set the Application ID. +// This value is assigned for each application by Primera as needed. +// Only applications that require special functionality will require this. +// (note most applications will not need this). +// +// Params: +// dwAppID Application ID specified by Primera +// +// Notes: +// Return: +// PTROBOT_OK if Successful +// PTROBOT_INTERNAL if an internal error occurred +// +/////////////////////////// +DWORD WINAPI PTRobot_SetApplicationID( DWORD dwAppID ); + +DWORD WINAPI PTRobot_SetRoboticDriveWithoutEnum(HANDLE hRobot, HANDLE hDrive, TCHAR *tszSerial, DWORD dwColIndex, + DWORD dwRowIndex, BOOL fProgramFlash); + +DWORD WINAPI PTRobot_GetDriveSerialFromFlash(HANDLE hRobot, DWORD dwColIndex, + DWORD dwRowIndex, TCHAR * tszSerial); + +//----------------------------------------------------------------- +// end of PTRobot API Prototypes +//----------------------------------------------------------------- + + + +/***************************************************************************** + +PTRobot Usage: + + Below is PSUEDO-CODE for how a calling application should use PTRobot to + implement robotics into its application. + + PTRobot_Initialize + + PTRobot_EnumRobots + - if the number of robots is greater than 1 then the calling application will + need to provide some logic/ui to determine which robot to use. The app + can use PTRobot_GetRobotInfo to get details about each robot. + PTRobot_EnumDrives or PTRobot_EnumDrivesWithList + - This will cause PTRobot to determine which drives are robotically controlled + by enumerating the drives themselves (PTRobot_EnumDrives) or based off a + list of drives passed in (PTRobot_EnumDrivesWithList) + PTRobot_GetDriveInfo for all drives returned + - This will allow the calling app to know which drive is which + PTRobot_LoadDrive(Robot, Drive, TRUE) + - This will load a disc into the drive from the input bin + (should set parameter 3 to TRUE if first round of the job) + PTRobot_GetRobotStatus + - This would be called in a loop until dwSystemState is set to SYSSTATE_IDLE + or SYSSTATE_ERROR. + + .. Client application will perform operations on the disc in the drive. + + if the operations are successful + PTRobot_LoadPrinterFromDrive(Robo, Drive) + PTRobot_GetRobotStatus -See Above- + PTRobot_PrintFile(szPrintFile) or PTRobot_PrintFileWithMerge(...) + PTRobot_GetRobotStatus -See Above- + PTRobot_UnloadPrinter(Robot, 0) + PTRobot_GetRobotStatus -See Above- + else + PTRobot_UnloadDrive(Robot, Drive, 100) + PTRobot_GetRobotStatus -See Above- + + PTRobot_Destroy + + +***/ + + +#ifdef __cplusplus +} +#endif diff --git a/Project1/PTRobot.lib b/Project1/PTRobot.lib new file mode 100644 index 0000000..4f41492 Binary files /dev/null and b/Project1/PTRobot.lib differ diff --git a/Project1/PTRobot4100.dll b/Project1/PTRobot4100.dll new file mode 100644 index 0000000..ed62c2d Binary files /dev/null and b/Project1/PTRobot4100.dll differ diff --git a/Project1/PTRobot4200.dll b/Project1/PTRobot4200.dll new file mode 100644 index 0000000..ea3416e Binary files /dev/null and b/Project1/PTRobot4200.dll differ diff --git a/Project1/PTRobotApp.exe b/Project1/PTRobotApp.exe new file mode 100644 index 0000000..24d7d05 Binary files /dev/null and b/Project1/PTRobotApp.exe differ diff --git a/Project1/PTRobotDP.dll b/Project1/PTRobotDP.dll new file mode 100644 index 0000000..82b7c87 Binary files /dev/null and b/Project1/PTRobotDP.dll differ diff --git a/Project1/PTRobotDPPRO.dll b/Project1/PTRobotDPPRO.dll new file mode 100644 index 0000000..31f173d Binary files /dev/null and b/Project1/PTRobotDPPRO.dll differ diff --git a/Project1/PTRobotDPse.dll b/Project1/PTRobotDPse.dll new file mode 100644 index 0000000..3e2bcec Binary files /dev/null and b/Project1/PTRobotDPse.dll differ diff --git a/Project1/PTRobotDPse3.dll b/Project1/PTRobotDPse3.dll new file mode 100644 index 0000000..c5159c1 Binary files /dev/null and b/Project1/PTRobotDPse3.dll differ diff --git a/Project1/PTRobotStr.dll b/Project1/PTRobotStr.dll new file mode 100644 index 0000000..f1d477e Binary files /dev/null and b/Project1/PTRobotStr.dll differ diff --git a/Project1/Project1.vcxproj b/Project1/Project1.vcxproj new file mode 100644 index 0000000..a494ae0 --- /dev/null +++ b/Project1/Project1.vcxproj @@ -0,0 +1,164 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {261558be-3639-413c-8c33-8adbb775d19e} + Project1 + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Project1/Project1.vcxproj.filters b/Project1/Project1.vcxproj.filters new file mode 100644 index 0000000..071c3dd --- /dev/null +++ b/Project1/Project1.vcxproj.filters @@ -0,0 +1,61 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Header Files + + + + + Header Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/Project1/Project1.vcxproj.user b/Project1/Project1.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/Project1/Project1.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Project1/Source.cpp b/Project1/Source.cpp new file mode 100644 index 0000000..7c3e7b0 --- /dev/null +++ b/Project1/Source.cpp @@ -0,0 +1,79 @@ +#include +#include +#include "PTRobot.h" + +int main() { + printf("Hello, world!\n"); + + printf("Initializing\n"); + int res = PTRobot_Initialize(); + if (res) { + printf("Failed with error: %i\n", res); + } + else { + printf("Init OK!\n"); + } + + // Enumerate robots + printf("Enumerating robots\n"); + HANDLE phRobots[256]; + DWORD handles = 256; // Set to the size of the array + + DWORD result = PTRobot_EnumRobots(phRobots, &handles); // Pass the address of handles + + bool ded = true; + if (result == PTROBOT_OK) { + printf("Successfully enumerated %lu robots.\n", handles); + // You can now use phRobots array which contains the handles to the robots + ded = false; + } + else if (result == PTROBOT_INVALID_ROBOT) { + printf("No robots found.\n"); + } + else if (result == PTROBOT_SEQUENCE) { + printf("Command called out of sequence.\n"); + } + else if (result == PTROBOT_INTERNAL) { + printf("An internal error occurred.\n"); + } + else if (result == PTROBOT_OVERFLOW) { + printf("Number of robots found exceeds the provided array size.\n"); + } + else { + printf("Unknown error occurred.\n"); + } + if (ded) { return 1; } + + // Get status + PTRobotStatus status; + result = PTRobot_GetRobotStatus(phRobots[0], &status); + if (result == PTROBOT_OK) { + printf("Successfully enumerated %lu robots.\n", handles); + // You can now use phRobots array which contains the handles to the robots + } + else { + printf("ERROR: %u", result); + return 1; + } + printf("State: %u", status.dwSystemState); + printf("Error: %u", status.dwSystemError); + + // Enumerate drives + HANDLE phDrives[256]; + DWORD numDrives = 256; + result = PTRobot_EnumDrives(phRobots[0], phDrives, &numDrives); + + if (result) { + printf("Failed to enumerate drives with error %u", result); + return 1; + } + else { + printf("Found %u drives", numDrives); + } + + // Load drive + result = PTRobot_LoadDrive(phRobots[0], phDrives[0], 1, CLEARDRIVE_NO); + printf("Load drive: %u", result); + + return 0; +} \ No newline at end of file