//把TCS3200颜色传感器各控制引脚连到Arduino数字端口

#define S0    6   //物体表面的反射光越强，TCS3002D内置振荡器产生的方波频率越高，

#define S1    5   //S0和S1的组合决定输出信号频率比例因子，比例因子为2%

                 //比率因子为TCS3200传感器OUT引脚输出信号频率与其内置振荡器频率之比

#define S2     4   //S2和S3的组合决定让红、绿、蓝，哪种光线通过滤波器

#define S3     3

#define OUT    2   //TCS3200颜色传感器输出信号连接到Arduino中断0引脚，并引发脉冲信号中断

                  //在中断函数中记录TCS3200输出信号的脉冲个数

#define LED    7   //控制TCS3200颜色传感器是否点亮LED灯

float g_SF[3];     //从TCS3200输出信号的脉冲数转换为RGB标准值的RGB比例因子

int   g_count = 0;   // 计算与反射光强相对应TCS3200颜色传感器输出信号的脉冲数

// 数组用于存储在1s内TCS3200输出信号的脉冲数，它乘以RGB比例因子就是RGB标准值

int   g_array[3];  

int   g_flag = 0;   // 滤波器模式选择顺序标志

// 初始化TSC3200各控制引脚的输入输出模式

//设置TCS3002D的内置振荡器方波频率与其输出信号频率的比例因子为2%

void TSC_Init()

{

  pinMode(S0, OUTPUT);

  pinMode(S1, OUTPUT);

  pinMode(S2, OUTPUT);

  pinMode(S3, OUTPUT);

  pinMode(OUT, INPUT);

  pinMode(LED, OUTPUT);

  digitalWrite(S0, LOW);

  digitalWrite(S1, HIGH);

}

//选择滤波器模式，决定让红、绿、蓝，哪种光线通过滤波器

void TSC_FilterColor(int Level01, int Level02)

{

  if(Level01 != 0)

    Level01 = HIGH;

  if(Level02 != 0)

    Level02 = HIGH;

  digitalWrite(S2, Level01);

  digitalWrite(S3, Level02);

}

//中断函数，计算TCS3200输出信号的脉冲数

void TSC_Count()

{

  g_count ++ ;

}

//定时器中断函数，每1s中断后，把该时间内的红、绿、蓝三种光线通过滤波器时，

//TCS3200输出信号脉冲个数分别存储到数组g_array[3]的相应元素变量中

void TSC_Callback()

{

  switch(g_flag)

  {

    case 0:

         Serial.println("->WB Start");

         TSC_WB(LOW, LOW);   //选择让红色光线通过滤波器的模式

         break;

    case 1:

         Serial.print("->Frequency R=");

         Serial.println(g_count);   //打印1s内的红光通过滤波器时，TCS3200输出的脉冲个数

         g_array[0] = g_count;    //存储1s内的红光通过滤波器时，TCS3200输出的脉冲个数

         TSC_WB(HIGH, HIGH);   //选择让绿色光线通过滤波器的模式

         break;

    case 2:

         Serial.print("->Frequency G=");

         Serial.println(g_count);   //打印1s内的绿光通过滤波器时，TCS3200输出的脉冲个数

         g_array[1] = g_count;    //存储1s内的绿光通过滤波器时，TCS3200输出的脉冲个数

         TSC_WB(LOW, HIGH);   //选择让蓝色光线通过滤波器的模式

         break;

    case 3:

         Serial.print("->Frequency B=");

         Serial.println(g_count);   //打印1s内的蓝光通过滤波器时，TCS3200输出的脉冲个数

         Serial.println("->WB End");

         g_array[2] = g_count;     //存储1s内的蓝光通过滤波器时，TCS3200输出的脉冲个数

         TSC_WB(HIGH, LOW);   //选择无滤波器的模式  

         break;

   default:

         g_count = 0;     //计数值清零

         break;

  }

}

//设置反射光中红、绿、蓝三色光分别通过滤波器时如何处理数据的标志

//该函数被TSC_Callback( )调用

void TSC_WB(int Level0, int Level1)   

{

  g_count = 0;   //计数值清零

  g_flag ++;     //输出信号计数标志

  TSC_FilterColor(Level0, Level1); //滤波器模式

  Timer1.setPeriod(1000000);     //设置输出信号脉冲计数时长1s

}

