STM32模拟I2C获取TCS34725光学颜色传感器数据

这篇具有很好参考价值的文章主要介绍了STM32模拟I2C获取TCS34725光学颜色传感器数据。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

STM32模拟I2C获取TCS34725光学颜色传感器数据

TCS34725是RGB三色颜色传感器,和TCS34727都属于TCS3472系列,在电气特性上略有差别,TCS34727相比TCS34725在I2C总线的访问电平上可以更低,而在I2C软件访问地址方面则一致。
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472

tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
TCS3472内部有4个PD(光电二极管),一个接收clear light(净光,未做任何处理),另外三个分别接收Red, Green, Blue的三色光,并且会滤除红外光。

TCS3472访问特征

  1. TCS34725和TCS34727软件方面在Device ID不同(非I2C访问地址),其它方面则相同。
    tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
  2. TCS3472在做寄存器访问时,5位寄存器地址在命令字节里发布:
    tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
    而在进行有效的命令字节发布时,这个字节最高位要求为1。而命令字节的TYPE则是访问过程的功能指定,为00时说明后面按byte直接访问寄存器,为01则说明后面按照byte连续操作方式操作寄存器(连读),这个时候有个影子寄存器的功能,保证对于两个字节的数据读取,前一个字节读的时候后一个字节被保护,避免前一个字节读完要读后一个字节前,后一个寄存器的数据被新的数据过来改写了,从而产生不一致。10为保留无功能。11则为特殊功能指定,在原本指定地址的位置,可以设置具体的特殊功能,当前只有00110一个功能。
    tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472

3 通过使能AEN位可以启动光学颜色检测,而WEN位用于控制运行模式,WEN设置为0,则光学检测是循环无间断进行,前一次检测出来马上进行下一次检测(每次检测占用一定的延时);当WEN设置为1,则两次检测之间可以插入等待时间,起到节省功耗的作用。AIEN位则是控制是否使用门限可设置的中断产生。
4. TCS3472的输出寄存器是16位,采用可控制积分时间和放大增益的方式,所以得到的结果可以大于255,更长的积分时间和放大增益用于距离较远或者弱光环境的测试。tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
积分时间为2.4ms相当于进行了10次ADC采样值的求和。
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
有4级接收光强放大可选,分别为1倍,4倍,16倍和60倍。

STM32工程配置

这里以STM32F103C6T6芯片及STM32CUBEIDE开发环境,实现访问获取TCS34725传感器的数据。
首先建立工程并配置时钟:
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
配置PB12和PB13作为模拟I2C的管脚:
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
采用USB虚拟串口作为输出方式,配置USB虚拟串口:
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472
保存并生成基础工程代码:
tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472

STM32模拟I2C协议代码

STM32模拟I2C协议代码需要用到微秒延时函数,这里采用 STM32 HAL us delay(微秒延时)的指令延时实现方式及优化 。

TCS3472访问部分的函数为:

#define us_num 50

#define SCL_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET)
#define SCL_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET)
#define SDA_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_SET)
#define SDA_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET)
#define SDA_IN HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13)

void I2C_Init(void)
{
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(1000000) ;
}

void I2C_Start(void)
{
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_L;
}

void I2C_Stop(void)
{
	SCL_OUT_L;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num) ;
}

void I2C_Write_Ack(void)
{

    PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_H;

}

uint8_t I2C_Read_Ack(void)
{
	uint8_t status=0;

	SCL_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	status = SDA_IN;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_L;

	return status;

}


void I2C_Send_Byte(uint8_t txd)
{


    for(uint8_t i=0;i<8;i++)
    {
    	PY_Delay_us_t(us_num/2) ;
        if((txd&0x80)>>7) SDA_OUT_H;
        else SDA_OUT_L;
        txd<<=1;
        PY_Delay_us_t(us_num/2) ;
        SCL_OUT_H;
        PY_Delay_us_t(us_num) ;
		SCL_OUT_L;
    }

    SDA_OUT_L;
}

uint8_t I2C_Read_Byte(unsigned char rdack)
{
	uint8_t rxd=0;


    for(uint8_t i=0;i<8;i++ )
	{
    	SCL_OUT_L;
    	PY_Delay_us_t(us_num/2) ;
    	SDA_OUT_H;
    	PY_Delay_us_t(us_num/2) ;
    	SCL_OUT_H;
        rxd<<=1;
        if(SDA_IN) rxd++;
        PY_Delay_us_t(us_num) ;
    }

    SCL_OUT_L;
    SDA_OUT_H;

    if (rdack) I2C_Write_Ack();

    return rxd;
}

