ReesesManiac
New member
Hello,
I am building a robot that cannot leave a certain boundary. This boundary is indicated by coloured tape on the floor. So, I am trying to use 3 RGB sensors placed on the edges of my robot to look for this boundry tape. I purchased a teensy 3.5 because of its 3 i2c ports, with the hope that I can use it to interface with all three sensors (https://learn.adafruit.com/adafruit-color-sensors/library-reference). The best way that I have found to do this is to use i2c_t3 to create three wire instances within the adafruit code. This will (hopefully) allow me to indicate which sensor I want the reading from, and get the reading back. However, this is not the case. I am getting readings from sensor 2, but no others. All three check out in the begin() function, because no error is thrown.
Am I going about this the right way, or is there an easier way to utilize all three i2c ports?
If this is the right way, do you have an idea of why my code is only working on sensor 2?
As I know this will be asked, each of my SDA/SCL pins are pulled up with a 4.7k resistor to 3.3V.
Below is the arduino code:
The adafruit cpp file which I modified to use i2c_t3:
The adafruit header file:
Thank you for your help!
I am building a robot that cannot leave a certain boundary. This boundary is indicated by coloured tape on the floor. So, I am trying to use 3 RGB sensors placed on the edges of my robot to look for this boundry tape. I purchased a teensy 3.5 because of its 3 i2c ports, with the hope that I can use it to interface with all three sensors (https://learn.adafruit.com/adafruit-color-sensors/library-reference). The best way that I have found to do this is to use i2c_t3 to create three wire instances within the adafruit code. This will (hopefully) allow me to indicate which sensor I want the reading from, and get the reading back. However, this is not the case. I am getting readings from sensor 2, but no others. All three check out in the begin() function, because no error is thrown.
Am I going about this the right way, or is there an easier way to utilize all three i2c ports?
If this is the right way, do you have an idea of why my code is only working on sensor 2?
As I know this will be asked, each of my SDA/SCL pins are pulled up with a 4.7k resistor to 3.3V.
Below is the arduino code:
Code:
//#include <i2c_t3.h>
#include <Adafruit_TCS34725.h>
Adafruit_TCS34725 color = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_2_4MS, TCS34725_GAIN_1X);
uint16_t r; uint16_t g; uint16_t b; uint16_t c;
void setup()
{
Serial.begin(9600);
Serial.println("Color View Test!");
// loop through and initalize all sensors
if (color.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1); // halt!
}
// // initalize scl/sda
// Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, 4700);
// Wire.setDefaultTimeout(200000);
//
// Wire1.begin(I2C_MASTER, 0x00, I2C_PINS_37_38, I2C_PULLUP_EXT, 4700);
// Wire1.setDefaultTimeout(200000);
//
// Wire2.begin(I2C_MASTER, 0x00, I2C_PINS_3_4, I2C_PULLUP_EXT, 4700);
// Wire2.setDefaultTimeout(200000);
}
void loop()
{
// loop through and initalize all sensors
for(int i = 0; i < 3; i++)
{
color.getRawData(&r, &g, &b, &c, i);
Serial.print("Sensor:\t"); Serial.print(i);
Serial.print("\tC:\t"); Serial.print(c);
Serial.print("\tR:\t"); Serial.print(r);
Serial.print("\tG:\t"); Serial.print(g);
Serial.print("\tB:\t"); Serial.println(b);
}
}The adafruit cpp file which I modified to use i2c_t3:
Code:
/**************************************************************************/
/*!
@file Adafruit_TCS34725.cpp
@author KTOWN (Adafruit Industries)
@license BSD (see license.txt)
Driver for the TCS34725 digital color sensors.
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
@section HISTORY
v1.0 - First release
*/
/**************************************************************************/
#ifdef __AVR
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#endif
#include <stdlib.h>
#include <math.h>
#include "Adafruit_TCS34725.h"
/*========================================================================*/
/* PRIVATE FUNCTIONS */
/*========================================================================*/
/**************************************************************************/
/*!
@brief Implements missing powf function
*/
/**************************************************************************/
float powf(const float x, const float y)
{
return (float)(pow((double)x, (double)y));
}
/**************************************************************************/
/*!
@brief Writes a register and an 8 bit value over I2C
*/
/**************************************************************************/
void Adafruit_TCS34725::write8 (uint8_t reg, uint32_t value, int i)
{
if (i == 0)
{
Wire.beginTransmission(TCS34725_ADDRESS);
Wire.write(TCS34725_COMMAND_BIT | reg);
Wire.write(value & 0xFF);
Wire.endTransmission();
}
if (i == 1)
{
Wire1.beginTransmission(TCS34725_ADDRESS);
Wire1.write(TCS34725_COMMAND_BIT | reg);
Wire1.write(value & 0xFF);
Wire1.endTransmission();
}
if (i == 2)
{
Wire2.beginTransmission(TCS34725_ADDRESS);
Wire2.write(TCS34725_COMMAND_BIT | reg);
Wire2.write(value & 0xFF);
Wire2.endTransmission();
}
}
/**************************************************************************/
/*!
@brief Reads an 8 bit value over I2C
*/
/**************************************************************************/
uint8_t Adafruit_TCS34725::read8(uint8_t reg, int i)
{
if (i == 0)
{
Wire.beginTransmission(TCS34725_ADDRESS);
Wire.write(TCS34725_COMMAND_BIT | reg);
Wire.endTransmission();
Wire.requestFrom(TCS34725_ADDRESS, 1);
return Wire.read();
}
if (i == 1)
{
Wire1.beginTransmission(TCS34725_ADDRESS);
Wire1.write(TCS34725_COMMAND_BIT | reg);
Wire1.endTransmission();
Wire1.requestFrom(TCS34725_ADDRESS, 1);
return Wire1.read();
}
if (i == 2)
{
Wire2.beginTransmission(TCS34725_ADDRESS);
Wire2.write(TCS34725_COMMAND_BIT | reg);
Wire2.endTransmission();
Wire2.requestFrom(TCS34725_ADDRESS, 1);
return Wire2.read();
}
else
return 0;
}
/**************************************************************************/
/*!
@brief Reads a 16 bit values over I2C
*/
/**************************************************************************/
uint16_t Adafruit_TCS34725::read16(uint8_t reg, int i)
{
uint16_t x; uint16_t t;
if (i == 0)
{
Wire.beginTransmission(TCS34725_ADDRESS);
Wire.write(TCS34725_COMMAND_BIT | reg);
Wire.endTransmission();
Wire.requestFrom(TCS34725_ADDRESS, 2);
t = Wire.read();
x = Wire.read();
}
else if (i == 1)
{
Wire1.beginTransmission(TCS34725_ADDRESS);
Wire1.write(TCS34725_COMMAND_BIT | reg);
Wire1.endTransmission();
Wire1.requestFrom(TCS34725_ADDRESS, 2);
t = Wire1.read();
x = Wire1.read();
}
else if (i == 2)
{
Wire2.beginTransmission(TCS34725_ADDRESS);
Wire2.write(TCS34725_COMMAND_BIT | reg);
Wire2.endTransmission();
Wire2.requestFrom(TCS34725_ADDRESS, 2);
t = Wire2.read();
x = Wire2.read();
}
else
{
t = 0;
x = 0;
}
x <<= 8;
x |= t;
return x;
}
/**************************************************************************/
/*!
Enables the device
*/
/**************************************************************************/
void Adafruit_TCS34725::enable(void)
{
for (int i = 0; i < 3; i++)
{
write8(TCS34725_ENABLE, TCS34725_ENABLE_PON, i);
delay(3);
write8(TCS34725_ENABLE, TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN, i);
}
}
/**************************************************************************/
/*!
Disables the device (putting it in lower power sleep mode)
*/
/**************************************************************************/
void Adafruit_TCS34725::disable(void)
{
/* Turn the device off to save power */
uint8_t reg = 0;
for (int i = 0; i < 3; i++)
{
reg = read8(TCS34725_ENABLE, i);
write8(TCS34725_ENABLE, reg & ~(TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN), i);
}
}
/*========================================================================*/
/* CONSTRUCTORS */
/*========================================================================*/
/**************************************************************************/
/*!
Constructor
*/
/**************************************************************************/
Adafruit_TCS34725::Adafruit_TCS34725(tcs34725IntegrationTime_t it, tcs34725Gain_t gain)
{
_tcs34725Initialised = false;
_tcs34725IntegrationTime = it;
_tcs34725Gain = gain;
}
/*========================================================================*/
/* PUBLIC FUNCTIONS */
/*========================================================================*/
/**************************************************************************/
/*!
Initializes I2C and configures the sensor (call this function before
doing anything else)
*/
/**************************************************************************/
boolean Adafruit_TCS34725::begin(void)
{
// initalize scl/sda
Wire.begin(I2C_MASTER, 0x00, I2C_PINS_18_19, I2C_PULLUP_EXT, 4700);
Wire.setDefaultTimeout(200000);
Wire1.begin(I2C_MASTER, 0x00, I2C_PINS_37_38, I2C_PULLUP_EXT, 4700);
Wire1.setDefaultTimeout(200000);
Wire2.begin(I2C_MASTER, 0x00, I2C_PINS_3_4, I2C_PULLUP_EXT, 4700);
Wire2.setDefaultTimeout(200000);
/* Make sure we're actually connected */
uint8_t x = read8(TCS34725_ID, 0);
uint8_t y = read8(TCS34725_ID, 1);
uint8_t z = read8(TCS34725_ID, 2);
if ((x != 0x44) && (x != 0x10) && (y != 0x44) && (y != 0x10) && (z != 0x44) && (z != 0x10))
{
return false;
}
_tcs34725Initialised = true;
/* Set default integration time and gain */
setIntegrationTime(_tcs34725IntegrationTime, 0);
setIntegrationTime(_tcs34725IntegrationTime, 1);
setIntegrationTime(_tcs34725IntegrationTime, 2);
setGain(_tcs34725Gain, 0);
setGain(_tcs34725Gain, 1);
setGain(_tcs34725Gain, 2);
/* Note: by default, the device is in power down mode on bootup */
enable();
return true;
}
/**************************************************************************/
/*!
Sets the integration time for the TC34725
*/
/**************************************************************************/
void Adafruit_TCS34725::setIntegrationTime(tcs34725IntegrationTime_t it, int i)
{
if (!_tcs34725Initialised) begin();
/* Update the timing register */
write8(TCS34725_ATIME, it, i);
/* Update value placeholders */
_tcs34725IntegrationTime = it;
}
/**************************************************************************/
/*!
Adjusts the gain on the TCS34725 (adjusts the sensitivity to light)
*/
/**************************************************************************/
void Adafruit_TCS34725::setGain(tcs34725Gain_t gain, int i)
{
if (!_tcs34725Initialised) begin();
/* Update the timing register */
write8(TCS34725_CONTROL, gain, i);
/* Update value placeholders */
_tcs34725Gain = gain;
}
/**************************************************************************/
/*!
@brief Reads the raw red, green, blue and clear channel values
*/
/**************************************************************************/
void Adafruit_TCS34725::getRawData (uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c, int i)
{
if (!_tcs34725Initialised) begin();
*c = read16(TCS34725_CDATAL, i);
*r = read16(TCS34725_RDATAL, i);
*g = read16(TCS34725_GDATAL, i);
*b = read16(TCS34725_BDATAL, i);
/* Set a delay for the integration time */
switch (_tcs34725IntegrationTime)
{
case TCS34725_INTEGRATIONTIME_2_4MS:
delay(3);
break;
case TCS34725_INTEGRATIONTIME_24MS:
delay(24);
break;
case TCS34725_INTEGRATIONTIME_50MS:
delay(50);
break;
case TCS34725_INTEGRATIONTIME_101MS:
delay(101);
break;
case TCS34725_INTEGRATIONTIME_154MS:
delay(154);
break;
case TCS34725_INTEGRATIONTIME_700MS:
delay(700);
break;
}
}
/**************************************************************************/
/*!
@brief Converts the raw R/G/B values to color temperature in degrees
Kelvin
*/
/**************************************************************************/
uint16_t Adafruit_TCS34725::calculateColorTemperature(uint16_t r, uint16_t g, uint16_t b)
{
float X, Y, Z; /* RGB to XYZ correlation */
float xc, yc; /* Chromaticity co-ordinates */
float n; /* McCamy's formula */
float cct;
/* 1. Map RGB values to their XYZ counterparts. */
/* Based on 6500K fluorescent, 3000K fluorescent */
/* and 60W incandescent values for a wide range. */
/* Note: Y = Illuminance or lux */
X = (-0.14282F * r) + (1.54924F * g) + (-0.95641F * b);
Y = (-0.32466F * r) + (1.57837F * g) + (-0.73191F * b);
Z = (-0.68202F * r) + (0.77073F * g) + ( 0.56332F * b);
/* 2. Calculate the chromaticity co-ordinates */
xc = (X) / (X + Y + Z);
yc = (Y) / (X + Y + Z);
/* 3. Use McCamy's formula to determine the CCT */
n = (xc - 0.3320F) / (0.1858F - yc);
/* Calculate the final CCT */
cct = (449.0F * powf(n, 3)) + (3525.0F * powf(n, 2)) + (6823.3F * n) + 5520.33F;
/* Return the results in degrees Kelvin */
return (uint16_t)cct;
}
/**************************************************************************/
/*!
@brief Converts the raw R/G/B values to lux
*/
/**************************************************************************/
uint16_t Adafruit_TCS34725::calculateLux(uint16_t r, uint16_t g, uint16_t b)
{
float illuminance;
/* This only uses RGB ... how can we integrate clear or calculate lux */
/* based exclusively on clear since this might be more reliable? */
illuminance = (-0.32466F * r) + (1.57837F * g) + (-0.73191F * b);
return (uint16_t)illuminance;
}
void Adafruit_TCS34725::setInterrupt(boolean i)
{
for (int x = 0; x < 3; x++)
{
uint8_t r = read8(TCS34725_ENABLE, x);
if (i) {
r |= TCS34725_ENABLE_AIEN;
}
else {
r &= ~TCS34725_ENABLE_AIEN;
}
write8(TCS34725_ENABLE, r, x);
}
}
void Adafruit_TCS34725::clearInterrupt(int i)
{
if (i == 0)
{
Wire.beginTransmission(TCS34725_ADDRESS);
Wire.write(TCS34725_COMMAND_BIT | 0x66);
Wire.endTransmission();
}
if (i == 1)
{
Wire1.beginTransmission(TCS34725_ADDRESS);
Wire1.write(TCS34725_COMMAND_BIT | 0x66);
Wire1.endTransmission();
}
if (i == 2)
{
Wire2.beginTransmission(TCS34725_ADDRESS);
Wire2.write(TCS34725_COMMAND_BIT | 0x66);
Wire2.endTransmission();
}
}
//void Adafruit_TCS34725::setIntLimits(uint16_t low, uint16_t high) {
// write8(0x04, low & 0xFF);
// write8(0x05, low >> 8);
// write8(0x06, high & 0xFF);
// write8(0x07, high >> 8);
//}The adafruit header file:
Code:
/**************************************************************************/
/*!
@file Adafruit_TCS34725.h
@author KTOWN (Adafruit Industries)
@section LICENSE
Software License Agreement (BSD License)
Copyright (c) 2013, Adafruit Industries
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**************************************************************************/
#ifndef _TCS34725_H_
#define _TCS34725_H_
#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include <i2c_t3.h>
#define TCS34725_ADDRESS (0x29)
#define TCS34725_COMMAND_BIT (0x80)
#define TCS34725_ENABLE (0x00)
#define TCS34725_ENABLE_AIEN (0x10) /* RGBC Interrupt Enable */
#define TCS34725_ENABLE_WEN (0x08) /* Wait enable - Writing 1 activates the wait timer */
#define TCS34725_ENABLE_AEN (0x02) /* RGBC Enable - Writing 1 actives the ADC, 0 disables it */
#define TCS34725_ENABLE_PON (0x01) /* Power on - Writing 1 activates the internal oscillator, 0 disables it */
#define TCS34725_ATIME (0x01) /* Integration time */
#define TCS34725_WTIME (0x03) /* Wait time (if TCS34725_ENABLE_WEN is asserted) */
#define TCS34725_WTIME_2_4MS (0xFF) /* WLONG0 = 2.4ms WLONG1 = 0.029s */
#define TCS34725_WTIME_204MS (0xAB) /* WLONG0 = 204ms WLONG1 = 2.45s */
#define TCS34725_WTIME_614MS (0x00) /* WLONG0 = 614ms WLONG1 = 7.4s */
#define TCS34725_AILTL (0x04) /* Clear channel lower interrupt threshold */
#define TCS34725_AILTH (0x05)
#define TCS34725_AIHTL (0x06) /* Clear channel upper interrupt threshold */
#define TCS34725_AIHTH (0x07)
#define TCS34725_PERS (0x0C) /* Persistence register - basic SW filtering mechanism for interrupts */
#define TCS34725_PERS_NONE (0b0000) /* Every RGBC cycle generates an interrupt */
#define TCS34725_PERS_1_CYCLE (0b0001) /* 1 clean channel value outside threshold range generates an interrupt */
#define TCS34725_PERS_2_CYCLE (0b0010) /* 2 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_3_CYCLE (0b0011) /* 3 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_5_CYCLE (0b0100) /* 5 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_10_CYCLE (0b0101) /* 10 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_15_CYCLE (0b0110) /* 15 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_20_CYCLE (0b0111) /* 20 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_25_CYCLE (0b1000) /* 25 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_30_CYCLE (0b1001) /* 30 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_35_CYCLE (0b1010) /* 35 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_40_CYCLE (0b1011) /* 40 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_45_CYCLE (0b1100) /* 45 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_50_CYCLE (0b1101) /* 50 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_55_CYCLE (0b1110) /* 55 clean channel values outside threshold range generates an interrupt */
#define TCS34725_PERS_60_CYCLE (0b1111) /* 60 clean channel values outside threshold range generates an interrupt */
#define TCS34725_CONFIG (0x0D)
#define TCS34725_CONFIG_WLONG (0x02) /* Choose between short and long (12x) wait times via TCS34725_WTIME */
#define TCS34725_CONTROL (0x0F) /* Set the gain level for the sensor */
#define TCS34725_ID (0x12) /* 0x44 = TCS34721/TCS34725, 0x4D = TCS34723/TCS34727 */
#define TCS34725_STATUS (0x13)
#define TCS34725_STATUS_AINT (0x10) /* RGBC Clean channel interrupt */
#define TCS34725_STATUS_AVALID (0x01) /* Indicates that the RGBC channels have completed an integration cycle */
#define TCS34725_CDATAL (0x14) /* Clear channel data */
#define TCS34725_CDATAH (0x15)
#define TCS34725_RDATAL (0x16) /* Red channel data */
#define TCS34725_RDATAH (0x17)
#define TCS34725_GDATAL (0x18) /* Green channel data */
#define TCS34725_GDATAH (0x19)
#define TCS34725_BDATAL (0x1A) /* Blue channel data */
#define TCS34725_BDATAH (0x1B)
typedef enum
{
TCS34725_INTEGRATIONTIME_2_4MS = 0xFF, /**< 2.4ms - 1 cycle - Max Count: 1024 */
TCS34725_INTEGRATIONTIME_24MS = 0xF6, /**< 24ms - 10 cycles - Max Count: 10240 */
TCS34725_INTEGRATIONTIME_50MS = 0xEB, /**< 50ms - 20 cycles - Max Count: 20480 */
TCS34725_INTEGRATIONTIME_101MS = 0xD5, /**< 101ms - 42 cycles - Max Count: 43008 */
TCS34725_INTEGRATIONTIME_154MS = 0xC0, /**< 154ms - 64 cycles - Max Count: 65535 */
TCS34725_INTEGRATIONTIME_700MS = 0x00 /**< 700ms - 256 cycles - Max Count: 65535 */
}
tcs34725IntegrationTime_t;
typedef enum
{
TCS34725_GAIN_1X = 0x00, /**< No gain */
TCS34725_GAIN_4X = 0x01, /**< 4x gain */
TCS34725_GAIN_16X = 0x02, /**< 16x gain */
TCS34725_GAIN_60X = 0x03 /**< 60x gain */
}
tcs34725Gain_t;
class Adafruit_TCS34725 {
public:
Adafruit_TCS34725(tcs34725IntegrationTime_t = TCS34725_INTEGRATIONTIME_2_4MS, tcs34725Gain_t = TCS34725_GAIN_1X);
boolean begin(void);
void setIntegrationTime(tcs34725IntegrationTime_t it, int i);
void setGain(tcs34725Gain_t gain, int i);
void getRawData(uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c, int i);
uint16_t calculateColorTemperature(uint16_t r, uint16_t g, uint16_t b);
uint16_t calculateLux(uint16_t r, uint16_t g, uint16_t b);
void write8 (uint8_t reg, uint32_t value, int i);
uint8_t read8 (uint8_t reg, int i);
uint16_t read16 (uint8_t reg, int i);
void setInterrupt(boolean flag);
void clearInterrupt(int i);
void setIntLimits(uint16_t l, uint16_t h);
void enable(void);
private:
boolean _tcs34725Initialised;
tcs34725Gain_t _tcs34725Gain;
tcs34725IntegrationTime_t _tcs34725IntegrationTime;
void disable(void);
};
#endifThank you for your help!
