OPT4048颜色传感器

angm*** · 发表于 2026-8-24 10:46:33

一个程序试试

/* 
=============================================================================
 STC32G12K128 + OPT4048 颜色传感器驱动程序
=============================================================================
 硬件连接:
   - OPT4048 SCL  -> STC32G P1.5
   - OPT4048 SDA  -> STC32G P1.4
   - OPT4048 VDD  -> 3.3V (传感器供电为1.8V~3.6V)
   - OPT4048 GND  -> GND
   - OPT4048 ADDR -> GND (I2C地址0x44)
   
 串口3调试输出: TxD3=P0.1, RxD3=P0.0, 波特率115200
   
 编译平台: Keil C251
 头文件: stc32g.h (STC官方提供)
 工作频率: 内部IRC = 11.0592MHz
=============================================================================
*/

#include "stc32g.h"
#include "intrins.h"
#include <stdio.h>

//=============================================================================
// 常量定义
//=============================================================================
#define FOSC  11059200UL
// 串口波特率重装值 (115200)
#define BRT   (65536 - (FOSC / 115200 + 2) / 4)

// OPT4048 I2C 地址
#define OPT_ADDR_WR   0x88   // 0x44<<1
#define OPT_ADDR_RD   0x89   // (0x44<<1)|1

// OPT4048 寄存器 (与用户上传头文件一致)
#define REG_EXP_CH0   0x00   // 红 指数+结果MSB
#define REG_CNT_CH0   0x01   // 红 结果LSB+计数+CRC
#define REG_EXP_CH1   0x02   // 绿 指数+结果MSB
#define REG_CNT_CH1   0x03   // 绿 结果LSB+计数+CRC
#define REG_EXP_CH2   0x04   // 蓝 指数+结果MSB
#define REG_CNT_CH2   0x05   // 蓝 结果LSB+计数+CRC
#define REG_EXP_CH3   0x06   // 白 指数+结果MSB
#define REG_CNT_CH3   0x07   // 白 结果LSB+计数+CRC
#define REG_CONTROL   0x0A   // 控制寄存器
#define REG_DEVICE_ID 0x11   // 设备ID
#define OPT_DEV_ID    0x2084 // 设备ID值

// 控制寄存器配置: 连续转换, 50ms, 2KLUX2, qwake=1
// qwake=1(reserved=0)(range=0000)(ctime=0111)(op=11)(latch=0)(pol=0)(fc=00)
#define OPT_CONTROL_VAL 0x874C

//=============================================================================
// 全局变量
//=============================================================================
bit    g_i2c_busy;               // I2C忙标志
bit    g_uart_busy;              // 串口发送忙标志
unsigned char g_rx_ptr, g_tx_ptr;
unsigned long g_adc[4];          // 4通道数据
char g_strbuf[64];               // 格式化输出缓冲

//=============================================================================
// I2C 底层驱动 (查询方式, 参考手册范例)
//=============================================================================

// 等待I2C命令完成
void I2C_Wait(void)
{
    while (!(I2CMSST & 0x40));   // 等待MSIF
    I2CMSST &= ~0x40;            // 清标志
}

void I2C_Start(void)
{
    I2CMSCR = 0x01;              // START命令
    I2C_Wait();
}

void I2C_SendData(unsigned char d)
{
    I2CTXD = d;
    I2CMSCR = 0x02;              // 发送数据
    I2C_Wait();
}

void I2C_RecvACK(void)
{
    I2CMSCR = 0x03;              // 接收ACK
    I2C_Wait();
}

unsigned char I2C_RecvData(void)
{
    I2CMSCR = 0x04;              // 接收数据
    I2C_Wait();
    return I2CRXD;
}

void I2C_SendACK(void)
{
    I2CMSST = 0x00;              // ACK
    I2CMSCR = 0x05;
    I2C_Wait();
}

void I2C_SendNAK(void)
{
    I2CMSST = 0x01;              // NAK
    I2CMSCR = 0x05;
    I2C_Wait();
}

void I2C_Stop(void)
{
    I2CMSCR = 0x06;              // STOP
    I2C_Wait();
}