//初始化

void setup()

{

  TSC_Init();

  Serial.begin(9600); //启动串行通信

  Timer1.initialize();   // defaulte is 1s

  Timer1.attachInterrupt(TSC_Callback); //设置定时器1的中断，中断调用函数为TSC_Callback()

  //设置TCS3200输出信号的上跳沿触发中断，中断调用函数为TSC_Count()

  attachInterrupt(0, TSC_Count, RISING);

  digitalWrite(LED, HIGH);//点亮LED灯

  delay(4000); //延时4s，以等待被测物体红、绿、蓝三色在1s内的TCS3200输出信号脉冲计数

  //通过白平衡测试，计算得到白色物体RGB值255与1s内三色光脉冲数的RGB比例因子

  g_SF[0] = 255.0/ g_array[0];     //红色光比例因子

  g_SF[1] = 255.0/ g_array[1] ;    //绿色光比例因子

  g_SF[2] = 255.0/ g_array[2] ;    //蓝色光比例因子

  //打印白平衡后的红、绿、蓝三色的RGB比例因子

  Serial.println(g_SF[0],5);

  Serial.println(g_SF[1],5);

  Serial.println(g_SF[2],5);

  //红、绿、蓝三色光分别对应的1s内TCS3200输出脉冲数乘以相应的比例因子就是RGB标准值

  //打印被测物体的RGB值

  for(int i=0; i<3; i++)

    Serial.println(int(g_array[i] * g_SF[i]));   

}

//主程序

void loop()

{

   g_flag = 0;

   //每获得一次被测物体RGB颜色值需时4s

   delay(4000);

   //打印出被测物体RGB颜色值

   for(int i=0; i<3; i++)

      Serial.println(int(g_array[i] * g_SF[i]));

}

#define OLED_CS 12

#define OLED_CLK 10

#define OLED_MOSI 9

#define OLED_RESET 13

#include "SSD1306.h"

SSD1306 oled(OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

#define NUMFLAKES 10

#define XPOS 0

#define YPOS 1

#define DELTAY 2

#define LOGO16_GLCD_HEIGHT 16

#define LOGO16_GLCD_WIDTH   16

static const unsigned char __attribute__ ((progmem)) logo16_glcd_bmp[]={

0x30, 0xf0, 0xf0, 0xf0, 0xf0, 0x30, 0xf8, 0xbe, 0x9f, 0xff, 0xf8, 0xc0, 0xc0, 0xc0, 0x80, 0x00,

0x20, 0x3c, 0x3f, 0x3f, 0x1f, 0x19, 0x1f, 0x7b, 0xfb, 0xfe, 0xfe, 0x07, 0x07, 0x07, 0x03, 0x00, };

void setup()   {               

  Serial.begin(9600);

  // If you want to provide external 7-9V VCC, uncomment next line and comment the one after

  //oled.ssd1306_init(SSD1306_EXTERNALVCC);

  // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)

  oled.ssd1306_init(SSD1306_SWITCHCAPVCC);

  // init done

  oled.display(); // show splashscreen

  delay(2000);

  oled.clear();   // clears the screen and buffer

  // Fill screen

  oled.fillrect(0, 0, SSD1306_LCDWIDTH-1, SSD1306_LCDHEIGHT-1, WHITE);

  oled.display();

  delay(2000);

  // draw a single pixel

  oled.setpixel(10, 10, WHITE);

  oled.display();

  delay(2000);

  oled.clear();

  // draw many lines

  testdrawline();

  oled.display();

  delay(2000);

  oled.clear();

  // draw rectangles

  testdrawrect();

  oled.display();

  delay(2000);

  oled.clear();

  // draw multiple rectangles

  testfillrect();

  oled.display();

  delay(2000);

  oled.clear();

  // draw mulitple circles

  testdrawcircle();

  oled.display();

  delay(2000);

  oled.clear();

  // draw a white circle, 10 pixel radius, at location (32,32)

  oled.fillcircle(32, 32, 10, WHITE);

  oled.display();

  delay(2000);

  oled.clear();

  // draw the first ~12 characters in the font

  testdrawchar();

  oled.display();

  delay(2000);

  oled.clear();

  // draw a string at location (0,0)

  oled.drawstring(0, 0, "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation");

  oled.display();

  delay(2000);

  oled.clear();

  // miniature bitmap display

  oled.drawbitmap(30, 16,   logo16_glcd_bmp, 16, 16, 1);

  oled.display();

  // invert the display

  oled.ssd1306_command(SSD1306_INVERTDISPLAY);

  delay(1000);

  oled.ssd1306_command(SSD1306_NORMALDISPLAY);

  delay(1000);

  // draw a bitmap icon and 'animate' movement

  testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH);

}

