标题: 51单片机实现红外探头ADC数值读取程序 实现红外巡线 [打印本页]
作者: KZ25T    时间: 2022-11-6 17:25
标题: 51单片机实现红外探头ADC数值读取程序 实现红外巡线
使用单片机型号STC15W408AS-35I-DIP20，焊接效果如附件图。使用程序可以读取所有红外探头的ADC数值，可以进行IIC通信。
这种单片机一次具有8个ADC，一个芯片就能实现8个探头的数据转换。

这样的设计可以实现红外巡线等功能。



# 红外巡线测试结果

2022年8月23日23:10:10

## 装车效果

只装了一块弯的，效果很好。

探头顶端距离地面大约8mm（目测）。

## 我的程序

### 从机

从机传输数据的时候LED亮起。

6个探头的从机传回的数据：\[data*6] \[0] \[addr]

8个探头的从机传回的数据：\[data*8]

### 主机

主机使用STM32F401CCU6，配置IIC2引脚，波特率为一个非标准的传输波特率（10000，标准值为100k（标准IIC）或400k（高速IIC））。

主机对所有地址的从机进行检测，对每个从机，会循环尝试传输，直到传输成功或传输次数达到5次为止。

把所有从机地址检测完毕之后重新开始。

主机接收到数据之后通过UART（115200）传输给电脑，使用串口调试助手（HEX）可以打开查看。

## 数据传输

使用IIC总线传输，经过我的调试，可以在8从机上稳定运行。

总共只需要4个线，2电源线和2数据线。

## 测试数据结果

悬空 0x00-0x10

黑 0x08-0x20

白 0xB0-0xFF

## 测试样例

![示意图](示意图.jpg)

顺时针方向分别是0和1号，也就是上图中左边是1、右边是0；测得数据：

```MATLAB
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 15 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 15 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 15 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 15 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 14 13 01 00 31 AC D8 F2 EF C0 01 01
EC F2 C8 16 15 13 01 00 31 AC D8 F2 EF C0 01 01
```

数据格式：

\[数据*6]（每个探头的ADC转换值，从左到右） \[发送成功所使用的的次数] \[从机地址]

- 位于白色上面的data\[0]\[0:3]给出了白色范围内的值
- 位于黑色上面的data\[0]\[4:6]给出了黑色范围内的值
- 位于过渡位置的data\[1]\[0]给出了中间值0x31，偏离过渡位置的data\[1]\[1]给出了比较靠近白色的值
- 位于白色上面的data\[1]\[2:6]给出了白色范围内的值
- 所有传输均使用1次尝试完成
- 可以连续运行10分钟无故障

## 其他

经过测试，也可以比较好地分辨出紫色、蓝色等。

## 总结

本次实验比较成功，我设计的系统比较安全、灵敏、可靠、高效。