//=============================================================================
// OPT4048 寄存器读写
//=============================================================================

// 写16位寄存器
void OPT_WriteReg(unsigned char reg, unsigned int val)
{
    I2C_Start();
    I2C_SendData(OPT_ADDR_WR);       // 设备地址+写
    I2C_RecvACK();
    I2C_SendData(reg);               // 寄存器地址
    I2C_RecvACK();
    I2C_SendData((unsigned char)(val >> 8));   // 高字节
    I2C_RecvACK();
    I2C_SendData((unsigned char)(val & 0xFF)); // 低字节
    I2C_RecvACK();
    I2C_Stop();
}

// 读16位寄存器
unsigned int OPT_ReadReg(unsigned char reg)
{
    unsigned int val;
    unsigned char hi, lo;

    // 写寄存器地址
    I2C_Start();
    I2C_SendData(OPT_ADDR_WR);
    I2C_RecvACK();
    I2C_SendData(reg);
    I2C_RecvACK();

    // 重新START, 读操作
    I2C_Start();
    I2C_SendData(OPT_ADDR_RD);
    I2C_RecvACK();
    hi = I2C_RecvData();
    I2C_SendACK();
    lo = I2C_RecvData();
    I2C_SendNAK();
    I2C_Stop();

    return ((unsigned int)hi << 8) | lo;
}

// 计算单个通道ADC值: result = mantissa * 2^exponent
unsigned long OPT_GetADC(unsigned char exp_reg)
{
    unsigned int  exp_res, res_cnt;
    unsigned long mantissa;
    unsigned char exponent;

    exp_res = OPT_ReadReg(exp_reg);       // 指数+结果MSB
    res_cnt = OPT_ReadReg(exp_reg + 1);   // 结果LSB+计数+CRC

    exponent = (unsigned char)(exp_res & 0x0F);
    mantissa = (unsigned long)((exp_res >> 4) & 0x0FFF);
    mantissa = (mantissa << 8) | (unsigned long)(res_cnt & 0xFF);

    return mantissa << exponent;
}

// 初始化OPT4048
unsigned char OPT_Init(void)
{
    unsigned int dev_id;

    dev_id = OPT_ReadReg(REG_DEVICE_ID);
    if (dev_id != OPT_DEV_ID)
        return 0;                         // 设备未找到

    OPT_WriteReg(REG_CONTROL, OPT_CONTROL_VAL);  // 连续转换
    return 1;
}

// 读取全部4通道
void OPT_ReadAll(void)
{
    g_adc[0] = OPT_GetADC(REG_EXP_CH0);   // 红
    g_adc[1] = OPT_GetADC(REG_EXP_CH1);   // 绿
    g_adc[2] = OPT_GetADC(REG_EXP_CH2);   // 蓝
    g_adc[3] = OPT_GetADC(REG_EXP_CH3);   // 白
}

//=============================================================================
// 串口3 驱动 (定时器2做波特率发生器)
//=============================================================================

// 串口3中断服务
void Uart3_Isr(void) interrupt 17
{
    if (S3TI) { S3TI = 0; g_uart_busy = 0; }
    if (S3RI) { S3RI = 0; }
}

void Uart3_Init(void)
{
    S3CON = 0x10;          // 8位数据模式, 允许接收
    T2L = (unsigned char)BRT;
    T2H = (unsigned char)(BRT >> 8);
    T2x12 = 1;             // 1T模式
    T2R = 1;               // 启动定时器2
}

void Uart3_SendByte(unsigned char d)
{
    while (g_uart_busy);
    g_uart_busy = 1;
    S3BUF = d;
}

void Uart3_SendStr(char *p)
{
    while (*p) Uart3_SendByte((unsigned char)(*p++));
}

void Uart3_SendLong(unsigned long v)
{
    sprintf(g_strbuf, "%lu", v);
    Uart3_SendStr(g_strbuf);
}

//=============================================================================
// 延时函数
//=============================================================================
void Delay_ms(unsigned int ms)
{
    unsigned int i, j;
    for (i = 0; i < ms; i++)
        for (j = 0; j < 1382; j++)   // 约1ms @11.0592MHz
            _nop_();
}

