real_color  red  green  blue     recognized
white         70   70   100       3  = cyan
green         20    0   120       1  = violet
violet        10    0    90       1/2= violet/blue
cyan          16    8   120       2  = blue
yellow        80   50   105       11 = lightViolet
orange        20    0    60       3  = cyan
red           60    0    20       10 = pink
light blue    40    2   120       1  = violet
 

//////////////////////////////////////////////////////////////////////////////////////////
//
//                        Hitechnic Color Sensor Example
//                        ==============================
//
// This file is a small application program that tests the NXT Color Sensor from HiTechnic.
//
// The program:
//  1. Configures sensor port 'S2' as a HiTechnic color sensor.
//  2. Displays the current color components (red, green, blue) on the NXT LCD.
//  3. Checks to see whether the current color matches one of two predefined colors. If so
//     a unique tone is played on the NXT speaker to indicate which of the two colors were
//     matched.
//
// This sample provides a good framework for easy cut and paste and
//
//////////////////////////////////////////////////////////////////////////////////////////
 
#pragma platform (NXT, FTC)
 
const tSensors kColorSensorPort   = S2; // We want the color sensor to be on port "S2"
 
#include "AdvancedSensors.c"
 
    //
    // Get the colors from the sensor and display on the NXT LCD
    //
    int nRed;
    int nGreen;
    int nBlue;
    short nColor;
    string strColor;
 

void Color2String(short color, string &sbuf)
{
 
  if (color==0) sbuf="black";
  else
  if (color==1) sbuf="violet";
  else
  if (color==2) sbuf="blue";
  else
  if (color==3) sbuf="cyan";
  else
  if (color==4) sbuf="green";
  else
  if (color==5) sbuf="YeGreen";
  else
  if (color==6) sbuf="yellow";
  else
  if (color==7) sbuf="orange";
  else
  if (color==8) sbuf="red";
  else
  if (color==9) sbuf="magenta";
  else
  if (color==10) sbuf="pink";
  else
  if (color==11) sbuf="lViolet";
  else
  if (color==12) sbuf="lCyan";
  else
  if (color==13) sbuf="lYellow";
  else
  if (color==14) sbuf="lOrange";
  else
  if (color==15) sbuf="lRed";
  else
  if (color==16) sbuf="lPink";
  else
  if (color==17) sbuf="white";
 
}
 

task main()
{
  long nCycles = 0;
 
  SensorType[kColorSensorPort] = sensorI2CHiTechnicColor; // Configure the sensor
 
  nxtDisplayTextLine(1, "Port: S%d", kColorSensorPort + 1);
  while (true)
  {
 
    getRGB(kColorSensorPort, nRed, nGreen, nBlue);
    nColor=SensorValue[kColorSensorPort];
    Color2String(nColor,strColor);
 
    nxtDisplayTextLine(2, "Color:%3d %s", nColor, strColor);
    nxtDisplayTextLine(3, "Red:  %3d", nRed);
    nxtDisplayTextLine(4, "Green:%3d", nGreen);
    nxtDisplayTextLine(5, "Blue: %3d", nBlue);
 
    //
    // Use utility routine to see if current color detected is close enough
    // to a specific target color.
    //
 
    //
    // To determine the color constants to match on, manually "watch" the output from the
    // color sensor and record the components of a target color. Edit the data below
    //
    // Adjust the "kRange" constant as appropriate to determine how close the target colors have to
    // be to detect a specific color.
    //
    const int kRedTarget1    =  20;
    const int kGreenTarget1  =   0;
    const int kBlueTarget1   =   0;
 
    const int kRedTarget2    =  52;
    const int kGreenTarget2  =   0;
    const int kBlueTarget2   =   0;
 
    const int kColorRange    =  10;
 
    if (bColorMatched(kColorSensorPort, kRedTarget1, kGreenTarget1, kBlueTarget1, kColorRange))
      PlayTone(400, 20);
 
    else if (bColorMatched(kColorSensorPort, kRedTarget2, kGreenTarget2, kBlueTarget2, kColorRange))
      PlayTone(800, 20);
 
    else
      ClearSounds();
 
    // Display the number of cycles on the LCD. It runs pretty fast.
 
    ++nCycles;
    nxtDisplayTextLine(7, "Cycles: %d",  nCycles);
  }
  return;
}
 