uint8_t TCS3472_Enable_Status = 0;
void TCS3472_WRITE( uint8_t WrAddr, uint8_t data)
{
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(WrAddr|0x80);
  	  I2C_Read_Ack();
  	  I2C_Send_Byte(data);
  	  I2C_Read_Ack();
  	  I2C_Stop();
}

uint8_t TCS3472_READ_1Byte( uint8_t RdAddr)
{

	  uint8_t RegValue = 0;
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(RdAddr|0x80); //Repeated byte protocol transaction
  	  I2C_Read_Ack();

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  RegValue=I2C_Read_Byte(0);
  	  I2C_Stop();

	  return RegValue;
}

uint16_t TCS3472_READ_2Byte( uint8_t RdAddr)
{

	  uint8_t RegValueH = 0, RegValueL = 0;
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(RdAddr|0xa0); //Auto-increment protocol transaction
  	  I2C_Read_Ack();

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  RegValueL=I2C_Read_Byte(1);
	  RegValueH=I2C_Read_Byte(0);
  	  I2C_Stop();

	  return (((uint16_t)RegValueH)<<8)|RegValueL;
}
void TCS3472_PON_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_PON;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_PON_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_PON);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}


void TCS3472_AEN_Enable(void)
{
	TCS3472_Enable_Status |=  TCS3472_ENABLE_AEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_AEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_AEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_WEN_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_WEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_WEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_WEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_AIEN_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_AIEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_AIEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_AIEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

uint8_t TCS3472_ID_Verification(void)
{
	uint8_t id;
	id = TCS3472_READ_1Byte(TCS3472_ID);
	if((id==0x44)||(id==0x4d)) return 1;
	else return 0;
}

COLOR_RGBC rgb;
COLOR_HSL  hsl;

//Conversion of RGB to HSL
void RGBtoHSL(COLOR_RGBC *Rgb, COLOR_HSL *Hsl)
{
	uint8_t maxVal,minVal,difVal;
	uint8_t r = Rgb->r*100/Rgb->c;   //[0-100]
	uint8_t g = Rgb->g*100/Rgb->c;
	uint8_t b = Rgb->b*100/Rgb->c;

	maxVal = max3v(r,g,b);
	minVal = min3v(r,g,b);
	difVal = maxVal-minVal;

	//Lightness
	Hsl->l = (maxVal+minVal)/2;   //[0-100]

	if(maxVal == minVal)//if r=g=b, grey
	{
		Hsl->h = 0;
		Hsl->s = 0;
	}
	else
	{
		//Hue
		if(maxVal==r)
		{
			if(g>=b)
				Hsl->h = 60*(g-b)/difVal;
			else
				Hsl->h = 60*(g-b)/difVal+360;
		}
		else
			{
				if(maxVal==g)Hsl->h = 60*(b-r)/difVal+120;
				else
					if(maxVal==b)Hsl->h = 60*(r-g)/difVal+240;
			}

		//Saturation
		if(Hsl->l<=50)Hsl->s=difVal*100/(maxVal+minVal);  //[0-100]
		else
			Hsl->s=difVal*100/(200-(maxVal+minVal));
	}
}

STM32完整工程代码

完整工程代码先读取Device ID以判断基本访问是否正常,再进行积分时间24ms及增益1x的配置,再开始数据采样和读取,读取到的数据是积分后的数据,并进行HSL格式的转换。通过USB虚拟串口将数据打印输出。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
//Written by Pegasus Yu in 2022
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usb_device.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <math.h>

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
__IO float usDelayBase;
void PY_usDelayTest(void)
{
  __IO uint32_t firstms, secondms;
  __IO uint32_t counter = 0;

  firstms = HAL_GetTick()+1;
  secondms = firstms+1;

  while(uwTick!=firstms) ;

  while(uwTick!=secondms) counter++;

  usDelayBase = ((float)counter)/1000;
}

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

void PY_usDelayOptimize(void)
{
  __IO uint32_t firstms, secondms;
  __IO float coe = 1.0;

  firstms = HAL_GetTick();
  PY_Delay_us_t(1000000) ;
  secondms = HAL_GetTick();

  coe = ((float)1000)/(secondms-firstms);
  usDelayBase = coe*usDelayBase;
}

void PY_Delay_us(uint32_t Delay)
{
  __IO uint32_t delayReg;

  __IO uint32_t msNum = Delay/1000;
  __IO uint32_t usNum = (uint32_t)((Delay%1000)*usDelayBase);

  if(msNum>0) HAL_Delay(msNum);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}


/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define us_num 50

#define SCL_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET)
#define SCL_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET)
#define SDA_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_SET)
#define SDA_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET)
#define SDA_IN HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13)

void I2C_Init(void)
{
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(1000000) ;
}

void I2C_Start(void)
{
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_L;
}

void I2C_Stop(void)
{
	SCL_OUT_L;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num) ;
}