单片机源程序如下:
  1. #include <I2C.h>
  2. #include <STC15.h>
  3. #include <intrins.h>

  5. // #include "./include/delay.h"

  7. sbit LED         = P3 ^ 4;
  8. sbit I2C_SCL = P3 ^ 6;
  9. sbit I2C_SDA = P3 ^ 7;

  11. #if 0
  12. //定义LED灯引脚
  13. sbit Data[8] = {P37, P36, P35, P33, P32, P31, P30, P54};
  14. #endif

  16. void delay(unsigned int delay_time) // 1毫秒@22.1184MHz
  17. {
  18.         unsigned char i, j;
  19.         for (; delay_time > 0; delay_time--) {
  20.                 _nop_();
  21.                 _nop_();
  22.                 i = 22;
  23.                 j = 128;
  24.                 do {
  25.                         while (--j)
  26.                                 ;
  27.                 } while (--i);
  28.         }
  29. }

  31. void                  InitADC();
  32. unsigned char GetADCResult(unsigned char ch);

  34. #define ADC_POWER 0x80         // ADC电源控制位
  35. #define ADC_FLAG 0x10         // ADC完成标志
  36. #define ADC_START 0x08         // ADC起始控制位
  37. #define ADC_SPEEDLL 0x00 // 540个时钟
  38. #define ADC_SPEEDL 0x20         // 360个时钟
  39. #define ADC_SPEEDH 0x40         // 180个时钟
  40. #define ADC_SPEEDHH 0x60 // 90个时钟

  42. /*----------------------------
  43. 初始化ADC
  44. ----------------------------*/
  45. void InitADC() {
  46.         P1ASF          = 0xff; //设置P1口为AD口，0xff表示8通道全开
  47.         ADC_RES          = 0;          //清除结果寄存器
  48.         ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
  49.         delay(20); // ADC上电并延时
  50. }

  52. /*----------------------------
  53. 读取ADC结果
  54. ----------------------------*/
  55. unsigned char GetADCResult(unsigned char ch) {
  56.         ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
  57.         _nop_(); //等待4个NOP
  58.         _nop_();
  59.         _nop_();
  60.         _nop_();
  61.         while (!(ADC_CONTR & ADC_FLAG))
  62.                 ;                                        //等待ADC转换完成
  63.         ADC_CONTR &= ~ADC_FLAG; // Close ADC

  65.         return ADC_RES; //返回ADC结果
  66. }
  67. /*
  68. void test(void){
  69.                 while(1){
  70.                                 I2C_SCL=1;
  71.                                 delay(10);
  72.                                 I2C_SDA=1;
  73.                                 delay(10);
  74.                                 I2C_SCL=0;
  75.                                 delay(10);
  76.                                 I2C_SDA=0;
  77.                                 delay(10);
  78.                                 LED = !LED;
  79.                 }
  80. }*/

  82. /*----------------------------
  83. 主程序由此开始
  84. ----------------------------*/

  86. #define ADDR 0x17 //定义从机地址/编号

  88. unsigned char TX_data[2], ADC_data[8], i;

  90. void main() {
  91.         LED = 1;
  92.         InitADC();
  93.         delay(10);
  94.         while (1) {
  95.                 for (i = 0; i < 8; i++)
  96.                         ADC_data[7 - i] = GetADCResult(i);

  98.                 // TX_data[0] = 0; //初始化为没有黑线
  99.                 // TX_data[1] = 0; //初始化为从第0个位置找到黑线
  100.                 // for (i = 0; i < 8; i++) {
  101.                 //         if (ADC_data[i] < 0x40) { //扫描到黑线
  102.                 //                 TX_data[1] = i;                                          //从第i个开始扫到黑线
  103.                 //                 i++;
  104.                 //                 TX_data[0]++; //扫描到黑线的数量
  105.                 //                 while (i < 8 && ADC_data[i] < 0x40) {
  106.                 //                         i++;
  107.                 //                         TX_data[0]++;
  108.                 //                 }
  109.                 //                 break;
  110.                 //         }
  111.                 // }

  113.                 // while (!I2C_Write(TX_data, ADDR, 2))
  114.                 //         ;
  115.                 P37 = ADC_data[0] > 0x38 ? 1 : 0;
  116.                 P36 = ADC_data[1] > 0x40 ? 1 : 0;
  117.                 P35 = ADC_data[2] > 0x40 ? 1 : 0;
  118.                 P33 = ADC_data[3] > 0x40 ? 1 : 0;
  119.                 P32 = ADC_data[4] > 0x40 ? 1 : 0;
  120.                 P31 = ADC_data[5] > 0x40 ? 1 : 0;
  121.                 P30 = ADC_data[6] > 0x40 ? 1 : 0;
  122.                 P54 = ADC_data[7] > 0x38 ? 1 : 0;
  123.                 delay(1);
  124.         }
  125. }
