EEPW论坛

       在搭建完开发环境后还需要将库文件复制到板卡中，库文件的链接是Libraries。需要注意的是要下载对应版本的库文件。下载后是一个压缩包，需要把如下的文件复制到lib文件夹下，复制后效果如下。

       TCS3200颜色传感器是通过红、绿、蓝和透明滤光片获取对应三原色的光强，再将光强转换成对应比例的频率信号。特点是简单易用成本低，缺点是易受环境光的影响而检测出的颜色有误差。所以在获取前需要进行白平衡校准。方式是触发白平衡校准，将传感器放到白色物体面前。主要引脚是S0～4和输出引脚（OUT），S0和S1选择输出频率缩放比例，S2和S3选择激活哪一组滤光二极管。输出引脚（OUT）获取对应三原色的频率信号。

       设计思路是上电需要按D0按键进行白平衡校准，可以多次或使用过程中再次校准。然后按D1按键显示RGB三原色的转换后的值和频率。将这些数值显示在屏幕和通过串口打印出来。 

      完整代码如下

import board
import digitalio
import time
import displayio
import terminalio
from adafruit_display_text import label

# 定义按键变量
Button0_flag = 0
Button1_flag = 0


class TCS3200:
    NUM_CYCLES = 10  # 测试多少个周期

    def __init__(self, s0, s1, s2, s3, out):
        # 初始化控制引脚
        self.s0 = digitalio.DigitalInOut(s0)
        self.s1 = digitalio.DigitalInOut(s1)
        self.s2 = digitalio.DigitalInOut(s2)
        self.s3 = digitalio.DigitalInOut(s3)
        self.out = digitalio.DigitalInOut(out)
        # 配置引脚方向
        self.s0.direction = digitalio.Direction.OUTPUT
        self.s1.direction = digitalio.Direction.OUTPUT
        self.s2.direction = digitalio.Direction.OUTPUT
        self.s3.direction = digitalio.Direction.OUTPUT
        self.out.direction = digitalio.Direction.INPUT
        # 设置频率缩放比为100% (最高精度)
        self.set_frequency_scaling(100)
        # 白平衡校准系数 (初始值为1，需要实际校准)
        self.r_scal = 1.0
        self.g_scal = 1.0
        self.b_scal = 1.0

        print("TCS3200传感器初始化完成")

    def set_frequency_scaling(self, scaling):
        """
        设置传感器的频率缩放比例
        # s0  s1
        # L   L   关闭
        # L   H   2%
        # H   L   20%
        # H   H   100%
        """
        if scaling == 2:  # 2%
            self.s0.value = False
            self.s1.value = True
            # print("TCS3200传感器设置频率缩放比为：%2 -> s0,s1[0,1]")
        elif scaling == 20:  # 20%
            self.s0.value = True
            self.s1.value = False
            # print("TCS3200传感器设置频率缩放比为：%20 -> s0,s1[1,0]")
        elif scaling == 100:  # 100%
            self.s0.value = True
            self.s1.value = True
            # print("TCS3200传感器设置频率缩放比为：%100 -> s0,s1[1,1]")
        else:  # 关闭
            self.s0.value = False
            self.s1.value = False
            # print("TCS3200传感器设置频率缩放比为：%0 -> s0,s1[0,0]")
        time.sleep(0.01)  # 短暂延时稳定频率缩放比例

    def set_color_filter(self, filter_type):
        """
        设置传感器的颜色滤波器
        # s2  s3
        # L   L   Red
        # H   H   Green
        # L   H   Blue
        # H   L   Clear(no filter)
        """
        if filter_type == "Red":
            self.s2.value = False
            self.s3.value = False
            # print("TCS3200传感器设置颜色滤波器为：Red -> s2,s3[0,0]")
        elif filter_type == "Green":
            self.s2.value = True
            self.s3.value = True
            # print("TCS3200传感器设置颜色滤波器为：Green -> s2,s3[1,1]")
        elif filter_type == "Blue":
            self.s2.value = False
            self.s3.value = True
            # print("TCS3200传感器设置颜色滤波器为：Blue -> s2,s3[0,1]")
        else:  # "Clear"
            self.s2.value = True
            self.s3.value = False
            # print("TCS3200传感器设置颜色滤波器为：Clear -> s2,s3[1,0]")
        time.sleep(0.01)  # 短暂延时稳定滤波器

    def measure_frequency(self):
        # 测量频率，并转换单位为Hz
        timestamps = []
        last_state = self.out.value

        while len(timestamps) < self.NUM_CYCLES:
            current_state = self.out.value
            if current_state != last_state:  # 发生边缘变化
                timestamps.append(time.monotonic_ns())
                last_state = current_state
        # 计数周期
        periods = []
        for i in range(2, len(timestamps), 2):
            period_ns = timestamps[i] - timestamps[i - 2]  # 一个完整周期（两个边缘）
            periods.append(period_ns)
        avg_period_ns = sum(periods) / len(periods)
        frequency = 1000000000 / avg_period_ns  # 转换为 Hz
        # print(f"原始频率值 -> Frequency:{frequency:.3f}")

        return frequency

    def read_rgb_freq(self):
        # 读取RGB三个通道的频率值
        red_freq = 0
        green_freq = 0
        blue_freq = 0

        # 读取红色分量 (S2=0, S3=0)
        self.set_color_filter("Red")
        red_freq = self.measure_frequency()
        # 读取绿色分量 (S2=1, S3=1)
        self.set_color_filter("Green")
        green_freq = self.measure_frequency()
        # 读取蓝色分量 (S2=0, S3=1)
        self.set_color_filter("Blue")
        blue_freq = self.measure_frequency()

        # 清除绿色分量 (S2=1, S3=0)
        # self.set_color_filter("Clear")

        # print(f"原始频率值 -> R:{red_freq:.3f}, G:{green_freq:.3f}, B:{blue_freq:.3f}")

        return red_freq, green_freq, blue_freq

    def calibrate_white_balance(self):
        # 白平衡校准 - 将传感器对准白色参考物后调用此方法
        print("正在进行白平衡校准...")
        print("请将传感器对准白色参考物")

        # 读取白色参考物的原始频率
        red, green, blue = self.read_rgb_freq()

        # 换算为RGB值 (18000/255 = 70)
        red = red / 70 if red > 0 else 1.0
        green = green / 70 if green > 0 else 1.0
        blue = blue / 70 if blue > 0 else 1.0

        # 计算校准系数 (假设我们希望白色时RGB值接近255)
        self.r_scal = 255.0 / red if red > 0 else 1.0
        self.g_scal = 255.0 / green if green > 0 else 1.0
        self.b_scal = 255.0 / blue if blue > 0 else 1.0

        print(f"校准完成 -> R:{self.r_scal:.3f}, G:{self.g_scal:.3f}, B:{self.b_scal:.3f}")

    def read_rgb(self):
        # 读取RGB三个通道的频率值，应用白平衡，并转换为RGB
        r = 0
        g = 0
        b = 0

        # 读取RGB三个通道的频率值
        red_freq, green_freq, blue_freq = self.read_rgb_freq()

        # 应用白平衡校准 (18000/255 = 70)
        r = int(red_freq / 70 * self.r_scal)
        g = int(green_freq / 70 * self.g_scal)
        b = int(blue_freq / 70 * self.b_scal)

        # 限制在0-255范围
        r = max(0, min(255, r))
        g = max(0, min(255, g))
        b = max(0, min(255, b))

        return r, g, b