void I2C_Write_Ack(void)
{

    PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_H;

}

uint8_t I2C_Read_Ack(void)
{
	uint8_t status=0;

	SCL_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	status = SDA_IN;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_L;

	return status;

}


void I2C_Send_Byte(uint8_t txd)
{


    for(uint8_t i=0;i<8;i++)
    {
    	PY_Delay_us_t(us_num/2) ;
        if((txd&0x80)>>7) SDA_OUT_H;
        else SDA_OUT_L;
        txd<<=1;
        PY_Delay_us_t(us_num/2) ;
        SCL_OUT_H;
        PY_Delay_us_t(us_num) ;
		SCL_OUT_L;
    }

    SDA_OUT_L;
}

uint8_t I2C_Read_Byte(unsigned char rdack)
{
	uint8_t rxd=0;


    for(uint8_t i=0;i<8;i++ )
	{
    	SCL_OUT_L;
    	PY_Delay_us_t(us_num/2) ;
    	SDA_OUT_H;
    	PY_Delay_us_t(us_num/2) ;
    	SCL_OUT_H;
        rxd<<=1;
        if(SDA_IN) rxd++;
        PY_Delay_us_t(us_num) ;
    }

    SCL_OUT_L;
    SDA_OUT_H;

    if (rdack) I2C_Write_Ack();

    return rxd;
}

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
uint8_t TCS3472_Enable_Status = 0;
void TCS3472_WRITE( uint8_t WrAddr, uint8_t data)
{
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(WrAddr|0x80);
  	  I2C_Read_Ack();
  	  I2C_Send_Byte(data);
  	  I2C_Read_Ack();
  	  I2C_Stop();
}

uint8_t TCS3472_READ_1Byte( uint8_t RdAddr)
{

	  uint8_t RegValue = 0;
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(RdAddr|0x80); //Repeated byte protocol transaction
  	  I2C_Read_Ack();

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  RegValue=I2C_Read_Byte(0);
  	  I2C_Stop();

	  return RegValue;
}

uint16_t TCS3472_READ_2Byte( uint8_t RdAddr)
{

	  uint8_t RegValueH = 0, RegValueL = 0;
	  uint8_t daddr = 0x52; //TCS3472 device address (0x29<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(RdAddr|0xa0); //Auto-increment protocol transaction
  	  I2C_Read_Ack();

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  RegValueL=I2C_Read_Byte(1);
	  RegValueH=I2C_Read_Byte(0);
  	  I2C_Stop();

	  return (((uint16_t)RegValueH)<<8)|RegValueL;
}
void TCS3472_PON_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_PON;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_PON_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_PON);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}


