Phidgets Support - Recent changes [en]

Terms and Conditions

Lmpacent — Fri, 01 May 2026 17:15:56 GMT

Payment Terms

@@ Line 120: / Line 120: @@
 |style="background: #f0f0f0" align=left|Wire transfers are only accepted for orders over $200.00 USD (excluding shipping charges). There is a $25.00 USD charge for wire transfers under $500.00 USD. Any fees charged by the sending bank are your responsibility.<br />Please make sure that the amount sent to us covers both our invoice and your bank fees.  Products are not shipped until the money is deposited in our bank account.  We recommend that you e-mail orders@phidgets.com with the amount of the transfer and the invoice you are paying.  <br />Any order for which payment is not received within 15 days, will be canceled.
 |}
 ==Security and Privacy==

OS - macOS

Lmpacent — Tue, 21 Apr 2026 15:12:15 GMT

Quick Downloads

← Older revision		Revision as of 15:12, 21 April 2026
Line 4:		Line 4:
	==Quick Downloads==		==Quick Downloads==
	Our libraries support macOS 10.11 and newer.		Our libraries support macOS 10.11 and newer.
	* [https://cdn.phidgets.com/downloads/phidget22/tools/macos/Phidget22ControlPanel.dmg Phidget22 Control Panel (macOS 10.15 and newer)]		* [https://cdn.phidgets.com/downloads/phidget22/tools/macos/Phidget22ControlPanel.dmg Phidget22 Control Panel (for macOS 10.15 and newer)]
	* [https://cdn.phidgets.com/downloads/phidget22/libraries/macos/Phidget22.dmg Phidget22 Installer (macOS 10.14 and earlier)]		* [https://cdn.phidgets.com/downloads/phidget22/libraries/macos/Phidget22.dmg Phidget22 Installer (for macOS 10.14 and earlier)]

	===Other Resources===		===Other Resources===

Language - Swift

Mparadis — Mon, 20 Apr 2026 16:09:34 GMT

Swift Libraries

← Older revision		Revision as of 16:09, 20 April 2026
Line 6:		Line 6:

	== Swift Libraries ==		== Swift Libraries ==
	If you've installed the Phidget drivers for [[OS - macOS\|macOS]] or [[OS - iOS\|iOS]], then you already have the files you need for your project.		If you've installed the Phidget drivers for [[OS - macOS\|macOS]] or [[OS - iOS\|iOS]], then you already have the files you need for your project.

			====macOS Considerations====
			Legacy Phidgets running a HID USB stack require a driver extension (macOS 10.15 and newer) or a kernel extension (macOS 10.14 and earlier). During development, we recommend downloading the appropriate [https://www.phidgets.com/docs/OS_-_macOS#Quick_Downloads package] which will install the extension. When deploying applications, review the README in the [https://cdn.phidgets.com/downloads/phidget22/libraries/macos/Phidget22_macosdevel.zip macOS Development Files] for information about bundling the extension with your application.

			=====Determining USB Stack=====
			To determine which USB stack your device is running, navigate to the product page and then to the specification tab, and look for the ''USB Stack'' specification. If you are using a VINT device, navigate to the product page for the VINT Hub you are using.

			[[Image:Javascript_networkserver_webusb_spec.png\|center\|600px\|link=https://cdn.phidgets.com/docs/images/8/80/Javascript_networkserver_webusb_spec.png]]

	== Example Code ==		== Example Code ==

Language - Objective C

Mparadis — Mon, 20 Apr 2026 16:09:04 GMT

Objective C Libraries

← Older revision		Revision as of 16:09, 20 April 2026
Line 6:		Line 6:

	== Objective C Libraries ==		== Objective C Libraries ==
	If you've installed the Phidget drivers for [[OS - macOS\|macOS]] or [[OS - iOS\|iOS]], then you already have the files you need for your project.		If you've installed the Phidget drivers for [[OS - macOS\|macOS]] or [[OS - iOS\|iOS]], then you already have the files you need for your project.

			====macOS Considerations====
			Legacy Phidgets running a HID USB stack require a driver extension (macOS 10.15 and newer) or a kernel extension (macOS 10.14 and earlier). During development, we recommend downloading the appropriate [https://www.phidgets.com/docs/OS_-_macOS#Quick_Downloads package] which will install the extension. When deploying applications, review the README in the [https://cdn.phidgets.com/downloads/phidget22/libraries/macos/Phidget22_macosdevel.zip macOS Development Files] for information about bundling the extension with your application.

			=====Determining USB Stack=====
			To determine which USB stack your device is running, navigate to the product page and then to the specification tab, and look for the ''USB Stack'' specification. If you are using a VINT device, navigate to the product page for the VINT Hub you are using.

			[[Image:Javascript_networkserver_webusb_spec.png\|center\|600px\|link=https://cdn.phidgets.com/docs/images/8/80/Javascript_networkserver_webusb_spec.png]]

	== Example Code ==		== Example Code ==

Language - C

Mparadis — Mon, 20 Apr 2026 16:07:17 GMT

MacOS Considerations

← Older revision		Revision as of 16:07, 20 April 2026
Line 19:		Line 19:
	</syntaxhighlight>		</syntaxhighlight>

	==== ~~MacOS~~ Considerations ====		====macOS Considerations====
	~~The Phidget framework~~ will ~~be found~~ in		Legacy Phidgets running a HID USB stack require a driver extension (macOS 10.15 and newer) or a kernel extension (macOS 10.14 and earlier). During development, we recommend downloading the appropriate [https://www.phidgets.com/docs/OS_-_macOS#Quick_Downloads package] which will install the extension. When deploying applications, review the README in the [https://cdn.phidgets.com/downloads/phidget22/libraries/macos/Phidget22_macosdevel.zip macOS Development Files] for information about bundling the extension with your application.
	~~<syntaxhighlight>~~
	/~~Library~~/~~Frameworks~~		=====Determining USB Stack=====
	~~</syntaxhighlight>~~		To determine which USB stack your device is running, navigate to the product page and then to the specification tab, and look for the ''USB Stack'' specification. If you are using a VINT device, navigate to the product page for the VINT Hub you are using.
	~~And~~ the ~~headers can be found in~~
	~~<syntaxhighlight>~~		[[Image:Javascript_networkserver_webusb_spec.png\|center\|600px\|link=https://cdn.phidgets.com/docs/images/8/80/Javascript_networkserver_webusb_spec.png]]
	/~~Library~~/~~Frameworks~~/~~Phidget22.framework~~/~~Headers~~
	</~~syntaxhighlight>~~

	====Linux Considerations====		====Linux Considerations====

Terms and Conditions

Lmpacent — Wed, 15 Apr 2026 16:12:13 GMT

Security and Privacy

← Older revision		Revision as of 16:12, 15 April 2026
(One intermediate revision by the same user not shown)
Line 122:		Line 122:

	==Security and Privacy==		==Security and Privacy==
	Phidgets Inc. pledges a safe and worry-free shopping experience. IF you are using the current version of Internet Explorer, on the checkout page where you enter your credit card information, you will notice a a locked padlock icon on the top bar your browser window. If you are using Mozilla Firefox, you will notice a locked padlock icon in the bottom right corner of your browser window. If this icon does not appear, please contact us directly to complete your purchase. These icons tell you that the page you are on is secure. We use Secure Sockets Layer (SSL 128-bit) technology with a digital certificate by GeoTrust, Inc. for Internet security to protect your personal information. This encryption makes it impossible for anyone to read your information in transit. We do not store your credit information and it is deleted once it has been securely transmitted to Moneris for processing.		Phidgets Inc. pledges a safe and worry-free shopping experience. If you are using the current version of Internet Explorer, on the checkout page where you enter your credit card information, you will notice a a locked padlock icon on the top bar your browser window. If you are using Mozilla Firefox, you will notice a locked padlock icon in the bottom right corner of your browser window. If this icon does not appear, please contact us directly to complete your purchase. These icons tell you that the page you are on is secure. We use Secure Sockets Layer (SSL 128-bit) technology with a digital certificate by GeoTrust, Inc. for Internet security to protect your personal information. This encryption makes it impossible for anyone to read your information in transit. We do not store your credit information and it is deleted once it has been securely transmitted to Moneris for processing.

	We use your e-mail address to let you know your shipment's tracking number. Your phone number is required by the Courier Company. We do not sell, rent or give any of your personal information to any unrelated third parties with the exception of Moneris for authorizing credit card payments and the Courier company to let them know where to deliver the shipment and how to contact you if there is any problems.		We use your e-mail address to let you know your shipment's tracking number. Your phone number is required by the Courier Company. We do not sell, rent or give any of your personal information to any unrelated third parties with the exception of Moneris for authorizing credit card payments and the Courier company to let them know where to deliver the shipment and how to contact you if there is any problems.

	If you have any questions or concerns about our Security and Privacy policy~~, call us at 1.403.282.7335 or e-mail us at support@phidgets~~.~~com~~		{{ContactUs\|Contact us}} if you have any questions or concerns about our Security and Privacy policy.

	Phidgets Inc. uses various Google Analytics tools such as conversion tracking in order to improve the effectiveness of the website. These statistics are completely anonymous.		Phidgets Inc. uses various Google Analytics tools such as conversion tracking in order to improve the effectiveness of the website. These statistics are completely anonymous.

Controlling an SPI Encoder

Lmpacent — Wed, 15 Apr 2026 15:48:57 GMT

← Older revision		Revision as of 15:48, 15 April 2026
Line 2:		Line 2:
	{{#seo:\|keywords=SPI Adapter}}		{{#seo:\|keywords=SPI Adapter}}
	{{#seo:\|description=Control an SPI encoder with the SPI Adapter Phidget}}		{{#seo:\|description=Control an SPI encoder with the SPI Adapter Phidget}}
			<div style="display:none;">
			[[Image:Adp0002_spiencoder_primary.png\|thumb\|link=\|alt=]]
			</div>
	[[Image:ADP0002_0.jpg\|link=\|thumb\| 400px\|<center>[https://www.phidgets.com/?prodid=1355 SPI Adapter Phidget (ADP0002_0)]]]		[[Image:ADP0002_0.jpg\|link=\|thumb\| 400px\|<center>[https://www.phidgets.com/?prodid=1355 SPI Adapter Phidget (ADP0002_0)]]]
	==Introduction==		==Introduction==

File:Adp0002 spiencoder primary.png

Lmpacent — Wed, 15 Apr 2026 15:48:35 GMT

Lmpacent uploaded File:Adp0002 spiencoder primary.png

New page

Reading an I2C Color Sensor

Lmpacent — Wed, 15 Apr 2026 15:46:47 GMT

← Older revision		Revision as of 15:46, 15 April 2026
Line 2:		Line 2:
	{{#seo:\|keywords=I2C Adapter}}		{{#seo:\|keywords=I2C Adapter}}
	{{#seo:\|description=Read an I2C color sensor with the I2C Adapter Phidget}}		{{#seo:\|description=Read an I2C color sensor with the I2C Adapter Phidget}}
			<div style="display:none;">
			[[Image:Adp0001_rgbcolor_primary.png\|thumb\|link=\|alt=]]
			</div>
	==Introduction==		==Introduction==
	[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]		[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]

File:Adp0001 rgbcolor primary.png

Lmpacent — Wed, 15 Apr 2026 15:46:22 GMT

Lmpacent uploaded File:Adp0001 rgbcolor primary.png

New page

LEDArray API Guide

Lmpacent — Wed, 15 Apr 2026 15:34:14 GMT

← Older revision		Revision as of 15:34, 15 April 2026
Line 1:		Line 1:
			[[Category:IntroGuide]]
			{{#seo:\|keywords=Addressable LED}}
	{{#seo:\|description=Get started with your Addressable LED Phidget}}		{{#seo:\|description=Get started with your Addressable LED Phidget}}
	~~[[Category:IntroGuide]]~~
	<div class="nonumtoc">		<div class="nonumtoc">
	<div class="toclimit-4">		<div class="toclimit-4">

Controlling an I2C Display

Lmpacent — Wed, 15 Apr 2026 15:32:32 GMT

← Older revision		Revision as of 15:32, 15 April 2026
Line 2:		Line 2:
	{{#seo:\|keywords=I2C Adapter}}		{{#seo:\|keywords=I2C Adapter}}
	{{#seo:\|description=Control an 14-segment LCD display with the I2C Adapter Phidget}}		{{#seo:\|description=Control an 14-segment LCD display with the I2C Adapter Phidget}}
			<div style="display:none;">
			[[Image:I2C_Sensor_Phid.png\|thumb\|link=\|alt=]]
			</div>
	==Introduction==		==Introduction==
	[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]		[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]

Controlling an SPI Encoder

Lmpacent — Wed, 15 Apr 2026 15:15:41 GMT

← Older revision		Revision as of 15:15, 15 April 2026
Line 1:		Line 1:
	~~<metadesc>A step-by-step example writing code to interface a sensor~~ with the ~~ADP0002.</metadesc>~~		[[Category: Project]]
			{{#seo:\|keywords=SPI Adapter}}
			{{#seo:\|description=Control an SPI encoder with the SPI Adapter Phidget}}

	[[Image:ADP0002_0.jpg\|link=\|thumb\| 400px\|<center>[https://www.phidgets.com/?prodid=1355 SPI Adapter Phidget (ADP0002_0)]]]		[[Image:ADP0002_0.jpg\|link=\|thumb\| 400px\|<center>[https://www.phidgets.com/?prodid=1355 SPI Adapter Phidget (ADP0002_0)]]]

Reading an I2C Color Sensor

Lmpacent — Wed, 15 Apr 2026 15:15:07 GMT

← Older revision		Revision as of 15:15, 15 April 2026
Line 1:		Line 1:
	~~<metadesc>A step-by-step example writing code to interface a~~ sensor with the ~~ADP0001.</metadesc>~~		[[Category: Project]]
			{{#seo:\|keywords=I2C Adapter}}
			{{#seo:\|description=Read an I2C color sensor with the I2C Adapter Phidget}}

	==Introduction==		==Introduction==

Controlling an I2C Display

Lmpacent — Wed, 15 Apr 2026 15:14:17 GMT

← Older revision		Revision as of 15:14, 15 April 2026
Line 1:		Line 1:
	~~<metadesc>A step-by~~-~~step example writing code to interface a sensor~~ with the ~~ADP0001.</metadesc>~~		[[Category: Project]]
			{{#seo:\|keywords=I2C Adapter}}
			{{#seo:\|description=Control an 14-segment LCD display with the I2C Adapter Phidget}}
	==Introduction==		==Introduction==
	[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]		[[Image:ADP0001_0_169.jpg\|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg\|thumb\| 450px\|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]

Reading an I2C Color Sensor

Mparadis — Mon, 13 Apr 2026 22:09:26 GMT

Created page with "<metadesc>A step-by-step example writing code to interface a sensor with the ADP0001.</metadesc> ==Introduction== link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg|thumb| 450px|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)] The [https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget] allows you to interface with a wide range of I2C-compatible devices, including sensors, displays, and more...."

New page

<metadesc>A step-by-step example writing code to interface a sensor with the ADP0001.</metadesc>

==Introduction==
[[Image:ADP0001_0_169.jpg|link=https://cdn.phidgets.com/docs/images/f/f5/ADP0001_0_169.jpg|thumb| 450px|<center>[https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget (ADP0001_0)]]]
The [https://www.phidgets.com/?prodid=1354 I2C Adapter Phidget] allows you to interface with a wide range of I2C-compatible devices, including sensors, displays, and more.

In this project, we will use it to read data from an RGB Color Sensor.

===Steps===
To complete this project, we will work through the following steps:
# Determine the device's basic configuration parameters
# Identify the sequence of commands expected by the device
# Connect the device to the I2C Adapter Phidget
# Test the device using the Phidget Control Panel
# Create a custom program.

===Resources===
Information from the following resource will be referenced throughout this project.
* [https://cdn.phidgets.com/docs/images/1/13/TCS34725.pdf TCS34725 RGB Color Sensor IC Datasheet]

==Demonstration==
<center>{{#ev:youtube|dYREkxXgjEA|rel=0}}</center>

==Configuration Parameters==
[[Image:Adp0002_rgb_specs2.png|link=https://cdn.phidgets.com/docs/images/0/05/Adp0002_rgb_specs2.png|thumb|<center>Excerpts from Datasheet</center>]]

During this step, we are looking for the following information:
* Supply Voltage
* Communication Frequency
* Device Address

This information is typically found using the device's product page and/or datasheet. In this case, it was all found on pages 3 to 5 of the datasheet:
* Supply Voltage: 3.3V
* Communication Frequency: 400kHz
* I2C Address: 0x29
<div style="clear:both">

==Command Sequence==
Next, we need to determine the sequence of commands the device is expecting. The TCS34725 datasheet provides a state diagram that we can use to create a list of actions:

[[Image:Adp0002_rgb_states.png|link=https://cdn.phidgets.com/docs/images/0/0e/Adp0002_rgb_states.png|200px|right|thumb|<center>From datasheet (page 7)</center>]]

<br>Based on the state diagram, our list of actions should look like this:

'''Power On Steps''':
# Enable PON (power on) to go from sleep to idle state
# Enable AEN (RGB enabled) to go from idle to RGBC state

After these steps, the device should be able to provide data and respond to commands. We're not using WEN (wait enabled) since we don't need this power-saving feature at this time.

===Writing to TCS34725 Registers===
I2C devices typically expect the following format:

[[Image:Adp0002_an_typicalcomms3.png|link=https://cdn.phidgets.com/docs/images/2/29/Adp0002_an_typicalcomms3.png|600px]]

This protocol diagram from page 12 of the datasheet confirms that the TCS34725 behaves as expected:

[[Image:Adp0002_rgb_protocol.png|link=https://cdn.phidgets.com/docs/images/3/38/Adp0002_rgb_protocol.png|700px]]

The Start (S), Stop (P), Acknowledge (A), and W/R (Write/Read) is all handled internally by the I2C Phidget, so we just need to focus on the command code and data.

==== Command Register ====

The command register lets us tell the sensor which register we want to read or write on our next communication.

[[Image:Adp0002_rgb_cmdreg.png|link=https://cdn.phidgets.com/docs/images/0/0d/Adp0002_rgb_cmdreg.png|750px|center]]

* The first bit is always '1'
* The next two bits control the how the device behaves when requesting multiple bytes
* The last five bits hold the register address (we can ignore the special functions for this project)

Here's an abridged list of registers we'll be using:

[[Image:Adp0002_rgb_registers.png|link=https://cdn.phidgets.com/docs/images/4/48/Adp0002_rgb_registers.png|600px|center]]

===Power On Steps===
====Enable the Sensor====
Enable is managed by register '''0x00''', so our command register will look like this:

[[Image:Adp0002_rgb_cmdenable.png|link=https://cdn.phidgets.com/docs/images/0/03/Adp0002_rgb_cmdenable.png|center|850px]]

So we'll send '''0x80''' to select the enable register.

The enable register is defined in the datasheet as follows:

[[Image:Adp0002_rgb_enablereg.png|link=https://cdn.phidgets.com/docs/images/8/89/Adp0002_rgb_enablereg.png|center|850px]]

* Bits 5, 6, and 7 are '''000''', as they're reserved
* Bit 4 will be '''0''', since we're not using interrupts
* Bit 3 will be '''0''', since we're not using the wait feature
* Bit 2 is '''0''', as it's reserved
* Bit 1 will be '''0''', since we're not enabling RGBC yet
* Bit 0 will be '''1''', to enable power

That gives us '''0x01'''. Together with our command register, our first communication will be '''0x8001'''.
The reason we don't enable RGBC yet is because the device requires a 2.4ms delay between PON and RGBC for reliable startup.

====Enable RGBC====

To enable RGBC we will use the same command we used for power on, but both the AEN bit and the PON bit will be 1. This gives us '''0x8003'''.

=== Reading Data ===

Now that the sensor is initialized, we can start getting data from it. We want to read all eight color registers, so we need to set auto-increment in the command register and point it to the first color register which is at 0x14:

[[Image:Adp0002_rgb_cmdreadauto.png|link=https://cdn.phidgets.com/docs/images/8/87/Adp0002_rgb_cmdreadauto.png|center|850px]]

This means we need to send '''B4'''. After that, we can listen for 8 bytes at a time to get all of our color data.

== Connecting to the ADP0001 ==

The pinout for this sensor is printed on the PCB:

[[Image:I2C_rgb_pinout2.png|link=|130px|left]]

*'''VIN''' - Power
*'''GND''' - Ground
*'''3V3''' - 3.3V Output
*'''SCL''' - Serial Clock
*'''SDA''' - Serial Data
*'''INT''' - Interrupt
*'''LED''' - LED toggle

We don't need the 3.3V output or the interrupt pin for this project. The other pins can be connected to the ADP0001 as follows:

[[Image:I2C_rgb_connection.png|800px|link=https://cdn.phidgets.com/docs/images/d/d9/I2C_rgb_connection.png]]

The LED toggle pin is connected to one of the ADP0001's GPIO pins so we can use it to turn off the LED when not in use.

==Testing in the Phidget Control Panel==
Now that we have the command sequence and our sensor connected, we can use the Phidget Control Panel to confirm our device is working as expected.

===Power On Steps===
We can set the voltage to 3.3V, the frequency to 400kHz, and the address to 0x29.

[[Image:I2C_RGB_ControlPanel.png|link=https://cdn.phidgets.com/docs/images/2/20/I2C_RGB_ControlPanel.png|center]]

Now we can enable the sensor with our command sequence:
* 0x8001 (Power on)
* 0x8003 (RGBC on)
* 0xB4 (auto increment and start from register 0x14)

[[Image:I2C_RGB_ControlPanel2.png|link=https://cdn.phidgets.com/docs/images/4/4f/I2C_RGB_ControlPanel2.png|center]]

===Reading Data===
After sending the command register B4, we can read all color registers by reading 8 bytes at a time.

[[Image:I2C_RGB_ControlPanel3.png|link=https://cdn.phidgets.com/docs/images/0/0a/I2C_RGB_ControlPanel3.png|center]]
[[Image:I2C_RGB_responsegraph.png|link=https://wwwdev.int.phidgets.com/docs/images/9/97/I2C_RGB_responsegraph.png|thumb|<center>Sensor response characteristic (pg.6)<center>]]

This sensor ultimately provides us with four 16-bit values: Clear, Red, Green, and Blue. The clear light value is important for providing brightness calibration. Since the responses of the red, green and blue sensors are normalized to match the response of the clear sensor, we can use it as a baseline to determine color in both bright and dim environments.

In the above image, we get roughly the same value when polling the sensor three times, so the value seems stable. We'll use the bottom row to see if the color makes sense. The data bytes received are sent in register order, so our values are:

* Clear: 0x0FFD
* Red: 0x0A96
* Green: 0x0331
* Blue: 0x0271

Converting to decimal, that's 4093, 2710, 817, 625. We can normalize the last three values using the clear value, and then multiply by 255 and round to get a standard RGB value:

* Red: (2710/4093)*255 = 169
* Green: (817/4093)*255 = 51
* Blue: (625/4093)*255 = 39

This RGB value '''<span style="color:#A93327">(#A93327)</span>''' looks to be correct, as the sensor was pointed at a roll of red electrical tape.

==Writing a Custom Program==
To begin writing a custom program for your Phidget device, navigate to the product page and select the [https://www.phidgets.com/?prodid=1354#Tab_Code_Samples Code Samples tab]. From there, you can customize the code for your own purposes. Here we have modified the Python code sample to match our steps from the Phidget Control Panel.

<syntaxhighlight lang=python>
from Phidget22.Phidget import *
from Phidget22.Devices.DataAdapter import *
import time

def convert_rgbc(data):

c = data[1] << 8 | data[0]

if(c <= 0):
return [0,0,0]

# Combine high and low bytes for each color,
# Then normalize and cap at 255
r = min(255,round((data[3] << 8 | data[2]) / c * 255))
g = min(255,round((data[5] << 8 | data[4]) / c * 255))
b = min(255,round((data[7] << 8 | data[6]) / c * 255))
return [r,g,b]

def main():

adp = DataAdapter()
adp.openWaitForAttachment(5000)

# Set properties
adp.setFrequency(DataAdapterFrequency.FREQUENCY_400kHz)
adp.setDataAdapterVoltage(DataAdapterVoltage.DATAADAPTER_VOLTAGE_3_3V)
addr = 0x29

# Power On
adp.i2cSendReceive(addr, [0x8001], 0)
time.sleep(0.01)

# RGBC On
adp.i2cSendReceive(addr, [0x8003], 0)

# Auto-increment starting with CDATAL
adp.i2cSendReceive(addr, [0xB4], 0)

try:
while True:
rgb = convert_rgbc(adp.i2cSendReceive(addr, [], 8))
print("R: " + str(rgb[0]) + " G: " + str(rgb[1]) + " B: " + str(rgb[2]))
time.sleep(0.5)
pass
except KeyboardInterrupt:
print("Closing...")

adp.close()

main()
</syntaxhighlight>

That’s about it, we went from reading the datasheet to a working script. Not all datasheets are created equal, so if you’re struggling with getting your sensor set up, feel free to ask for help by [https://www.phidgets.com/?view=contact sending us an email].

===Python Graphical Example===
Here is a more in-depth script that displays a graph of the raw values and shows the calculated color after gamma and saturation adjustment.

{{UGC-Start}}
{{UGC-Entry|Full Script (Click to expand)||
<syntaxhighlight lang=python>
import tkinter as tk
import math
from Phidget22.Phidget import *
from Phidget22.Devices.DataAdapter import *
import time

class MultiLineGraph(tk.Canvas):
def __init__(self, parent, lines=4, max_points=100, **kwargs):
super().__init__(parent, bg="black", **kwargs)
self.lines = lines
self.max_points = max_points
self.data = [[] for _ in range(lines)]
self.colors = ["white", "red", "green", "blue"]

def add_points(self, *values):
for i, v in enumerate(values):
self.data[i].append(v)
if len(self.data[i]) > self.max_points:
self.data[i].pop(0)
self.draw()

def draw(self):
self.delete("all")
w = self.winfo_width()
h = self.winfo_height()

if w < 10 or h < 10:
return

# Flatten all visible data
all_values = [v for line in self.data for v in line]

if not all_values:
return

min_val = min(all_values)
max_val = max(all_values)

# Prevent divide-by-zero
if max_val == min_val:
max_val += 1

padding = (max_val - min_val) * 0.1 # 10% padding
min_val -= padding
max_val += padding

for i, line in enumerate(self.data):
if len(line) < 2:
continue

points = []
for j, val in enumerate(line):
x = j / (self.max_points - 1) * w

# Normalize to 0–1
norm = (val - min_val) / (max_val - min_val)

# Flip Y (Tkinter origin is top-left)
y = h - (norm * h)

points.extend([x, y])

self.create_line(points, fill=self.colors[i], width=2)

class App:
def __init__(self, root):
self.root = root
self.root.title("I2C RGB Viewer")
self.adp = DataAdapter()
self.addr = 0x29
self.sat = 1.8
self.gamma = 1.3

# --- Define Gamma Table ---
self.gamma_table = [0] * 256
for i in range(256):
self.gamma_table[i] = int(math.pow(i/255.0,self.gamma)*255)

# --- UI ---
self.graph = MultiLineGraph(root, height=300)
self.graph.pack(fill="both", expand=True)

self.rgb_entry = tk.Entry(root, font=("Consolas", 14))
self.rgb_entry.pack(fill="x")

self.color_panel = tk.Frame(root, height=50, bg="black")
self.color_panel.pack(fill="x")

self.adp.openWaitForAttachment(5000)

# Set properties
self.adp.setFrequency(DataAdapterFrequency.FREQUENCY_400kHz)
self.adp.setDataAdapterVoltage(DataAdapterVoltage.DATAADAPTER_VOLTAGE_3_3V)

# Power On
self.adp.i2cSendReceive(self.addr, [0x8001], 0)
time.sleep(0.01)

# RGBC On
self.adp.i2cSendReceive(self.addr, [0x8003], 0)

# Auto-increment starting with CDATAL
self.adp.i2cSendReceive(self.addr, [0xB4], 0)

# --- Timer ---
self.update_loop()

def read_sensor(self):

data = self.adp.i2cSendReceive(self.addr, [], 8)

# Combine high and low bytes for clear register
raw_c = data[1] << 8 | data[0]

if(raw_c <= 0):
return [0,0,0,0]

# Combine high and low bytes for each colour
raw_r = data[3] << 8 | data[2]
raw_g = data[5] << 8 | data[4]
raw_b = data[7] << 8 | data[6]

return raw_c, raw_r, raw_g, raw_b

def update_loop(self):
raw_c, raw_r, raw_g, raw_b = self.read_sensor()

if raw_c > 0:
# Normalize + gamma
norm_r = self.gamma_table[int(raw_r / raw_c * 255)]
norm_g = self.gamma_table[int(raw_g / raw_c * 255)]
norm_b = self.gamma_table[int(raw_b / raw_c * 255)]

avg = (norm_r + norm_g + norm_b) / 3

# Saturation adjust
norm_r = max(0, min(255, avg + (norm_r - avg) * self.sat))
norm_g = max(0, min(255, avg + (norm_g - avg) * self.sat))
norm_b = max(0, min(255, avg + (norm_b - avg) * self.sat))

hex_color = "#{:02X}{:02X}{:02X}".format(
int(norm_r), int(norm_g), int(norm_b)
)

self.rgb_entry.delete(0, tk.END)
self.rgb_entry.insert(0, hex_color)

self.color_panel.config(bg=hex_color)

# Update graph
self.graph.add_points(raw_c, raw_r, raw_g, raw_b)

# Repeat every 50 ms
self.root.after(50, self.update_loop)

if __name__ == "__main__":
root = tk.Tk()
app = App(root)
root.geometry("600x400")
root.mainloop()
</syntaxhighlight>
}}
{{UGC-End}}

File:TCS34725.pdf

Mparadis — Mon, 13 Apr 2026 22:09:02 GMT

Mparadis uploaded File:TCS34725.pdf

New page

File:I2C RGB responsegraph.png

Mparadis — Mon, 13 Apr 2026 22:03:48 GMT

Mparadis uploaded File:I2C RGB responsegraph.png

New page

File:I2C RGB ControlPanel3.png

Mparadis — Mon, 13 Apr 2026 22:03:36 GMT

Mparadis uploaded File:I2C RGB ControlPanel3.png

New page

File:I2C RGB ControlPanel2.png

Mparadis — Mon, 13 Apr 2026 22:03:28 GMT

Mparadis uploaded File:I2C RGB ControlPanel2.png

New page

File:I2C RGB ControlPanel.png

Mparadis — Mon, 13 Apr 2026 22:03:14 GMT

Mparadis uploaded File:I2C RGB ControlPanel.png

New page

File:I2C rgb connection.png

Mparadis — Mon, 13 Apr 2026 22:02:15 GMT

Mparadis uploaded File:I2C rgb connection.png

New page

File:I2C rgb pinout2.png

Mparadis — Mon, 13 Apr 2026 22:02:04 GMT

Mparadis uploaded File:I2C rgb pinout2.png

New page

File:Adp0002 rgb cmdreadauto.png

Mparadis — Mon, 13 Apr 2026 22:01:42 GMT

Mparadis uploaded File:Adp0002 rgb cmdreadauto.png

New page

File:Adp0002 rgb enablereg.png

Mparadis — Mon, 13 Apr 2026 22:01:22 GMT

Mparadis uploaded File:Adp0002 rgb enablereg.png

New page

File:Adp0002 rgb cmdenable.png

Mparadis — Mon, 13 Apr 2026 22:00:59 GMT

Mparadis uploaded File:Adp0002 rgb cmdenable.png

New page

File:Adp0002 rgb registers.png

Mparadis — Mon, 13 Apr 2026 22:00:35 GMT

Mparadis uploaded File:Adp0002 rgb registers.png

New page

File:Adp0002 rgb cmdreg.png

Mparadis — Mon, 13 Apr 2026 22:00:21 GMT

Mparadis uploaded File:Adp0002 rgb cmdreg.png

New page

File:Adp0002 rgb protocol.png

Mparadis — Mon, 13 Apr 2026 21:59:53 GMT

Mparadis uploaded File:Adp0002 rgb protocol.png

New page

File:Adp0002 rgb states.png

Mparadis — Mon, 13 Apr 2026 21:59:38 GMT

Mparadis uploaded File:Adp0002 rgb states.png

New page

File:Adp0002 rgb specs2.png

Mparadis — Mon, 13 Apr 2026 21:59:22 GMT

Mparadis uploaded File:Adp0002 rgb specs2.png

New page

Controlling an I2C Display

Lmpacent — Mon, 13 Apr 2026 15:11:42 GMT

Writing a Custom Program

← Older revision		Revision as of 15:11, 13 April 2026
(One intermediate revision by the same user not shown)
Line 161:		Line 161:
	[[Image:I2C_Panel_Read.png\|850px\|link=]]		[[Image:I2C_Panel_Read.png\|850px\|link=]]

	==Writing a Custom ~~Python Script~~==		==Writing a Custom Program==
	To begin writing a custom program for your Phidget device, navigate to the product page and select the [https://www.phidgets.com/?prodid=1354#Tab_Code_Samples Code Samples tab]. From there, you can customize the code for your own purposes. Here we have modified the code sample to match our steps from the Phidget Control Panel.		To begin writing a custom program for your Phidget device, navigate to the product page and select the [https://www.phidgets.com/?prodid=1354#Tab_Code_Samples Code Samples tab]. From there, you can customize the code for your own purposes. Here we have modified the Python code sample to match our steps from the Phidget Control Panel.

	<syntaxhighlight lang=python>		<syntaxhighlight lang=python>

I2C Adapter API Guide

Lmpacent — Thu, 09 Apr 2026 19:50:44 GMT

I2CSendReceive()

← Older revision		Revision as of 19:50, 9 April 2026
(2 intermediate revisions by the same user not shown)
Line 4:		Line 4:
	<div class="toclimit-4">		<div class="toclimit-4">
	== Introduction ==		== Introduction ==
	This guide will provide ~~additional details for~~ the DataAdapter API so you ~~can better understand what~~ your I2C Adapter Phidget ~~is doing when communicating with an~~ I2C ~~device~~.		[[Image:ADP0001_0.jpg\|thumb\|<center>I2C Adapter Phidget (ADP0001_0)</center>]]
			This guide will provide information about the DataAdapter API to get you up and running with your new I2C Adapter Phidget.


			Before starting this guide, visit the Quick Start Guide on your I2C Adapter Phidget's product page for information about wiring.

	== Address Format ==		== Address Format ==
Line 34:		Line 38:

	''''S'''' represents a start condition, while ''''P'''' represents a stop condition. If your I2C device requires data in a different structure than this, you may need to use {{Code\|I2CComplexTransaction()}}, as explained in the next section.		''''S'''' represents a start condition, while ''''P'''' represents a stop condition. If your I2C device requires data in a different structure than this, you may need to use {{Code\|I2CComplexTransaction()}}, as explained in the next section.








	=== I2CComplexTransaction() ===		=== I2CComplexTransaction() ===

File:ADP0001 0.jpg

Lmpacent — Thu, 09 Apr 2026 19:42:20 GMT

Lmpacent uploaded File:ADP0001 0.jpg

New page

I2C Adapter API Guide

Mparadis — Thu, 09 Apr 2026 18:16:26 GMT

Created page with "{{#seo:|description=Get started with your I2C Adapter Phidget}} Category:IntroGuide <div class="nonumtoc"> <div class="toclimit-4"> == Introduction == This guide will provide additional details for the DataAdapter API so you can better understand what your I2C Adapter Phidget is doing when communicating with an I2C device. == Address Format == The I2C Adapter Phidget interprets the device address as follows: link=|550px The read/write bit i..."

New page

{{#seo:|description=Get started with your I2C Adapter Phidget}}
[[Category:IntroGuide]]
<div class="nonumtoc">
<div class="toclimit-4">
== Introduction ==
This guide will provide additional details for the DataAdapter API so you can better understand what your I2C Adapter Phidget is doing when communicating with an I2C device.

== Address Format ==

The I2C Adapter Phidget interprets the device address as follows:

[[Image:I2C_Addr.png|link=|550px]]

The read/write bit is not included in the hexadecimal value for the address, as this bit is handled by the API calls.
You may find that datasheets for some I2C devices include the read/write bit, so a read-only device like a simple temperature sensor might specify the address as '''0xE3''' instead of '''0x71''' in this case. When using such a sensor, be sure to ignore the R/W bit and shift the remaining seven bits down to get the address you need to send to Phidgets API calls.

== Methods ==
=== I2CSendReceive() ===

Parameters:
* int '''address'''
* byte[ ] '''data'''
* int '''receiveLength'''

This is the main function you'll use for simple read and write operations.

* The first parameter is the I2C address of your device, usually specified in the datasheet or printed on the circuit board.
* The second parameter is the data array, which can contain up to 127 bytes. If the data array is empty, the I2C Adapter Phidget will skip sending the write address and bytes.
* The third parameter is the receive length, or the number of bytes you're expecting back from the device for this transaction. Maximum receive length is 127, and if it's zero the I2C Adapter Phidget will skip sending the read address and bytes.

This diagram illustrates the data structure when using {{Code|I2CSendReceive}}:

[[Image:I2C_SendRecv.png|link=|850px]]

''''S'''' represents a start condition, while ''''P'''' represents a stop condition. If your I2C device requires data in a different structure than this, you may need to use {{Code|I2CComplexTransaction()}}, as explained in the next section.

=== I2CComplexTransaction() ===

Parameters:
* int '''address'''
* string '''I2CPacketString'''
* byte[ ] '''data'''

This function gives you more control over the read/write structure for more complex interactions. This is useful for longer commands that make use of repeated start conditions.

* The first parameter is the I2C address of your device, usually specified in the datasheet or printed on the circuit board.
* The second parameter is a string that dictates the read/write sequence to follow.
* The third parameter is the data array, whose length must match the number of writes in the string, up to 127 bytes.

The string is made up of the following characters, case-sensitive with no spaces:
* ''''s'''' for a start condition
* ''''R'''' for a read byte
* ''''T'''' for a write byte
* ''''p'''' for a stop condition

Here's an example:

[[Image:I2C_Complex.png|link=|850px]]

Numerals can also be used after a 'T' or 'R' to make the string compact. In this example, the data array would need to have a length of 3, since a total of three bytes are written in the sequence.

File:I2C Complex.png

Mparadis — Thu, 09 Apr 2026 18:16:19 GMT

Mparadis uploaded File:I2C Complex.png

New page

File:I2C SendRecv.png

Mparadis — Thu, 09 Apr 2026 18:16:09 GMT

Mparadis uploaded File:I2C SendRecv.png

New page

File:I2C Addr.png

Mparadis — Thu, 09 Apr 2026 18:15:58 GMT

Mparadis uploaded File:I2C Addr.png

New page

Rotary Motion Guide

Mparadis — Wed, 08 Apr 2026 20:25:37 GMT

Chain/Sprockets

← Older revision		Revision as of 20:25, 8 April 2026
Line 24:		Line 24:
	Pretty much everyone has at least seen a chain system in their life in the form of a bicycle. This system of course is driven by human input rather than a motor. Automated systems behave no differently though, you have several sprockets, and chain that wraps around them. One sprocket is driven and the others perform work on the load. Chain tends to be noisier than belts and cannot be tensioned as tightly meaning there is a bit more backlash inherent in the system. In exchange though, chain can move much heavier loads for their size.		Pretty much everyone has at least seen a chain system in their life in the form of a bicycle. This system of course is driven by human input rather than a motor. Automated systems behave no differently though, you have several sprockets, and chain that wraps around them. One sprocket is driven and the others perform work on the load. Chain tends to be noisier than belts and cannot be tensioned as tightly meaning there is a bit more backlash inherent in the system. In exchange though, chain can move much heavier loads for their size.

	We sell ANSI#25 and #40 chain and sprockets (that is 0.25" pitch and 0.5" pitch). The #25 is rated for 100lbs of working tension while the #40 is rated for 800lbs. Chain is sold by the meter and you can form closed loops of any length you'd like with the link kits that we sell. To calculate how many links you will need for a particular sprocket spacing you can use [http://www.botlanta.org/converters/dale-calc/sprocket.html this calculator], just enter in the number of teeth on each sprocket, the chain pitch, and the center to center distance between the sprockets to get the number of links you will need. If the number is not whole, you should always round up (and probably even add one). Once you know how many links you will require you will need to use the link kit to connect your chain up. This is where it gets a bit fiddly.		We sell ANSI#25 and #40 chain and sprockets (that is 0.25" pitch and 0.5" pitch). The #25 is rated for 100lbs of working tension while the #40 is rated for 800lbs. Chain is sold by the meter and you can form closed loops of any length you'd like with the link kits that we sell.

	There are two ways to connect chain, you can either use a hammer and a pin of some kind to knock out one of the pins which you can then connect up with an offset link:		There are two ways to connect chain, you can either use a hammer and a pin of some kind to knock out one of the pins which you can then connect up with an offset link:
Line 36:		Line 36:
	A good example of a chain system is our MURVV robot. Here is how it's drive mechanism works:		A good example of a chain system is our MURVV robot. Here is how it's drive mechanism works:
	[[Image:Murvv_chain.jpg\|link=\|center\|500px]]		[[Image:Murvv_chain.jpg\|link=\|center\|500px]]


	==Worm Gearboxes==		==Worm Gearboxes==