void loop()                     

{

  for (uint8_t i=0; i<SSD1306_LCDWIDTH; i++) {

    for (uint8_t j=0; j<SSD1306_LCDHEIGHT; j++) {

      oled.setpixel(i, j, WHITE);

      oled.display();

    }

  }

}

void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) {

  uint8_t icons[NUMFLAKES][3];

  srandom(666);     // whatever seed

  // initialize

  for (uint8_t f=0; f< NUMFLAKES; f++) {

    icons[f][XPOS] = random() % SSD1306_LCDWIDTH;

    icons[f][YPOS] = 0;

    icons[f][DELTAY] = random() % 5 + 1;

    Serial.print("x: ");

    Serial.print(icons[f][XPOS], DEC);

    Serial.print(" y: ");

    Serial.print(icons[f][YPOS], DEC);

    Serial.print(" dy: ");

    Serial.println(icons[f][DELTAY], DEC);

  }

  while (1) {

    // draw each icon

    for (uint8_t f=0; f< NUMFLAKES; f++) {

      oled.drawbitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, WHITE);

    }

    oled.display();

    delay(200);

    // then erase it + move it

    for (uint8_t f=0; f< NUMFLAKES; f++) {

      oled.drawbitmap(icons[f][XPOS], icons[f][YPOS],   logo16_glcd_bmp, w, h, BLACK);

      // move it

      icons[f][YPOS] += icons[f][DELTAY];

      // if its gone, reinit

      if (icons[f][YPOS] > SSD1306_LCDHEIGHT) {

        icons[f][XPOS] = random() % SSD1306_LCDWIDTH;

        icons[f][YPOS] = 0;

        icons[f][DELTAY] = random() % 5 + 1;

      }

    }

  }

}

void testdrawchar(void) {

  for (uint8_t i=0; i < 168; i++) {

    oled.drawchar((i % 21) * 6, i/21, i);

  }   

}

void testdrawcircle(void) {

  for (uint8_t i=0; i<SSD1306_LCDHEIGHT; i+=2) {

    oled.drawcircle(63, 31, i, WHITE);

  }

}

void testdrawrect(void) {

  for (uint8_t i=0; i<SSD1306_LCDHEIGHT; i+=2) {

    oled.drawrect(i, i, SSD1306_LCDWIDTH-i, SSD1306_LCDHEIGHT-i, WHITE);

  }

}

void testfillrect(void) {

  for (uint8_t i=0; i<SSD1306_LCDHEIGHT; i++) {

      // alternate colors for moire effect

    oled.fillrect(i, i, SSD1306_LCDWIDTH-i, SSD1306_LCDHEIGHT-i, i%2);

  }

}

void testdrawline() {

  for (uint8_t i=0; i<SSD1306_LCDWIDTH; i+=4) {

    oled.drawline(0, 0, i, SSD1306_LCDHEIGHT-1, WHITE);

    oled.display();

  }

  for (uint8_t i=0; i<SSD1306_LCDHEIGHT; i+=4) {

    oled.drawline(0, 0, SSD1306_LCDWIDTH-1, i, WHITE);

    oled.display();

  }

  delay(1000);

  for (uint8_t i=0; i<SSD1306_LCDWIDTH; i+=4) {

    oled.drawline(i, SSD1306_LCDHEIGHT-1, 0, 0, BLACK);

    oled.display();

  }

  for (uint8_t i=0; i<SSD1306_LCDHEIGHT; i+=4) {

    oled.drawline(SSD1306_LCDWIDTH - 1, i, 0, 0, BLACK);

    oled.display();

  }

}

void setup() {

  pinMode(PIN_SENSOR, INPUT);

  Serial.begin(9600);

}

void loop() {

  int x = digitalRead(PIN_SENSOR);

  Serial.println(x);

}