void TCS3472_AEN_Enable(void)
{
	TCS3472_Enable_Status |=  TCS3472_ENABLE_AEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_AEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_AEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_WEN_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_WEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_WEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_WEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

void TCS3472_AIEN_Enable(void)
{
	TCS3472_Enable_Status |= TCS3472_ENABLE_AIEN;

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}
void TCS3472_AIEN_Disable(void)
{
	TCS3472_Enable_Status &= (~TCS3472_ENABLE_AIEN);

	TCS3472_WRITE(TCS3472_ENABLE, TCS3472_Enable_Status);
}

uint8_t TCS3472_ID_Verification(void)
{
	uint8_t id;
	id = TCS3472_READ_1Byte(TCS3472_ID);
	if((id==0x44)||(id==0x4d)) return 1;
	else return 0;
}

COLOR_RGBC rgb;
COLOR_HSL  hsl;

//Conversion of RGB to HSL
void RGBtoHSL(COLOR_RGBC *Rgb, COLOR_HSL *Hsl)
{
	uint8_t maxVal,minVal,difVal;
	uint8_t r = Rgb->r*100/Rgb->c;   //[0-100]
	uint8_t g = Rgb->g*100/Rgb->c;
	uint8_t b = Rgb->b*100/Rgb->c;

	maxVal = max3v(r,g,b);
	minVal = min3v(r,g,b);
	difVal = maxVal-minVal;

	//Lightness
	Hsl->l = (maxVal+minVal)/2;   //[0-100]

	if(maxVal == minVal)//if r=g=b, grey
	{
		Hsl->h = 0;
		Hsl->s = 0;
	}
	else
	{
		//Hue
		if(maxVal==r)
		{
			if(g>=b)
				Hsl->h = 60*(g-b)/difVal;
			else
				Hsl->h = 60*(g-b)/difVal+360;
		}
		else
			{
				if(maxVal==g)Hsl->h = 60*(b-r)/difVal+120;
				else
					if(maxVal==b)Hsl->h = 60*(r-g)/difVal+240;
			}

		//Saturation
		if(Hsl->l<=50)Hsl->s=difVal*100/(maxVal+minVal);  //[0-100]
		else
			Hsl->s=difVal*100/(200-(maxVal+minVal));
	}
}
/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
char PY_Str[512];

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();

  if (!TCS3472_ID_Verification())  //For communication error verification
  {
	  while(1)
	  {
		  CDC_Transmit_FS("ID READ ERROR!\r\n", strlen("ID READ ERROR!\r\n"));
		  PY_Delay_us(2000000);
	  }
  }
  else  //Initial config
  {
	  TCS3472_PON_Enable(); //Other register config must be after TCS3472_PON_Enable().

	  TCS3472_WRITE(TCS3472_ATIME, TCS3472_INTEGRATIONTIME_24MS);
	  TCS3472_WRITE(TCS3472_CONTROL, TCS3472_GAIN_1X);

	  TCS3472_AEN_Enable();
  }

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

      if(TCS3472_READ_1Byte(TCS3472_STATUS) & TCS3472_STATUS_AVALID)
      {
    	  (&rgb)->c = TCS3472_READ_2Byte(TCS3472_CDATAL);
    	  (&rgb)->r	= TCS3472_READ_2Byte(TCS3472_RDATAL);
    	  (&rgb)->g	= TCS3472_READ_2Byte(TCS3472_GDATAL);
		  (&rgb)->b = TCS3472_READ_2Byte(TCS3472_BDATAL);

    	  sprintf( PY_Str, "Clear light value: %d\r\nRed light value: %d\r\nGreen light value: %d\r\nBlue light value: %d\r\n\r\n", (&rgb)->c, (&rgb)->r, (&rgb)->g, (&rgb)->b );
    	  CDC_Transmit_FS(PY_Str, strlen(PY_Str));
    	  PY_Delay_us(1000000);

    	  RGBtoHSL(&rgb,&hsl);
    	  sprintf( PY_Str, "Hue value: %d\r\nSaturation value: %d\r\nLightness value: %d\r\n\r\n", (&hsl)->h, (&hsl)->s, (&hsl)->l );
    	  CDC_Transmit_FS(PY_Str, strlen(PY_Str));

    	  PY_Delay_us(1000000);
      }
      else PY_Delay_us(1);

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL_DIV1_5;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12|GPIO_PIN_13, GPIO_PIN_SET);

  /*Configure GPIO pins : PB12 PB13 */
  GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */


代码执行输出效果

代码执行输出效果如下:

tcs3472,STM32,stm32,TCS34725,颜色传感器,颜色识别,TCS3472

例程下载

STM32F103C6T6获取TCS34725光学颜色传感器数据范例下载(STM32CUBEIDE工程):

可以调整光照强度,颜色物体厚度及背景反光情况进行效果优化。也可以将数据通过全彩显示屏显示以对比颜色及做校准,参考 STM32驱动0.96寸TFT 彩色LCD模块显示 。

–End –文章来源地址https://www.toymoban.com/news/detail-573167.html