# 初始化板载按键D0/BOOT0，按下接地
button0 = digitalio.DigitalInOut(board.BUTTON)
button0.switch_to_input(pull=digitalio.Pull.UP)

# 初始化板载按键D1，按下接VCC
button1 = digitalio.DigitalInOut(board.D1)
button1.switch_to_input(pull=digitalio.Pull.DOWN)

# 初始化板载LED
led0 = digitalio.DigitalInOut(board.LED)
led0.direction = digitalio.Direction.OUTPUT
led0.value = True

# 初始化颜色传感器LED补光灯
led1 = digitalio.DigitalInOut(board.D5)
led1.direction = digitalio.Direction.OUTPUT
led1.value = True

# 初始化显示屏
display = board.DISPLAY
# 创建显示组
splash = displayio.Group()
display.root_group = splash

# 创建文本标签用于显示RGB值
text_area_l = label.Label(terminalio.FONT, text="", color=0xFFFFFF, x=60, y=20)
text_area_r = label.Label(terminalio.FONT, text="R: ---", color=0xFF0000, x=40, y=40)
text_area_g = label.Label(terminalio.FONT, text="G: ---", color=0x00FF00, x=40, y=60)
text_area_b = label.Label(terminalio.FONT, text="B: ---", color=0x0000FF, x=40, y=80)