复制代码

  1. #include "STC15.h"
  2. #include "./include/delay.h"
  3. #include <intrins.h>

  5. sbit LED = P3 ^ 4;

  7. #define I2CDelay() \
  8.         {              \
  9.                 _nop_();   \
  10.                 _nop_();   \
  11.                 _nop_();   \
  12.                 _nop_();   \
  13.         }
  14. sbit I2C_SCL = P3 ^ 6;
  15. sbit I2C_SDA = P3 ^ 7;

  17. /* I2C总线写操作，dat-待写入字节，返回值-主机应答位的值 */
  18. bit I2CWrite(unsigned char dat)
  19. {
  20.         bit ack;                        //用于暂存应答位的值
  21.         unsigned char mask; //用于探测字节内某一位值的掩码变量

  23.         for (mask = 0x80; mask != 0; mask >>= 1) //从高位到低位依次进行
  24.         {
  25.                 if ((mask & dat) == 0) //该位的值输出到SDA上
  26.                         I2C_SDA = 0;
  27.                 else
  28.                         I2C_SDA = 1;
  29.                 while (I2C_SCL == 0)
  30.                         ; //等待SCL上升沿
  31.                 while (I2C_SCL == 1)
  32.                         ; //等待SCL下降沿
  33.         }
  34.         I2C_SDA = 1; // 8位数据发送完后，从机释放SDA，以检测应答
  35.         while (I2C_SCL == 0)
  36.                 ;                   //等待SCL上升沿
  37.         ack = I2C_SDA; //读取此时的SDA值，即为从机的应答值
  38.         while (I2C_SCL == 1)
  39.                 ; //等待SCL下降沿

  41.         return (~ack); //应答值取反以符合通常的逻辑：
  42.                                    // 0=不存在或忙或写入失败，1=存在且空闲或写入成功
  43. }
  44. /* I2C总线读操作，并发送非应答信号，返回值-读到的字节 */
  45. unsigned char I2CReadNAK(unsigned char addr)
  46. {
  47.         unsigned char mask;
  48.         unsigned char dat = 0;

  50.         // I2C_SDA = 1;  //首先确保释放SDA
  51.         // I2C_SCL = 1;  //首先确保释放SDA
  52.         for (mask = 0x80; mask != 0; mask >>= 1) //从高位到低位依次进行
  53.         {
  54.                 while (I2C_SCL == 0)
  55.                         ;                          //等待SCL上升沿
  56.                 if (I2C_SDA == 0) //读取SDA的值
  57.                         dat &= ~mask; //为0时，dat中对应位清零
  58.                 else
  59.                         dat |= mask; //为1时，dat中对应位置1
  60.                 while (I2C_SCL == 1)
  61.                         ; //等待SCL下降沿
  62.         }
  63.         if ((dat >> 1) == addr)
  64.                 I2C_SDA = 0; //地址正确，发送应答信号
  65.         else
  66.                 I2C_SDA = 1; //地址错误，发送非应答信号
  67.         while (I2C_SCL == 0)
  68.                 ; //等待SCL上升沿
  69.         while (I2C_SCL == 1)
  70.                 ; //等待SCL下降沿
  71.         I2C_SDA = 1;

  73.         return dat;
  74. }

  76. /* 读取函数，buf-数据接收指针，addr-起始地址，len-读取长度 */
  77. /*void I2C_Read(unsigned char *buf, unsigned char addr, unsigned char len)
  78. {
  79.         I2CStart();                //发送重复启动信号
  80.         I2CWrite((addr<<1)|0x01);  //寻址器件，后续为读操作
  81.         while (len > 1)            //连续读取len-1个字节
  82.         {
  83.                 *buf++ = I2CReadACK(); //最后字节之前为读取操作+应答
  84.                 len--;
  85.         }
  86.         *buf = I2CReadNAK();       //最后一个字节为读取操作+非应答
  87.         I2CStop();
  88. }*/
  89. /* 写入函数，buf-源数据指针，addr-起始地址，len-写入长度 */
  90. bit I2C_Write(unsigned char *buf, unsigned char addr, unsigned char len) {
  91.         unsigned char I2C_SDA_new, I2C_SDA_old, get_addr; //,loop;
  92.         // I2C_SDA = 1;  //首先确保释放SDA
  93.         // I2C_SCL = 1;  //首先确保释放SCL
  94.         I2C_SDA_new = I2C_SDA;
  95.         do {
  96.                 do
  97.                         I2C_SDA_old = I2C_SDA_new;
  98.                 while (((I2C_SDA_new = I2C_SDA) == 1) ||
  99.                            (I2C_SDA_old == 0)); //等待SDA下降沿
  100.         } while (I2C_SCL == 0);                        //并且SCL为高电平
  101.         while (I2C_SCL == 1)
  102.                 ; //等待SCL下降沿

  104.         get_addr = (I2CReadNAK(addr) >> 1);

  106.         if (get_addr == addr) {
  107.                 LED = 1;

  109.                 while (len > 0) {
  110.                         I2CWrite(*buf++);
  111.                         // if(I2CWrite(*buf++)==0)break;     //写入一个字节数据
  112.                         len--; //待写入长度计数递减
  113.                 }

  115.                 LED = 0;

  117.                 return 1; //发送成功
  118.         }
  119.         return 0; //发送失败
  120. }
复制代码





欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1