writeI2Cvalue(byte value, byte location, byte port)
// and
readI2Cvalue(byte &value, byte location, byte port)

#pragma config(Sensor, S1,     HTC,                 sensorI2CHiTechnicColor)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//

#include "i2c.h"

void calibrateSensor(tSensors _link) {
  // we need to send the command 0x43 to register 0x41
  byte_array _data;
  _data[0] = 3;           // the size of our message
  _data[1] = _link;       // the sensor port our sensor is attached to
  _data[2] = 0x41;        // the register we're writing to
  _data[3] = 0x43;        // the command we're sending (calibrate)

  writeI2Cvalue(_link, _data, 0);
}

task main() {
  calibrateSensor(HTC);
  while(true) {
    wait1Msec(10);
  }
}

#ifndef __I2C_H__
#define __I2C_H__

#define MAX_ARR_SIZE 16
typedef byte byte_array[MAX_ARR_SIZE];

void clearI2CBus(tSensors _link);
void waitForI2CBus(tSensors _link);
void writeI2Cvalue(tSensors _link, byte_array &_data, int _replylen);
void readI2Cvalue(tSensors _link, byte_array &_data, int _replylen);

/*
  =============================================================================
  Clear the I2C bus before we send new data.

 */
void clearI2CBus(tSensors _link) {
  ubyte _tmp = 0;
  while (nI2CBytesReady[_link] > 0)
    readI2CReply(_link, _tmp, 1);
}

/*
  =============================================================================
  We wait for the I2C bus to be ready for the next message or emit a
  loud annoying buzz sound if there's an error.
  Taken from RobotC example code and modified.

 */
void waitForI2CBus(tSensors _link)
{
   byte _tmp = 0;
   TI2CStatus nStatus;

   while (true)
   {
      nStatus = nI2CStatus[_link];
      switch (nStatus)
      {
      case NO_ERR:
      return;

      case STAT_COMM_PENDING:
         break;

      case ERR_COMM_BUS_ERR:
         PlaySound(soundLowBuzz);
         while (bSoundActive) {}
         // clear out any old buffers.
      clearI2CBus(_link);
         return;
      }
   }
}

void writeI2Cvalue(tSensors _link, byte_array &_data, int _replylen) {
  clearI2CBus(_link);
  waitForI2CBus(_link);
  sendI2CMsg(_link, _data[0], _replylen);
  waitForI2CBus(_link);
}

void readI2Cvalue(tSensors _link, byte_array &_data, int _replylen) {
  readI2CReply(_link, _data[0], _replylen);
  waitForI2CBus(_link);
}


#endif // __I2C_H__

real_color  red  green  blue     recognized
white         70   50   110       3  = cyan // 1.0 cm distance
white         80   60   130       3  = cyan // 1.5 cm distance

real_color  red  green  blue     recognized
white         70   48   120       3  = cyan
// up to
white         66   12   82        3  = cyan

const tSensors kColorSensorPort   = S2;
SensorType[kColorSensorPort] = sensorI2CCustom;

#include "i2c.h"

const tSensors HTC   = S1;

void calibrateSensor(tSensors _link) {
  // we need to send the command 0x43 to register 0x41
  byte_array _data;
  _data[0] = 3;           // the size of our message
  _data[1] = _link;       // the sensor port our sensor is attached to
  _data[2] = 0x41;        // the register we're writing to
  _data[3] = 0x43;        // the command we're sending (calibrate)

  writeI2Cvalue(_link, _data, HTC);
}

task main() {

  SensorType[HTC] = sensorI2CCustom;

  calibrateSensor(HTC);

  wait1Msec(2000);

}

real_color  red  green  blue     recognized
white         60   30   110       3  = cyan