phidget22 1.21.20241123__tar.gz

phidget22-1.21.20241123/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: phidget22
+Version: 1.21.20241123
+Summary: Phidget22 Python wrapper library
+Home-page: http://www.phidgets.com
+Author: Phidgets Inc
+Author-email: support@phidgets.com
+License: MIT
+Description: # Phidget22
+        
+        [![Python version (Phidget22)](https://img.shields.io/pypi/v/Phidget22.svg?style=flat-square)](https://pypi.org/project/Phidget22/)
+        
+        **Phidget22** is the official Python library for working with Phidgets in Python applications. It provides lightweight bindings to the native phidget22 library.
+        
+        
+        ## Installation
+        
+        ### pip Package
+        The library is available as a pip package and includes the phidget22 native library for **Windows**, **Linux**, and **macOS**. For other operating systems, the native library must be installed separately.
+        
+        ### macOS Notes
+        - **HID USB Phidgets** require the installation of macOS libraries or the Standalone Control Panel ([Download Here](https://www.phidgets.com/docs/OS_-_macOS)).
+          - HID USB Phidgets are listed as `'HID'` in the USB Stack field on their product page specifications tab at [www.phidgets.com](https://www.phidgets.com).
+        - **PHIDUSB, VINT Phidgets**: Newer USB Phidgets and VINT Phidgets do not require a separate install.
+        
+        
+        ## Resources
+        
+        - [Python Language Page](https://www.phidgets.com/docs/Language_-_Python)
+        - [Python API Reference](https://www.phidgets.com/?view=api&lang=Python)
+        - [Python Code Samples](https://www.phidgets.com/?view=code_samples&lang=Python)
+        
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown

phidget22-1.21.20241123/Phidget22/Async.py

@@ -0,0 +1,48 @@
+import sys
+import ctypes
+from Phidget22.PhidgetSupport import PhidgetSupport
+
+class AsyncSupport:
+	__callbacks = {}
+	__nativecallback = None
+
+	@staticmethod
+	def add(entry, phid):
+		t = (entry, phid);
+		AsyncSupport.__callbacks[id(t)] = t
+		return id(t)
+
+	@staticmethod
+	def __getAndRemove(id):
+		entry = AsyncSupport.__callbacks.get(id)
+		del AsyncSupport.__callbacks[id]
+		return entry
+
+	@staticmethod
+	def __async_callback(handle, ctx, res):
+
+		if ctx == None:
+			return
+
+		# look up callback
+		entry = AsyncSupport.__getAndRemove(ctx)
+		if entry == None:
+			return
+
+		details = ""
+		_code = ctypes.c_int(res)
+		_desc = ctypes.c_char_p()
+		result = PhidgetSupport.getDll().Phidget_getErrorDescription(_code, ctypes.byref(_desc))
+		if result == 0:
+			details = _desc.value.decode("utf-8")
+
+		entry[0](entry[1], res, details)
+
+	@staticmethod
+	def getCallback():
+		if AsyncSupport.__nativecallback is None:
+			if sys.platform == 'win32':
+				AsyncSupport.__nativecallback = ctypes.WINFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int)(AsyncSupport.__async_callback)
+			else:
+				AsyncSupport.__nativecallback = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int)(AsyncSupport.__async_callback)
+		return AsyncSupport.__nativecallback

phidget22-1.21.20241123/Phidget22/BridgeGain.py

@@ -0,0 +1,39 @@
+import sys
+import ctypes
+class BridgeGain:
+	# 1x Amplificaion
+	BRIDGE_GAIN_1 = 1
+	# 2x Amplification
+	BRIDGE_GAIN_2 = 2
+	# 4x Amplification
+	BRIDGE_GAIN_4 = 3
+	# 8x Amplification
+	BRIDGE_GAIN_8 = 4
+	# 16x Amplification
+	BRIDGE_GAIN_16 = 5
+	# 32x Amplification
+	BRIDGE_GAIN_32 = 6
+	# 64x Amplification
+	BRIDGE_GAIN_64 = 7
+	# 128x Amplification
+	BRIDGE_GAIN_128 = 8
+
+	@classmethod
+	def getName(self, val):
+		if val == self.BRIDGE_GAIN_1:
+			return "BRIDGE_GAIN_1"
+		if val == self.BRIDGE_GAIN_2:
+			return "BRIDGE_GAIN_2"
+		if val == self.BRIDGE_GAIN_4:
+			return "BRIDGE_GAIN_4"
+		if val == self.BRIDGE_GAIN_8:
+			return "BRIDGE_GAIN_8"
+		if val == self.BRIDGE_GAIN_16:
+			return "BRIDGE_GAIN_16"
+		if val == self.BRIDGE_GAIN_32:
+			return "BRIDGE_GAIN_32"
+		if val == self.BRIDGE_GAIN_64:
+			return "BRIDGE_GAIN_64"
+		if val == self.BRIDGE_GAIN_128:
+			return "BRIDGE_GAIN_128"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/ChannelClass.py

@@ -0,0 +1,143 @@
+import sys
+import ctypes
+class ChannelClass:
+	# Accelerometer channel
+	PHIDCHCLASS_ACCELEROMETER = 1
+	# BLDC motor channel
+	PHIDCHCLASS_BLDCMOTOR = 35
+	# Capacitive Touch channel
+	PHIDCHCLASS_CAPACITIVETOUCH = 14
+	# Current input channel
+	PHIDCHCLASS_CURRENTINPUT = 2
+	# DC motor channel
+	PHIDCHCLASS_DCMOTOR = 4
+	# Dictionary
+	PHIDCHCLASS_DICTIONARY = 36
+	# Digital input channel
+	PHIDCHCLASS_DIGITALINPUT = 5
+	# Digital output channel
+	PHIDCHCLASS_DIGITALOUTPUT = 6
+	# Distance sensor channel
+	PHIDCHCLASS_DISTANCESENSOR = 7
+	# Encoder channel
+	PHIDCHCLASS_ENCODER = 8
+	# Frequency counter channel
+	PHIDCHCLASS_FREQUENCYCOUNTER = 9
+	# GPS channel
+	PHIDCHCLASS_GPS = 10
+	# Gyroscope channel
+	PHIDCHCLASS_GYROSCOPE = 12
+	# VINT Hub channel
+	PHIDCHCLASS_HUB = 13
+	# Humidity sensor channel
+	PHIDCHCLASS_HUMIDITYSENSOR = 15
+	# IR channel
+	PHIDCHCLASS_IR = 16
+	# LCD channel
+	PHIDCHCLASS_LCD = 11
+	# Light sensor channel
+	PHIDCHCLASS_LIGHTSENSOR = 17
+	# Magnetometer channel
+	PHIDCHCLASS_MAGNETOMETER = 18
+	# Motor position control channel.
+	PHIDCHCLASS_MOTORPOSITIONCONTROLLER = 34
+	# Motor velocity control channel.
+	PHIDCHCLASS_MOTORVELOCITYCONTROLLER = 39
+	# pH sensor channel
+	PHIDCHCLASS_PHSENSOR = 37
+	# Power guard channel
+	PHIDCHCLASS_POWERGUARD = 20
+	# Pressure sensor channel
+	PHIDCHCLASS_PRESSURESENSOR = 21
+	# RC Servo channel
+	PHIDCHCLASS_RCSERVO = 22
+	# Resistance input channel
+	PHIDCHCLASS_RESISTANCEINPUT = 23
+	# RFID channel
+	PHIDCHCLASS_RFID = 24
+	# Sound sensor channel
+	PHIDCHCLASS_SOUNDSENSOR = 25
+	# Spatial channel
+	PHIDCHCLASS_SPATIAL = 26
+	# Stepper channel
+	PHIDCHCLASS_STEPPER = 27
+	# Temperature sensor channel
+	PHIDCHCLASS_TEMPERATURESENSOR = 28
+	# Voltage input channel
+	PHIDCHCLASS_VOLTAGEINPUT = 29
+	# Voltage output channel
+	PHIDCHCLASS_VOLTAGEOUTPUT = 30
+	# Voltage ratio input channel
+	PHIDCHCLASS_VOLTAGERATIOINPUT = 31
+
+	@classmethod
+	def getName(self, val):
+		if val == self.PHIDCHCLASS_ACCELEROMETER:
+			return "PHIDCHCLASS_ACCELEROMETER"
+		if val == self.PHIDCHCLASS_BLDCMOTOR:
+			return "PHIDCHCLASS_BLDCMOTOR"
+		if val == self.PHIDCHCLASS_CAPACITIVETOUCH:
+			return "PHIDCHCLASS_CAPACITIVETOUCH"
+		if val == self.PHIDCHCLASS_CURRENTINPUT:
+			return "PHIDCHCLASS_CURRENTINPUT"
+		if val == self.PHIDCHCLASS_DCMOTOR:
+			return "PHIDCHCLASS_DCMOTOR"
+		if val == self.PHIDCHCLASS_DICTIONARY:
+			return "PHIDCHCLASS_DICTIONARY"
+		if val == self.PHIDCHCLASS_DIGITALINPUT:
+			return "PHIDCHCLASS_DIGITALINPUT"
+		if val == self.PHIDCHCLASS_DIGITALOUTPUT:
+			return "PHIDCHCLASS_DIGITALOUTPUT"
+		if val == self.PHIDCHCLASS_DISTANCESENSOR:
+			return "PHIDCHCLASS_DISTANCESENSOR"
+		if val == self.PHIDCHCLASS_ENCODER:
+			return "PHIDCHCLASS_ENCODER"
+		if val == self.PHIDCHCLASS_FREQUENCYCOUNTER:
+			return "PHIDCHCLASS_FREQUENCYCOUNTER"
+		if val == self.PHIDCHCLASS_GPS:
+			return "PHIDCHCLASS_GPS"
+		if val == self.PHIDCHCLASS_GYROSCOPE:
+			return "PHIDCHCLASS_GYROSCOPE"
+		if val == self.PHIDCHCLASS_HUB:
+			return "PHIDCHCLASS_HUB"
+		if val == self.PHIDCHCLASS_HUMIDITYSENSOR:
+			return "PHIDCHCLASS_HUMIDITYSENSOR"
+		if val == self.PHIDCHCLASS_IR:
+			return "PHIDCHCLASS_IR"
+		if val == self.PHIDCHCLASS_LCD:
+			return "PHIDCHCLASS_LCD"
+		if val == self.PHIDCHCLASS_LIGHTSENSOR:
+			return "PHIDCHCLASS_LIGHTSENSOR"
+		if val == self.PHIDCHCLASS_MAGNETOMETER:
+			return "PHIDCHCLASS_MAGNETOMETER"
+		if val == self.PHIDCHCLASS_MOTORPOSITIONCONTROLLER:
+			return "PHIDCHCLASS_MOTORPOSITIONCONTROLLER"
+		if val == self.PHIDCHCLASS_MOTORVELOCITYCONTROLLER:
+			return "PHIDCHCLASS_MOTORVELOCITYCONTROLLER"
+		if val == self.PHIDCHCLASS_PHSENSOR:
+			return "PHIDCHCLASS_PHSENSOR"
+		if val == self.PHIDCHCLASS_POWERGUARD:
+			return "PHIDCHCLASS_POWERGUARD"
+		if val == self.PHIDCHCLASS_PRESSURESENSOR:
+			return "PHIDCHCLASS_PRESSURESENSOR"
+		if val == self.PHIDCHCLASS_RCSERVO:
+			return "PHIDCHCLASS_RCSERVO"
+		if val == self.PHIDCHCLASS_RESISTANCEINPUT:
+			return "PHIDCHCLASS_RESISTANCEINPUT"
+		if val == self.PHIDCHCLASS_RFID:
+			return "PHIDCHCLASS_RFID"
+		if val == self.PHIDCHCLASS_SOUNDSENSOR:
+			return "PHIDCHCLASS_SOUNDSENSOR"
+		if val == self.PHIDCHCLASS_SPATIAL:
+			return "PHIDCHCLASS_SPATIAL"
+		if val == self.PHIDCHCLASS_STEPPER:
+			return "PHIDCHCLASS_STEPPER"
+		if val == self.PHIDCHCLASS_TEMPERATURESENSOR:
+			return "PHIDCHCLASS_TEMPERATURESENSOR"
+		if val == self.PHIDCHCLASS_VOLTAGEINPUT:
+			return "PHIDCHCLASS_VOLTAGEINPUT"
+		if val == self.PHIDCHCLASS_VOLTAGEOUTPUT:
+			return "PHIDCHCLASS_VOLTAGEOUTPUT"
+		if val == self.PHIDCHCLASS_VOLTAGERATIOINPUT:
+			return "PHIDCHCLASS_VOLTAGERATIOINPUT"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/ChannelSubclass.py

@@ -0,0 +1,59 @@
+import sys
+import ctypes
+class ChannelSubclass:
+	# No subclass
+	PHIDCHSUBCLASS_NONE = 1
+	# Digital output duty cycle
+	PHIDCHSUBCLASS_DIGITALOUTPUT_DUTY_CYCLE = 16
+	# Digital output frequency
+	PHIDCHSUBCLASS_DIGITALOUTPUT_FREQUENCY = 18
+	# Digital output LED driver
+	PHIDCHSUBCLASS_DIGITALOUTPUT_LED_DRIVER = 17
+	# Encoder IO mode settable
+	PHIDCHSUBCLASS_ENCODER_MODE_SETTABLE = 96
+	# Graphic LCD
+	PHIDCHSUBCLASS_LCD_GRAPHIC = 80
+	# Text LCD
+	PHIDCHSUBCLASS_LCD_TEXT = 81
+	# Spatial AHRS/IMU
+	PHIDCHSUBCLASS_SPATIAL_AHRS = 112
+	# Temperature sensor RTD
+	PHIDCHSUBCLASS_TEMPERATURESENSOR_RTD = 32
+	# Temperature sensor thermocouple
+	PHIDCHSUBCLASS_TEMPERATURESENSOR_THERMOCOUPLE = 33
+	# Voltage sensor port
+	PHIDCHSUBCLASS_VOLTAGEINPUT_SENSOR_PORT = 48
+	# Voltage ratio bridge input
+	PHIDCHSUBCLASS_VOLTAGERATIOINPUT_BRIDGE = 65
+	# Voltage ratio sensor port
+	PHIDCHSUBCLASS_VOLTAGERATIOINPUT_SENSOR_PORT = 64
+
+	@classmethod
+	def getName(self, val):
+		if val == self.PHIDCHSUBCLASS_NONE:
+			return "PHIDCHSUBCLASS_NONE"
+		if val == self.PHIDCHSUBCLASS_DIGITALOUTPUT_DUTY_CYCLE:
+			return "PHIDCHSUBCLASS_DIGITALOUTPUT_DUTY_CYCLE"
+		if val == self.PHIDCHSUBCLASS_DIGITALOUTPUT_FREQUENCY:
+			return "PHIDCHSUBCLASS_DIGITALOUTPUT_FREQUENCY"
+		if val == self.PHIDCHSUBCLASS_DIGITALOUTPUT_LED_DRIVER:
+			return "PHIDCHSUBCLASS_DIGITALOUTPUT_LED_DRIVER"
+		if val == self.PHIDCHSUBCLASS_ENCODER_MODE_SETTABLE:
+			return "PHIDCHSUBCLASS_ENCODER_MODE_SETTABLE"
+		if val == self.PHIDCHSUBCLASS_LCD_GRAPHIC:
+			return "PHIDCHSUBCLASS_LCD_GRAPHIC"
+		if val == self.PHIDCHSUBCLASS_LCD_TEXT:
+			return "PHIDCHSUBCLASS_LCD_TEXT"
+		if val == self.PHIDCHSUBCLASS_SPATIAL_AHRS:
+			return "PHIDCHSUBCLASS_SPATIAL_AHRS"
+		if val == self.PHIDCHSUBCLASS_TEMPERATURESENSOR_RTD:
+			return "PHIDCHSUBCLASS_TEMPERATURESENSOR_RTD"
+		if val == self.PHIDCHSUBCLASS_TEMPERATURESENSOR_THERMOCOUPLE:
+			return "PHIDCHSUBCLASS_TEMPERATURESENSOR_THERMOCOUPLE"
+		if val == self.PHIDCHSUBCLASS_VOLTAGEINPUT_SENSOR_PORT:
+			return "PHIDCHSUBCLASS_VOLTAGEINPUT_SENSOR_PORT"
+		if val == self.PHIDCHSUBCLASS_VOLTAGERATIOINPUT_BRIDGE:
+			return "PHIDCHSUBCLASS_VOLTAGERATIOINPUT_BRIDGE"
+		if val == self.PHIDCHSUBCLASS_VOLTAGERATIOINPUT_SENSOR_PORT:
+			return "PHIDCHSUBCLASS_VOLTAGERATIOINPUT_SENSOR_PORT"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/CodeInfo.py

@@ -0,0 +1,125 @@
+import sys
+import ctypes
+
+from Phidget22.IRCodeEncoding import IRCodeEncoding
+from Phidget22.IRCodeLength import IRCodeLength
+
+class CodeInfo(ctypes.Structure):
+	_fields_ = [
+		("_bitCount", ctypes.c_uint32),
+		("_encoding", ctypes.c_int),
+		("_length", ctypes.c_int),
+		("_gap", ctypes.c_uint32),
+		("_trail", ctypes.c_uint32),
+		("_header", ctypes.c_uint32 * 2),
+		("_one", ctypes.c_uint32 * 2),
+		("_zero", ctypes.c_uint32 * 2),
+		("_repeat", ctypes.c_uint32 * 26),
+		("_minRepeat", ctypes.c_uint32),
+		("_dutyCycle", ctypes.c_double),
+		("_carrierFrequency", ctypes.c_uint32),
+		("_toggleMask", ctypes.c_char * 33),
+	]
+
+	def __init__(self):
+		self.bitCount = 0
+		self.encoding = 0
+		self.length = 0
+		self.gap = 0
+		self.trail = 0
+		self.header = [0] * 2
+		self.one = [0] * 2
+		self.zero = [0] * 2
+		self.repeat = [0] * 26
+		self.minRepeat = 0
+		self.dutyCycle = 0
+		self.carrierFrequency = 0
+		self.toggleMask = ""
+
+	def fromPython(self):
+		self._bitCount = self.bitCount
+		self._encoding = self.encoding
+		self._length = self.length
+		self._gap = self.gap
+		self._trail = self.trail
+		self._header = (ctypes.c_uint32 * 2)(*self.header)
+		self._one = (ctypes.c_uint32 * 2)(*self.one)
+		self._zero = (ctypes.c_uint32 * 2)(*self.zero)
+		self._repeat = (ctypes.c_uint32 * 26)(*self.repeat)
+		self._minRepeat = self.minRepeat
+		self._dutyCycle = self.dutyCycle
+		self._carrierFrequency = self.carrierFrequency
+		self._toggleMask = self.toggleMask.encode('utf-8')
+		return self
+
+	def toPython(self):
+		if self._bitCount == None:
+			self.bitCount = None
+		else:
+			self.bitCount = self._bitCount
+		if self._encoding == None:
+			self.encoding = None
+		else:
+			self.encoding = self._encoding
+		if self._length == None:
+			self.length = None
+		else:
+			self.length = self._length
+		if self._gap == None:
+			self.gap = None
+		else:
+			self.gap = self._gap
+		if self._trail == None:
+			self.trail = None
+		else:
+			self.trail = self._trail
+		if self._header == None:
+			self.header = None
+		else:
+			self.header = self._header
+		if self._one == None:
+			self.one = None
+		else:
+			self.one = self._one
+		if self._zero == None:
+			self.zero = None
+		else:
+			self.zero = self._zero
+		if self._repeat == None:
+			self.repeat = None
+		else:
+			self.repeat = self._repeat
+		if self._minRepeat == None:
+			self.minRepeat = None
+		else:
+			self.minRepeat = self._minRepeat
+		if self._dutyCycle == None:
+			self.dutyCycle = None
+		else:
+			self.dutyCycle = self._dutyCycle
+		if self._carrierFrequency == None:
+			self.carrierFrequency = None
+		else:
+			self.carrierFrequency = self._carrierFrequency
+		if self._toggleMask == None:
+			self.toggleMask = None
+		else:
+			self.toggleMask = self._toggleMask.decode('utf-8')
+		return self
+
+	def __str__(self):
+		return ("[CodeInfo] ("
+			"bitCount: " + str(self.bitCount) + ", "
+			"encoding: " + str(self.encoding) + ", "
+			"length: " + str(self.length) + ", "
+			"gap: " + str(self.gap) + ", "
+			"trail: " + str(self.trail) + ", "
+			"header: " + str(self.header) + ", "
+			"one: " + str(self.one) + ", "
+			"zero: " + str(self.zero) + ", "
+			"repeat: " + str(self.repeat) + ", "
+			"minRepeat: " + str(self.minRepeat) + ", "
+			"dutyCycle: " + str(self.dutyCycle) + ", "
+			"carrierFrequency: " + str(self.carrierFrequency) + ", "
+			"toggleMask: " + str(self.toggleMask) + 
+			")")

phidget22-1.21.20241123/Phidget22/ControlMode.py

@@ -0,0 +1,15 @@
+import sys
+import ctypes
+class ControlMode:
+	# Control the motor by setting a target position.
+	CONTROL_MODE_STEP = 0
+	# Control the motor by selecting a target velocity (sign indicates direction). The motor will rotate continuously in the chosen direction.
+	CONTROL_MODE_RUN = 1
+
+	@classmethod
+	def getName(self, val):
+		if val == self.CONTROL_MODE_STEP:
+			return "CONTROL_MODE_STEP"
+		if val == self.CONTROL_MODE_RUN:
+			return "CONTROL_MODE_RUN"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterEndianness.py

@@ -0,0 +1,15 @@
+import sys
+import ctypes
+class DataAdapterEndianness:
+	# MSB First
+	ENDIANNESS_MSB_FIRST = 1
+	# LSB First
+	ENDIANNESS_LSB_FIRST = 2
+
+	@classmethod
+	def getName(self, val):
+		if val == self.ENDIANNESS_MSB_FIRST:
+			return "ENDIANNESS_MSB_FIRST"
+		if val == self.ENDIANNESS_LSB_FIRST:
+			return "ENDIANNESS_LSB_FIRST"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterHandshakeMode.py

@@ -0,0 +1,19 @@
+import sys
+import ctypes
+class DataAdapterHandshakeMode:
+	# RTS is never set, and CTS is ignored.
+	HANDSHAKE_MODE_NONE = 1
+	# RTS Pin requests to transmit data. CTS input confirms we can send data.
+	HANDSHAKE_MODE_REQUEST_TO_SEND = 2
+	# RTS signals this device can receive data. CTS confirms we can send data.
+	HANDSHAKE_MODE_READY_TO_RECEIVE = 3
+
+	@classmethod
+	def getName(self, val):
+		if val == self.HANDSHAKE_MODE_NONE:
+			return "HANDSHAKE_MODE_NONE"
+		if val == self.HANDSHAKE_MODE_REQUEST_TO_SEND:
+			return "HANDSHAKE_MODE_REQUEST_TO_SEND"
+		if val == self.HANDSHAKE_MODE_READY_TO_RECEIVE:
+			return "HANDSHAKE_MODE_READY_TO_RECEIVE"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterParity.py

@@ -0,0 +1,19 @@
+import sys
+import ctypes
+class DataAdapterParity:
+	# No Parity Bit
+	PARITY_MODE_NONE = 1
+	# Even Parity
+	PARITY_MODE_EVEN = 2
+	# Odd Parity
+	PARITY_MODE_ODD = 3
+
+	@classmethod
+	def getName(self, val):
+		if val == self.PARITY_MODE_NONE:
+			return "PARITY_MODE_NONE"
+		if val == self.PARITY_MODE_EVEN:
+			return "PARITY_MODE_EVEN"
+		if val == self.PARITY_MODE_ODD:
+			return "PARITY_MODE_ODD"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterProtocol.py

@@ -0,0 +1,27 @@
+import sys
+import ctypes
+class DataAdapterProtocol:
+	# Basic half-duplex RS485. Always receiving until you send data.
+	PROTOCOL_RS485 = 1
+	# Uses full-duplex RS422 communication.
+	PROTOCOL_RS422 = 2
+	# Allows communication with DMX512-compatible devices, such as stage lighting
+	PROTOCOL_DMX512 = 3
+	# Allows communication with MODBUS RTU compatible devices
+	PROTOCOL_MODBUS_RTU = 4
+	# Allows communication with RS232 compatible devices
+	PROTOCOL_RS232 = 8
+
+	@classmethod
+	def getName(self, val):
+		if val == self.PROTOCOL_RS485:
+			return "PROTOCOL_RS485"
+		if val == self.PROTOCOL_RS422:
+			return "PROTOCOL_RS422"
+		if val == self.PROTOCOL_DMX512:
+			return "PROTOCOL_DMX512"
+		if val == self.PROTOCOL_MODBUS_RTU:
+			return "PROTOCOL_MODBUS_RTU"
+		if val == self.PROTOCOL_RS232:
+			return "PROTOCOL_RS232"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterSPIChipSelect.py

@@ -0,0 +1,23 @@
+import sys
+import ctypes
+class DataAdapterSPIChipSelect:
+	# CS normally HIGH, Automatically goes LOW during transmission
+	SPI_CHIP_SELECT_ACTIVE_LOW = 1
+	# CS normally LOW, Automatically goes HIGH during transmission
+	SPI_CHIP_SELECT_ACTIVE_HIGH = 2
+	# CS is held LOW as long as this is set
+	SPI_CHIP_SELECT_LOW = 3
+	# CS is held HIGH as long as this is set
+	SPI_CHIP_SELECT_HIGH = 4
+
+	@classmethod
+	def getName(self, val):
+		if val == self.SPI_CHIP_SELECT_ACTIVE_LOW:
+			return "SPI_CHIP_SELECT_ACTIVE_LOW"
+		if val == self.SPI_CHIP_SELECT_ACTIVE_HIGH:
+			return "SPI_CHIP_SELECT_ACTIVE_HIGH"
+		if val == self.SPI_CHIP_SELECT_LOW:
+			return "SPI_CHIP_SELECT_LOW"
+		if val == self.SPI_CHIP_SELECT_HIGH:
+			return "SPI_CHIP_SELECT_HIGH"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterSPIMode.py

@@ -0,0 +1,23 @@
+import sys
+import ctypes
+class DataAdapterSPIMode:
+	# CPOL = 0 CPHA = 0
+	SPI_MODE_0 = 1
+	# CPOL = 0 CPHA = 1
+	SPI_MODE_1 = 2
+	# CPOL = 1 CPHA = 0
+	SPI_MODE_2 = 3
+	# CPOL = 1 CPHA = 1
+	SPI_MODE_3 = 4
+
+	@classmethod
+	def getName(self, val):
+		if val == self.SPI_MODE_0:
+			return "SPI_MODE_0"
+		if val == self.SPI_MODE_1:
+			return "SPI_MODE_1"
+		if val == self.SPI_MODE_2:
+			return "SPI_MODE_2"
+		if val == self.SPI_MODE_3:
+			return "SPI_MODE_3"
+		return "<invalid enumeration value>"

phidget22-1.21.20241123/Phidget22/DataAdapterStopBits.py

@@ -0,0 +1,15 @@
+import sys
+import ctypes
+class DataAdapterStopBits:
+	# One Stop Bit
+	STOP_BITS_ONE = 1
+	# Two Stop Bits
+	STOP_BITS_TWO = 2
+
+	@classmethod
+	def getName(self, val):
+		if val == self.STOP_BITS_ONE:
+			return "STOP_BITS_ONE"
+		if val == self.STOP_BITS_TWO:
+			return "STOP_BITS_TWO"
+		return "<invalid enumeration value>"