# 显示输出
for text_area in (text_area_r, text_area_g, text_area_b, text_area_l):
    splash.append(text_area)
# 创建TCS3200颜色传感器实体
try:
    # 创建TCS3200对象
    color_sensor = TCS3200(
        s0=board.D12,
        s1=board.D11,
        s2=board.D10,
        s3=board.D9,
        out=board.D6,
    )
    print("TCS3200实例创建成功")
except Exception as e:
    print(f"初始化TCS3200失败: {e}")
    # 创建虚拟传感器用于测试
    color_sensor = None
# 主循环
while True:
    led0.value = True
    time.sleep(0.05)

    # 读取按键0
    if not button0.value:
        print("button0按下")
        Button0_flag = 1
        Button1_flag = 0
    # 读取按键1
    if button1.value:
        print("button1按下")
        Button0_flag = 0
        Button1_flag = 1
    if Button0_flag:
        Button0_flag = 0
        # 调用白平衡校准
        color_sensor.calibrate_white_balance()
        # 更新显示
        text_area_l.text = ""
        text_area_r.text = "R: {:.3f}".format(color_sensor.r_scal)
        text_area_g.text = "G: {:.3f}".format(color_sensor.g_scal)
        text_area_b.text = "B: {:.3f}".format(color_sensor.b_scal)
    if Button1_flag:
        # 读取并显示TCS3200颜色传感器的频率值
        if color_sensor is not None:
            try:
                # 调用read_rgb_freq方法读取频率值
                R_Freq, G_Freq, B_Freq = color_sensor.read_rgb_freq()

                # 调用read_rgb方法读取颜色值
                R_Val, G_Val, B_Val = color_sensor.read_rgb()
                # 更新显示
                text_area_l.text = "Val      Freq"
                text_area_r.text = "R: {:3d}     {:.3f}".format(R_Val, R_Freq)
                text_area_g.text = "G: {:3d}     {:.3f}".format(G_Val, G_Freq)
                text_area_b.text = "B: {:3d}     {:.3f}".format(B_Val, B_Freq)

                print("RGB Value:")
                print("RGB: {:3d},{:3d},{:3d}".format(R_Val, G_Val, B_Val))
                print("RGB Frequency:")
                print("RGB: {:.3f},{:.3f},{:.3f}".format(R_Freq, G_Freq, B_Freq))
            except Exception as e:
                print(f"读取颜色传感器错误: {e}")
                R_Val = 128
                G_Val = 128
                B_Val = 128
                R_Freq = 128
                G_Freq = 128
                B_Freq = 129
        else:
            # 更新显示屏
            text_area_r.text = "R: {:3d}  {:.3f}".format(R_Val, R_Freq)
            text_area_g.text = "G: {:3d}  {:.3f}".format(G_Val, G_Freq)
            text_area_b.text = "B: {:3d}  {:.3f}".format(B_Val, B_Freq)
    led0.value = False
    time.sleep(0.05)

       硬件连接如图

       我是通过屏幕在线测试获取白色、红色、绿色和蓝色，发现环境光影响比较大。效果如下

校准

红色

绿色

蓝色