//=============================================================================
// 主函数
//=============================================================================
void main(void)
{
    // 系统初始化
    EAXFR = 1;                 // 使能XFR访问
    CKCON = 0x00;              // 外部数据总线最快
    WTST = 0x00;               // 程序等待最快

    // 端口初始化: 全部准双向口
    P0M0 = 0x00;  P0M1 = 0x00;
    P1M0 = 0x00;  P1M1 = 0x00;
    P2M0 = 0x00;  P2M1 = 0x00;
    P3M0 = 0x00;  P3M1 = 0x00;
    P4M0 = 0x00;  P4M1 = 0x00;
    P5M0 = 0x00;  P5M1 = 0x00;

    // I2C 初始化: 主机模式, 默认引脚P1.4/P1.5
    // MSSPEED=0x20时, 总线速度 = SYSCLK/2/(0x20*2+4) = 11.0592M/72 ≈ 154kHz
    I2CCFG = 0xE0;             // ENI2C=1, MSSL=1(主机), MSSPEED=0x20
    I2CMSST = 0x00;

    // 串口3初始化
    Uart3_Init();
    ES3 = 1;
    EA = 1;

    Uart3_SendStr("\r\n=== OPT4048 Color Sensor Test ===\r\n");

    // 初始化传感器
    if (OPT_Init())
        Uart3_SendStr("OPT4048 found (ID=0x2084)!\r\n");
    else
    {
        Uart3_SendStr("OPT4048 NOT found!\r\n");
        while (1);
    }

    // 主循环: 持续读取并输出颜色数据
    while (1)
    {
        OPT_ReadAll();

        Uart3_SendStr("R=");
        Uart3_SendLong(g_adc[0]);
        Uart3_SendStr(" G=");
        Uart3_SendLong(g_adc[1]);
        Uart3_SendStr(" B=");
        Uart3_SendLong(g_adc[2]);
        Uart3_SendStr(" W=");
        Uart3_SendLong(g_adc[3]);
        Uart3_SendStr("\r\n");

        Delay_ms(500);
    }
}


复制代码

好学*** · 发表于 2026-8-24 10:48:05

梁*** 发表于 2026-8-24 10:14
厂家或卖家没有给程序码？
AI给程序只是省去打字的时间，程序逻辑还是要自己过一遍，核对寄存器的操作，A ...

这是ai给我生成的代码，可以生成，但是读取的都是

[code]/*---------------------------------------------------------------------*/
/* --- STC MCU Limited ------------------------------------------------*/
/* --- STC 1T Series MCU Demo Programme -------------------------------*/
/*---------------------------------------------------------------------*/
#include "STC32G.h"
#include <intrins.h>

typedef

好学*** · 发表于 2026-8-24 10:57:17

angm*** 发表于 2026-8-24 10:46
一个程序试试

好滴我试试

好学*** · 发表于 2026-8-24 10:57:32

好学*** 发表于 2026-8-24 10:48
这是ai给我生成的代码，可以生成，但是读取的都是

[code]/*------------------------------------------ ...

/*---------------------------------------------------------------------*/
/* --- STC MCU Limited ------------------------------------------------*/
/* --- STC 1T Series MCU Demo Programme -------------------------------*/
/*---------------------------------------------------------------------*/
#include "STC32G.h"
#include <intrins.h>

typedef unsigned char u8;
typedef unsigned int u16;
typedef unsigned long u32;

#define MAIN_Fosc       22118400L
#define Baudrate2 (65536 - MAIN_Fosc / 115200 / 4)
#define UART2_BUF_LENGTH 128

/*************  本地变量声明 **************/
u8  TX2_Cnt;
u8  RX2_Cnt;
bit B_TX2_Busy;
u8  RX2_Buffer[UART2_BUF_LENGTH];

//OPT4048变量全局edata，避免C172段溢出
unsigned int rawX,rawY,rawZ,rawW;
float cie_x,cie_y,lux,cct;