到了这里,关于STM32模拟I2C获取TCS34725光学颜色传感器数据的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • STM32使用模拟I2C读取AS5600(深入讲解:带波形图)

    首先我们要了解I2C的基本原理 当IIC处于空闲状态的时候,SDA和SCL都处于高电平状态, 当IIC通信开始信号,SCL保持高电平,SDA从高电平变成低电平(SCL=1,SDA=1-0), 当IIC通信结束信号,SCL保持高电平,SDA从低电平变成高电平(SCL=1,SDA=0-1)。 IIC通信开始后,发送8位数据信号

    2024年02月01日
    浏览(50)
  • K_A12_033 基于STM32等单片机驱动TCS34725颜色传感 串口与OLED0.96双显示

    单片机型号 测试条件 模块名称 代码功能 STC89C52RC 晶振11.0592M TCS34725颜色传感 模块 STC89C52RC驱动TCS34725颜色传感模块串口与OLED0.96双显示 STM32F103C8T6 晶振8M/系统时钟72M TCS34725颜色传感模块 STM32F103C8T6驱动TCS34725颜色传感模块串口与OLED0.96双显示 其他资料目录 直戳跳转 工作电压:

    2024年02月06日
    浏览(51)
  • 基于HAL库的stm32的OLED显示屏显示(模拟I2C,四脚,0.96寸)

    参考视频:江科大oled程序移植stm32hal库,freertos学习,cpu使用率_哔哩哔哩_bilibili ​ STM32入门教程-2023持续更新中_哔哩哔哩_bilibili 高速和低速晶振均选择为陶瓷晶振即可。 不需更改初始化配置,因为模拟I2C初始化时会设置这两个引脚的电平 step1、step2完成后生成工程即可。 代

    2024年02月06日
    浏览(52)
  • STM32为基础的模拟I2C通用8bit和16bit读取以及多字节读取

    GPIO模拟I2C驱动的通用代码,I2C的寄存器地址有8位和16位的,主要解决了同一个MCU同时处理8位和16位寄存器地址芯片时候的驱动问题。 以上是结构体,作为参数,其中DevAddr是芯片地址,RegAddr是寄存器地址,data_len是写入或者读取的数据长度,data_buf是写入或者读出的数据缓冲

    2024年04月28日
    浏览(41)
  • HAL STM32 硬件I2C方式读取AS5600磁编码器获取角度例程

    📍相关篇《STM32 软件I2C方式读取AS5600磁编码器获取角度例程》 ✨stm32使用硬件I2C去读取角度数据,通过STM32CubeMX工具配置工程,读取角度数据,只需要调用一个函数,即可完成数据的读取。了解函数的用法以及从设备地址命令,上手十分快速和简单。 📌AS5600资料: https://p

    2024年04月26日
    浏览(71)
  • 【STM32 CubeMX】I2C层次结构、I2C协议

    在STM32 CubeMX环境中,I2C(Inter-Integrated Circuit)是一种常用的串行通信协议,广泛应用于连接各种外设和传感器。理解I2C的层次结构、协议和硬件结构对于STM32微控制器的开发至关重要。通过STM32 CubeMX提供的图形化配置工具,我们能够更轻松地理解和配置I2C通信,同时深入了解

    2024年02月22日
    浏览(80)
  • STM32 I2C

    目录 I2C通信  软件I2C读写MPU6050 I2C通信外设 硬件I2C读写MPU6050 I2C通信 R/W:0写1读 十轴:3轴加速度,3轴角速度,3轴磁场强度和一个气压强度  软件I2C读写MPU6050 MyI2C.c MPU6050.c MPU6050_Reg.h(寄存器) main.c I2C通信外设 GPIO口需要配置为复用开漏输出模式。复用:就是GPIO的状态是交由

    2024年02月19日
    浏览(49)
  • STM32---I2C

    目录                                       一.I2C协议 1.什么是I2C协议?  2.物理层特性                                     二.协议层 1.I2C读写过程 2.I2C外设 3.I2C外设通讯过程              三.I2C库函数                       四.EEPROM 写操作: 读操作:      

    2024年02月16日
    浏览(47)
  • STM32学习笔记(十)丨I2C通信(使用I2C实现MPU6050和STM32之间通信)

    ​  本次课程采用单片机型号为STM32F103C8T6。(鉴于笔者实验时身边只有STM32F103ZET6,故本次实验使基于ZET6进行的) ​  课程链接:江协科技 STM32入门教程   往期笔记链接:   STM32学习笔记(一)丨建立工程丨GPIO 通用输入输出   STM32学习笔记(二)丨STM32程序调试

    2024年01月19日
    浏览(59)
  • STM32-I2C通讯

    I2C( Inter-Integrated Circuit )是一种通用的总线协议。它是由Philips(飞利浦)公司,现NXP(恩智浦)半导体开发的一种 简单的双向两线制 总线协议标准。 I2C有两根双向的信号线,一根数据线SDA用于收发数据,一根时钟线SCL用于通信双方时钟的同步。 支持同步,半双工,带数据应答,

    2024年03月14日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包