//======== OPT4048 I2C引脚 P2.4 SDA  P2.5 SCL ========
sbit I2C_SDA  = P2^4;
sbit I2C_SCL  = P2^5;

#define OPT4048_ADDR       0x44
#define OPT4048_REG_RESULT0 0x00
#define OPT4048_REG_RESULT1 0x01
#define OPT4048_REG_RESULT2 0x02
#define OPT4048_REG_RESULT3 0x03
#define OPT4048_REG_CONFIG  0x04

#define CONV_TIME_100MS (0x0B << 4)
#define MODE_CONTINUOUS (0x02 << 1)
#define RANGE_0          (0x00 << 8)  //满量程 440lux

/*************  本地函数声明 **************/
void UART2_config(u8 brt);
void PrintString2(u8 *puts);
void GPIO_I2C_Init(void);
void I2C_Delay(void);
void I2C_Start(void);
void I2C_Stop(void);
bit I2C_WriteByte(unsigned char dat);
unsigned char I2C_ReadByte(bit ack_en);
bit OPT4048_WriteReg(unsigned char reg, unsigned int val);
bit OPT4048_ReadXYZ(unsigned int *X, unsigned int *Y, unsigned int *Z, unsigned int *W);
bit OPT4048_Init(void);
void OPT4048_Calc(unsigned int rawX,unsigned int rawY,unsigned int rawZ,
               float *out_x, float *out_y, float *out_lux, float *out_cct);
void UART2_SendFloat(float val, unsigned char dec);
void Delay_ms(unsigned int ms);

/******************** 主函数 **************************/
void main(void)
{
WTST = 0;
EAXFR = 1;
CKCON = 0;
P0M1 = 0x30; P0M0 = 0x30;
P1M1 = 0x30; P1M0 = 0x30;
P2M0 &= ~0x31; P2M1 &= ~0x31;
P3M1 = 0x50; P3M0 = 0x50;
P4M1 = 0x3c; P4M0 = 0x3c;
P5M1 = 0x0c; P5M0 = 0x0c;
P6M1 = 0xff; P6M0 = 0xff;
P7M1 = 0x00; P7M0 = 0x00;

GPIO_I2C_Init();
UART2_config(2);
EA = 1;

PrintString2((u8*)"OPT4048 ready, send any byte to trigger read!\r\n");

if(OPT4048_Init() != 0)
{
      PrintString2((u8*)"OPT4048 init FAIL!\r\n");
      while(1);
}
PrintString2((u8*)"OPT4048 init OK\r\n");

while (1)
{
if(RX2_Cnt != TX2_Cnt)
{
      TX2_Cnt = RX2_Cnt;

      //读取，失败重试一次
      if(OPT4048_ReadXYZ(&rawX,&rawY,&rawZ,&rawW) != 0)
      {
         PrintString2((u8*)"I2C read error!\r\n");
      }
      // 如果全部为0，再等110ms重读一次
      else if(rawX == 0 && rawY ==0 && rawZ ==0)
      {
         Delay_ms(110);
         OPT4048_ReadXYZ(&rawX,&rawY,&rawZ,&rawW);
      }

      PrintString2((u8*)"--------DATA--------\r\n");
      //打印原始寄存器值，方便定位
      PrintString2((u8*)"RAW X,Y,Z,W:");
      UART2_SendFloat((float)rawX,0); PrintString2((u8*)",");
      UART2_SendFloat((float)rawY,0); PrintString2((u8*)",");
      UART2_SendFloat((float)rawZ,0); PrintString2((u8*)",");
      UART2_SendFloat((float)rawW,0); PrintString2((u8*)"\r\n");

      OPT4048_Calc(rawX,rawY,rawZ,&cie_x,&cie_y,&lux,&cct);

      PrintString2((u8*)"CIE-x:");
      UART2_SendFloat(cie_x,4);
      PrintString2((u8*)"\r\n");

      PrintString2((u8*)"CIE-y:");
      UART2_SendFloat(cie_y,4);
      PrintString2((u8*)"\r\n");

      PrintString2((u8*)"Lux(亮度):");
      UART2_SendFloat(lux,2);
      PrintString2((u8*)" lx\r\n");

      PrintString2((u8*)"CCT(色温):");
      UART2_SendFloat(cct,1);
      PrintString2((u8*)" K\r\n");
      PrintString2((u8*)"--------------------\r\n\r\n");
}
}

}

//========================================================================
// 函数: void PrintString2(u8 *puts) 原厂原样
//========================================================================
void PrintString2(u8 *puts)
{
for (; *puts != 0;  puts++)
{
      S2BUF = *puts;
      B_TX2_Busy = 1;
      while(B_TX2_Busy);
}
}

//========================================================================
// 函数: SetTimer2Baudraye(u32 dat) 原厂原样
//========================================================================
void SetTimer2Baudraye(u32 dat)
{
T2R = 0;
T2_CT = 0;
T2x12 = 1;
T2H = (u8)(dat / 256);
T2L = (u8)(dat % 256);
ET2 = 0;
T2R = 1;
}

//========================================================================
// 函数: void UART2_config(u8 brt) 原厂原样
//========================================================================
void UART2_config(u8 brt)
{
if(brt == 2)
{
      SetTimer2Baudraye(Baudrate2);
      S2CFG |= 0x01;
      S2CON = (S2CON & 0x3f) | 0x40;
      ES2 = 1;
      S2REN = 1;
      S2_S  = 1;       //UART2映射 P4.6(TX2), P4.7(RX2)
      B_TX2_Busy = 0;
      TX2_Cnt = 0;
      RX2_Cnt = 0;
}
}

//========================================================================
// 函数: void UART2_int (void) interrupt UART2_VECTOR 原厂中断原样
//========================================================================
void UART2_int (void) interrupt 8
{
if(S2RI)
{
      S2RI = 0;
      RX2_Buffer[RX2_Cnt] = S2BUF;
      if(++RX2_Cnt >= UART2_BUF_LENGTH) RX2_Cnt = 0;
}
if(S2TI)
{
      S2TI = 0;
      B_TX2_Busy = 0;
}
}

//==================== I2C OPT4048 部分 ====================
void GPIO_I2C_Init(void)
{
I2C_SDA = 1;
I2C_SCL = 1;
}

void I2C_Delay(void)
{
unsigned char i;
for(i = 0; i < 150; i++) _nop_();
}

void I2C_Start(void)
{
I2C_SDA = 1;
I2C_Delay();
I2C_SCL = 1;
I2C_Delay();
I2C_SDA= 0;
I2C_Delay();
I2C_SCL= 0;
I2C_Delay();
}

void I2C_Stop(void)
{
   I2C_SDA = 0;
I2C_Delay();
I2C_SCL= 1;
I2C_Delay();
I2C_SDA = 1;
I2C_Delay();
}

bit I2C_WriteByte(unsigned char dat)
{
unsigned char i;
bit ack;
for(i = 0; i < 8; i++)
{
      if(dat & 0x80)  I2C_SDA = 1;
      else          I2C_SDA= 0;
      dat <<= 1;
      I2C_Delay();
      I2C_SCL = 1;
I2C_Delay();
      I2C_SCL = 0;
I2C_Delay();
}
I2C_SDA = 1;
I2C_Delay();
I2C_SCL = 1;
I2C_Delay();
ack = I2C_SDA;
I2C_SCL = 0;
return ack;

}

unsigned char I2C_ReadByte(bit ack_en)
{
unsigned char i, dat = 0;
I2C_SDA = 1;
for(i = 0; i < 8; i++)
{
      dat <<= 1;
      I2C_SCL = 1; I2C_Delay();
      if(I2C_SDA) dat |= 0x01;
      I2C_SCL = 0; I2C_Delay();
}
I2C_SDA = !ack_en;
I2C_Delay();
I2C_SCL = 1; I2C_Delay();
I2C_SCL = 0;
I2C_SDA = 1;
return dat;
}

bit OPT4048_WriteReg(unsigned char reg, unsigned int val)
{
I2C_Start();
if(I2C_WriteByte(OPT4048_ADDR << 1)) {I2C_Stop(); return 1;}
if(I2C_WriteByte(reg))             {I2C_Stop(); return 1;}
if(I2C_WriteByte((val >> 8) & 0xFF)){I2C_Stop(); return 1;}
if(I2C_WriteByte(val & 0xFF))       {I2C_Stop(); return 1;}
I2C_Stop();
return 0;
}

bit OPT4048_ReadXYZ(unsigned int *X, unsigned int *Y, unsigned int *Z, unsigned int *W)
{
I2C_Start();
if(I2C_WriteByte(OPT4048_ADDR << 1)) {I2C_Stop(); return 1;}
if(I2C_WriteByte(OPT4048_REG_RESULT0))  {I2C_Stop(); return 1;}
I2C_Start();
if(I2C_WriteByte((OPT4048_ADDR <<1)|0x01)) {I2C_Stop(); return 1;}

*X = (I2C_ReadByte(1) << 8) | I2C_ReadByte(1);
*Y = (I2C_ReadByte(1) << 8) | I2C_ReadByte(1);
*Z = (I2C_ReadByte(1) << 8) | I2C_ReadByte(1);
*W = (I2C_ReadByte(0) << 8) | I2C_ReadByte(0);
I2C_Stop();
return 0;
}

bit OPT4048_Init(void)
{
unsigned int cfg;
cfg = RANGE_0 | CONV_TIME_100MS | MODE_CONTINUOUS;
if(OPT4048_WriteReg(OPT4048_REG_CONFIG, cfg))
{
      return 1;
}
// 关键！配置完成，等待第一次100ms转换完成
Delay_ms(120);
return 0;
}

void OPT4048_Calc(unsigned int rawX,unsigned int rawY,unsigned int rawZ,
               float *out_x, float *out_y, float *out_lux, float *out_cct)
{
float X,Y,Z,sum,n;
X = (float)rawX;
Y = (float)rawY;
Z = (float)rawZ;
sum = X + Y + Z;

if(sum < 1.0f)
{
      *out_x = 0.0f; *out_y =0.0f; *out_lux=0.0f; *out_cct=0.0f;
      return;
}
*out_x = X / sum;
*out_y = Y / sum;
*out_lux = Y / 65535.0f * 144000.0f;

n = (*out_x - 0.3320f) / (0.1858f - *out_y);
*out_cct = -449.0f * n*n*n + 3525.0f * n*n - 6823.3f * n + 5520.33f;

if(*out_cct < 1000.0f) *out_cct = 1000.0f;
if(*out_cct > 10000.0f) *out_cct = 10000.0f;
}

//浮点数发送
void UART2_SendFloat(float val, unsigned char dec)
{
unsigned long int_part;
unsigned char i;
if(val < 0.0f)
{
      S2BUF = '-'; B_TX2_Busy=1; while(B_TX2_Busy);
      val = -val;
}
if(val > 4294967295.0f)
      val = 4294967295.0f;

int_part = (unsigned long)(val + 0.0001f);
if(int_part == 0U)
{
      S2BUF = '0'; B_TX2_Busy=1; while(B_TX2_Busy);
}
else
{
      unsigned long temp = int_part;
      unsigned char buf[12], p = 0U;
      while(temp > 0U)
      {
         buf[p++] = (unsigned char)((temp % 10UL) + '0');
         temp /= 10UL;
      }
      for(i = p; i > 0U; i--)
      {
         S2BUF = buf[i - 1U];
         B_TX2_Busy = 1;
         while(B_TX2_Busy);
      }
}
S2BUF = '.'; B_TX2_Busy=1; while(B_TX2_Busy);
for(i = 0U; i < dec; i++)
{
      val = (val - (float)int_part) * 10.0f;
      int_part = (unsigned long)(val + 0.0001f);
      S2BUF = (unsigned char)((int_part % 10UL) + '0');
      B_TX2_Busy = 1;
      while(B_TX2_Busy);
}
}

void Delay_ms(unsigned int ms)
{
unsigned int i,j;
for(i = ms; i>0; i--)
      for(j = 360; j>0; j--);
}

		自动登录	找回密码
密码			立即注册