1. Johngo学长首页
  2. 技术点详细复盘专题
  3. 人工智能

LD3320语音识别模块开发

• 人工智能 • 阅读 79

LD3320语音识别模块开发

达者为先 师者之意

LD3320语音识别模块开发

; 1 LD3320语音识别模块基本参数

1.1 基本参数

模块的各种参数如下所述。

[En]

The various parameters of the module are described below.

  • 型号：YS-LDV7
  • 名称：集成语音识别模块
    [En]

    name: integrated speech recognition module*

  • 规格：43*29.7MM
  • 供电电压：5V （内部工作电压 3.3V）
  • 待机电流：30MA 识别时电流：45MA
  • IO 口输出：高电平为 3.3V
  • 通信方式：串口通信（5V TTL 电平，不可直接接 RS232、RS485）
  • 单片机参数：型号–>STC11L08XE 、flash–>8k、SRAM–>1280、eeprom–>32k
  • 识别词条个数：50 句
  • 工作温度：-20 至 60℃
  • 本模块实际原理为 1 片 STC11 单片机+1 片 LD3320 组合形成的一款语音 识别模块，语音识别部分已写好驱动程序，用于只需要对 STC 单片机进行编 程加入自己的识别语句和控制程序即可，语音识别部分无需理会和做编程处理。

LD3320语音识别模块开发

LD3320是非特定人（不用针对指定人）语音识别芯片，即语音声控芯片。最多可以识别50条预先内置的指令。

工作模式：LD3320（LDV7)语音模块可以工作在以下三种模式：（推荐使用口令模式，这样避免嘈杂环境下误动作。）

  • 正常模式：直接说话，直接识别模块。
    [En]

    normal mode: speak directly and identify the module directly.*

  • 按键模式：按键触发开始ASR进程；
  • 密码模式：需要一级唤醒字(密码)
    [En]

    password mode: a first-level wake-up word is required (password)*

LD3320语音识别模块开发

实物连接图

LD3320语音识别模块开发

; 1.2 识别原理

也就是说，你说一句话，然后模块用拼音与你的发音进行比较，找出哪些预设值的单词更接近你的发音(假设50%)。然后从大于(50%)的堆中输出最接近的一个。

[En]

That is, you say a sentence, and then the module uses pinyin to compare with your pronunciation to find out which words with preset values are closer to your pronunciation (assuming 50%). Then output the closest one from a pile greater than (50%).

这会造成问题，容易造成太多的误解。如果你只有一个关键词：“时间”，然后你说：“时刻”，他认出了当时的发音，所以有50%以上的相似之处，但在候选单词中没有时间比他更接近。所以他会输出“时间”的结果。在这方面，他错了。如果你设置了一些拟声词，它可能会被随意触发。

[En]

This will cause a problem, which is easy to cause too much misrecognition. If you have only one keyword: “time”, and then you say: “moment”, he recognizes the pronunciation at that time, so it is more than 50% similar, but there is no time in the candidate word that is closer than he is. So he will output the result of “time”. In this way, he is wrong. If you set up some onomatopoeia, it may be triggered casually.

1.3 解决方案：

在设定好要识别的关键词语后，为了进一步降低误识别率，可以再添加一些其他的任意词汇进识别列表，用来吸收错误识别，从而达到降低误识别率的目的。我们把这样一些关键词语称之为”垃圾关键词语”。比如，某个应用场景中，需要识别的关键词语是4条，”前进”，”后退”，”开门”，”关门”。在把这4个关键词语设置进LD3320后，可以再另外设置10～30个词语进LD3320，比如”前门”，”后门”，”阿阿阿”，”呜呜”等等。所以最好把一些拟声词或者容易混淆的词语设置为垃圾关键词，即，识别后不进行输出。只有识别结果是4个关键词语之内的，才认为识别有效。如果识别结果是”垃圾关键词语”，则说明是其他的声音导致的误识别，产品应该重新开始一次识别过程。这样，可以非常有效地降低误识别率。极大地提高终端用户的主观使用体验。

2 LD3320语音识别模块二次开发

2.1 源码修改

打开 keil4 APP文件夹

LD3320语音识别模块开发
然后点击 YS-V0.7.uvproj快速打开所有源码：

LD3320语音识别模块开发
LD3320语音识别模块二次开发
只需对 LDChip.c、 LDChip.h、 main.c 这三个文件做出修改即可。

; 2.1.1 LDChip.c ：修改关键词和识别码（此处省略部分代码）

uint8 LD_AsrAddFixed()
{

    #define DATE_A 50
    #define DATE_B 70
    uint8 code sRecog[DATE_A][DATE_B] = {
                                                                                 "xiao jie",\
                                                                                 "kai fa ban yan zheng",\
                                                                                 "dai ma ce shi",\
                                                                                 "kai deng",\
                                                                                 "guan deng",\
                                                                                 "bei jing",\
                                                                                 "shang hai",\
                                                                                 "guang zhou"
                                                                            };
    uint8 code pCode[DATE_A] = {
                                                            CODE_CMD,\
                                                            CODE_KFBYZ,\
                                                            CODE_DMCS,\
                                                            CODE_KD,\
                                                            CODE_GD,\
                                                            CODE_BJ,\
                                                            CODE_SH,\
                                                            CODE_GZ
                                                         };

添加内容为拼音输入方式，例如想添加”开灯”命令，则写入 “kai deng”，每个汉字间的拼音用空格隔开；
所添加的识别码为预先定义好的宏定义常量值，同时必须和关键词一一对应，如上图所示， “da ma ce shi”命令对应的识别码为 CODE_DMCS。

2.1.2 LDChip.h ：根据关键词修改相应识别码（此处省略部分代码）


#define CODE_CMD  0x00
#define CODE_DMCS   0x01
#define CODE_KFBYZ  0x02
#define CODE_KD 0x04
#define CODE_GD 0x05
#define CODE_BJ 0x16
#define CODE_SH 0x17
#define CODE_GZ 0x2f

此处即为识别码的添加和修改，可以根据自己的需要和喜好任意定义识别码和宏名，但必须和前面所使用的识别码配对，否则会提示未定义错误。识别码的参数范围为 01-FF 随意选择，没有具体意义，只要不存在重复的即可。

2.1.3 main.c ：（此处省略部分代码）

TEST测试命令


#define TEST

#ifdef TEST
PrintCom("一级口令：小杰\r\n");
PrintCom("二级口令：1、代码测试\r\n");
PrintCom("  2、开发板验证\r\n");
PrintCom("  3、开灯\r\n");
PrintCom("  4、关灯\r\n");
PrintCom("  5、北京\r\n");
PrintCom("  6、上海\r\n");
PrintCom("  7、广州\r\n");
#endif

TEST为测试命令宏，添加 TEST则运行其中代码，此处代码为向串口打印相应数据，不希望执行测试命令，可以把内容去掉

修改处理程序(此处省略部分代码)

[En]

Modify the handler (omit some of the code here)

switch(dat)
              {
                  case CODE_DMCS:
                        PrintCom(""代码测试"命令识别成功\r\n");
                                                     break;
                    case CODE_KFBYZ:
                        PrintCom(""开发板验证"命令识别成功\r\n");
                                                     break;
                    case CODE_KD:
                        PrintCom(""开灯"命令识别成功\r\n");
                                                    break;
                    case CODE_GD:
                        PrintCom(""关灯"命令识别成功\r\n");
                                                    break;
                    case CODE_BJ:
                        PrintCom(""北京"命令识别成功\r\n");
                                                    break;
                    case CODE_SH:
                        PrintCom(""上海"命令识别成功\r\n");
                                                    break;
                    case CODE_GZ:
                        PrintCom(""广州"命令识别成功\r\n");
                                                    break;
                    default:PrintCom("请重新识别发口令\r\n"); break;
                }

用户可以根据自己的使用情况，在对应的识别码后面添加识别成功后的操作。然后，该设备将在某个句子之后执行相应的动作。其实，这个程序就是识别识别码，然后执行相应的动作，属于覆盆子派的应用处理部分。

[En]

Users can add the operation after successful identification after the corresponding identification code according to their own usage. Then the device will perform the corresponding action after a certain sentence. In fact, this program is to identify the identification code and then perform the corresponding action, which belongs to the application processing part of the raspberry pie.

2.2 模块调试

2.2.1 模块程序下载

本模块的程序下载实际为 STC 单片机的程序下载方法，首先我们需要安装 USB 转 TTL 驱动（如已安装无需再安装），然后接好 USB 转 TTL，打开 STC-ISP：

LD3320语音识别模块开发

①选择单片机型号
②选择相应串口号
③打开程序文件 > 打开源程序 > 打开obj文件夹 > 选择后缀.hex文件
④注意勾选 “复位脚用作I/O口”，
⑤设置完毕后点击”下载/编程”，并冷启动
在⑥冷启动后，底部的进度条显示进度。

[En]

After the cold start of ⑥, the progress bar at the bottom shows the progress.

; 2.2.2 模块调试

LD3320语音识别模块开发
①打开串口助手
②接收缓冲区选择 “文本模式”
③选择相应串口号
④波特率选择 9600
⑤打开串口

3 LD3320语音识别所有文件代码

3.1 main.c ：


#include "config.h"

uint8 idata nAsrStatus=0;
void MCU_init();
void ProcessInt0();
void delay(unsigned long uldata);
void User_handle(uint8 dat);
void Delay200ms();
void Led_test(void);
uint8_t G0_flag=DISABLE;
sbit LED=P4^2;

void  main(void)
{
    uint8 idata nAsrRes;
    uint8 i=0;
    Led_test();
    MCU_init();
    LD_Reset();
    UartIni();
    nAsrStatus = LD_ASR_NONE;

    #ifdef TEST
    PrintCom("一级口令：小杰\r\n");
    PrintCom("二级口令：1、代码测试\r\n");
    PrintCom("  2、开发板验证\r\n");
    PrintCom("  3、开灯\r\n");
    PrintCom("  4、关灯\r\n");
    PrintCom("  5、北京\r\n");
    PrintCom("  6、上海\r\n");
    PrintCom("  7、广州\r\n");
    #endif

    while(1)
    {
        switch(nAsrStatus)
        {
            case LD_ASR_RUNING:
            case LD_ASR_ERROR:
                break;
            case LD_ASR_NONE:
            {
                nAsrStatus=LD_ASR_RUNING;
                if (RunASR()==0)
                {
                    nAsrStatus = LD_ASR_ERROR;
                }
                break;
            }
            case LD_ASR_FOUNDOK:
            {
                nAsrRes = LD_GetResult();
                User_handle(nAsrRes);
                nAsrStatus = LD_ASR_NONE;
                break;
            }
            case LD_ASR_FOUNDZERO:
            default:
            {
                nAsrStatus = LD_ASR_NONE;
                break;
            }
        }
    }

}

void Led_test(void)
{
    LED=~ LED;
    Delay200ms();
    LED=~ LED;
    Delay200ms();
    LED=~ LED;
    Delay200ms();
    LED=~ LED;
    Delay200ms();
    LED=~ LED;
    Delay200ms();
    LED=~ LED;
}

void MCU_init()
{
    P0 = 0xff;
    P1 = 0xff;
    P2 = 0xff;
    P3 = 0xff;
    P4 = 0xff;

    LD_MODE = 0;
    IE0=1;
    EX0=1;
    EA=1;
}

void Delay200us()
{
    unsigned char i, j;
    _nop_();
    _nop_();
    i = 5;
    j = 73;
    do
    {
        while (--j);
    } while (--i);
}

void  delay(unsigned long uldata)
{
    unsigned int j  =  0;
    unsigned int g  =  0;
    while(uldata--)
    Delay200us();
}

void Delay200ms()
{
    unsigned char i, j, k;

    i = 17;
    j = 208;
    k = 27;
    do
    {
        do
        {
            while (--k);
        } while (--j);
    } while (--i);
}

void ExtInt0Handler(void) interrupt 0
{
    ProcessInt0();
}

void    User_handle(uint8 dat)
{

         if(0==dat)
         {
            G0_flag=ENABLE;
            LED=0;
            PrintCom("收到\r\n");
         }
         else if(ENABLE==G0_flag)
         {
                G0_flag=DISABLE;
                LED=1;
             switch(dat)
              {
                  case CODE_DMCS:
                        PrintCom(""代码测试"命令识别成功\r\n");
                                                     break;
                    case CODE_KFBYZ:
                        PrintCom(""开发板验证"命令识别成功\r\n");
                                                     break;
                    case CODE_KD:
                        PrintCom(""开灯"命令识别成功\r\n");
                                                    break;
                    case CODE_GD:
                        PrintCom(""关灯"命令识别成功\r\n");
                                                    break;
                    case CODE_BJ:
                        PrintCom(""北京"命令识别成功\r\n");
                                                    break;
                    case CODE_SH:
                        PrintCom(""上海"命令识别成功\r\n");
                                                    break;
                    case CODE_GZ:
                        PrintCom(""广州"命令识别成功\r\n");
                                                    break;
                            default:PrintCom("请重新识别发口令\r\n"); break;
                }
            }
            else
            {
                PrintCom("请说出一级口令\r\n");
            }
}

3.2 LDChip.c ：


#include "config.h"

extern void  delay(unsigned long uldata);

uint8 idata ucRegVal;
extern uint8 idata nAsrStatus;

void ProcessInt0(void);

void LD_Reset()
{
    RSTB=1;
    delay(5);
    RSTB=0;
    delay(5);
    RSTB=1;

    delay(5);
    CSB=0;
    delay(5);
    CSB=1;
    delay(5);
}

void LD_Init_Common()
{
    LD_ReadReg(0x06);
    LD_WriteReg(0x17, 0x35);
    delay(10);
    LD_ReadReg(0x06);

    LD_WriteReg(0x89, 0x03);
    delay(5);
    LD_WriteReg(0xCF, 0x43);
    delay(5);
    LD_WriteReg(0xCB, 0x02);

    LD_WriteReg(0x11, LD_PLL_11);

    LD_WriteReg(0x1E,0x00);
    LD_WriteReg(0x19, LD_PLL_ASR_19);
    LD_WriteReg(0x1B, LD_PLL_ASR_1B);
  LD_WriteReg(0x1D, LD_PLL_ASR_1D);
    delay(10);

    LD_WriteReg(0xCD, 0x04);

    delay(5);
    LD_WriteReg(0xB9, 0x00);
    LD_WriteReg(0xCF, 0x4F);
    LD_WriteReg(0x6F, 0xFF);
}

void LD_Init_ASR()
{
    LD_Init_Common();
    LD_WriteReg(0xBD, 0x00);
    LD_WriteReg(0x17, 0x48);
    delay( 10 );
    LD_WriteReg(0x3C, 0x80);
    LD_WriteReg(0x3E, 0x07);
    LD_WriteReg(0x38, 0xff);
    LD_WriteReg(0x3A, 0x07);
  LD_WriteReg(0x40, 0);
    LD_WriteReg(0x42, 8);
    LD_WriteReg(0x44, 0);
    LD_WriteReg(0x46, 8);
    delay( 1 );
}

void ProcessInt0(void)
{
    uint8 nAsrResCount=0;

    EX0=0;
    ucRegVal = LD_ReadReg(0x2B);
    LD_WriteReg(0x29,0) ;
    LD_WriteReg(0x02,0) ;
    if((ucRegVal & 0x10) &&
        LD_ReadReg(0xb2)==0x21 &&
        LD_ReadReg(0xbf)==0x35)
    {
        nAsrResCount = LD_ReadReg(0xba);
        if(nAsrResCount>0 && nAsrResCount4)
        {
            nAsrStatus=LD_ASR_FOUNDOK;
        }
        else
        {
            nAsrStatus=LD_ASR_FOUNDZERO;
        }
    }
    else
    {
        nAsrStatus=LD_ASR_FOUNDZERO;
    }

  LD_WriteReg(0x2b, 0);
  LD_WriteReg(0x1C,0);

    LD_WriteReg(0x29,0) ;
    LD_WriteReg(0x02,0) ;
    LD_WriteReg(0x2B,  0);
    LD_WriteReg(0xBA, 0);
    LD_WriteReg(0xBC,0);
    LD_WriteReg(0x08,1);
    LD_WriteReg(0x08,0);

    EX0=1;
}

uint8 RunASR(void)
{
    uint8 i=0;
    uint8 asrflag=0;
    for (i=0; i<5; i++)
    {
        LD_AsrStart();
        delay(50);
        if (LD_AsrAddFixed()==0)
        {
            LD_Reset();
            delay(50);
            continue;
        }
        delay(10);
        if (LD_AsrRun() == 0)
        {
            LD_Reset();
            delay(50);
            continue;
        }
        asrflag=1;
        break;
    }

    return asrflag;
}

uint8 LD_Check_ASRBusyFlag_b2()
{
    uint8 j;
    uint8 flag = 0;
    for (j=0; j<10; j++)
    {
        if (LD_ReadReg(0xb2) == 0x21)
        {
            flag = 1;
            break;
        }
        delay(10);
    }
    return flag;
}

void LD_AsrStart()
{
    LD_Init_ASR();
}

uint8 LD_AsrRun()
{
    EX0=0;
    LD_WriteReg(0x35, MIC_VOL);
    LD_WriteReg(0x1C, 0x09);
    LD_WriteReg(0xBD, 0x20);
    LD_WriteReg(0x08, 0x01);
    delay( 1 );
    LD_WriteReg(0x08, 0x00);
    delay( 1 );

    if(LD_Check_ASRBusyFlag_b2() == 0)
    {
        return 0;
    }

    LD_WriteReg(0x1C, 0x0b);

    LD_WriteReg(0xB2, 0xff);
    delay( 1);
    LD_WriteReg(0x37, 0x06);
    delay( 1 );
    LD_WriteReg(0x37, 0x06);
        delay( 5 );
    LD_WriteReg(0x29, 0x10);

    LD_WriteReg(0xBD, 0x00);
    EX0=1;
    return 1;
}

uint8 LD_AsrAddFixed()
{
    uint8 k, flag;
    uint8 nAsrAddLength;
    #define DATE_A 50
    #define DATE_B 70
    uint8 code sRecog[DATE_A][DATE_B] = {
                                                                                "xiao jie",\
                                                                                "kai fa ban yan zheng",\
                                                                                 "dai ma ce shi",\
                                                                                 "kai deng",\
                                                                                 "guan deng",\
                                                                                 "bei jing",\
                                                                                 "shang hai",\
                                                                                 "guang zhou"
                                                                            };
    uint8 code pCode[DATE_A] = {
                                                            CODE_CMD,\
                                                            CODE_KFBYZ,\
                                                            CODE_DMCS,\
                                                            CODE_KD,\
                                                            CODE_GD,\
                                                            CODE_BJ,\
                                                            CODE_SH,\
                                                            CODE_GZ
                                                         };
    flag = 1;
    for (k=0; k<DATE_A; k++)
    {

        if(LD_Check_ASRBusyFlag_b2() == 0)
        {
            flag = 0;
            break;
        }

        LD_WriteReg(0xc1, pCode[k] );
        LD_WriteReg(0xc3, 0 );
        LD_WriteReg(0x08, 0x04);
        delay(1);
        LD_WriteReg(0x08, 0x00);
        delay(1);

        for (nAsrAddLength=0; nAsrAddLength<DATE_B; nAsrAddLength++)
        {
            if (sRecog[k][nAsrAddLength] == 0)
                break;
            LD_WriteReg(0x5, sRecog[k][nAsrAddLength]);
        }
        LD_WriteReg(0xb9, nAsrAddLength);
        LD_WriteReg(0xb2, 0xff);
        LD_WriteReg(0x37, 0x04);
    }
    return flag;
}

uint8 LD_GetResult()
{
    return LD_ReadReg(0xc5 );
}

3.3 LDChip.h ：


#ifndef LD_CHIP_H
#define LD_CHIP_H

#define uint8 unsigned char
#define uint16 unsigned int
#define uint32 unsigned long

#define LD_ASR_NONE             0x00
#define LD_ASR_RUNING           0x01
#define LD_ASR_FOUNDOK          0x10
#define LD_ASR_FOUNDZERO        0x11
#define LD_ASR_ERROR            0x31

#define CLK_IN          22.1184
#define LD_PLL_11           (uint8)((CLK_IN/2.0)-1)
#define LD_PLL_MP3_19       0x0f
#define LD_PLL_MP3_1B       0x18
#define LD_PLL_MP3_1D       (uint8)(((90.0*((LD_PLL_11)+1))/(CLK_IN))-1)

#define LD_PLL_ASR_19       (uint8)(CLK_IN*32.0/(LD_PLL_11+1) - 0.51)
#define LD_PLL_ASR_1B       0x48
#define LD_PLL_ASR_1D       0x1f

void LD_Reset();
void LD_Init_Common();
void LD_Init_ASR();
uint8 RunASR(void);
void LD_AsrStart();
uint8 LD_AsrRun();
uint8 LD_AsrAddFixed();
uint8 LD_GetResult();

#define CODE_CMD  0x00
#define CODE_DMCS   0x01
#define CODE_KFBYZ  0x02
#define CODE_KD 0x04
#define CODE_GD 0x05
#define CODE_BJ 0x16
#define CODE_SH 0x17
#define CODE_GZ 0x2f

#define MIC_VOL 0x30
#endif

3.4 Reg_RW.c ：


#include "config.h"

        #define LD_INDEX_PORT       (*((volatile unsigned char xdata*)(0x8100)))
        #define LD_DATA_PORT        (*((volatile unsigned char xdata*)(0x8000)))

        void LD_WriteReg( unsigned char address, unsigned char dataout )
        {
            LD_INDEX_PORT  = address;
            LD_DATA_PORT = dataout;
        }

        unsigned char LD_ReadReg( unsigned char address )
        {
            LD_INDEX_PORT = address;
            return (unsigned char)LD_DATA_PORT;
        }

3.5 Reg_RW.h ：


#ifndef REG_RW_H
#define REG_RW_H

sbit LD_MODE    =P4^3;
sbit RSTB=P3^5;
sbit CSB=P2^1;

void LD_WriteReg( unsigned char address, unsigned char dataout );
unsigned char LD_ReadReg( unsigned char address );

#endif

3.6 config.h ：


#ifndef __CONFIG_H
#define __CONFIG_H

typedef   signed          char int8_t;
typedef   signed short     int int16_t;
typedef   signed           int int32_t;
typedef   signed       long int int64_t;

typedef unsigned          char uint8_t;
typedef unsigned short     int uint16_t;
typedef unsigned           int uint32_t;
typedef unsigned       long int uint64_t;

#define ENABLE  1
#define DISABLE  0

#include
#include "STC11XX.H"
#include "LDChip.h"
#include "Reg_RW.h"
#include "usart.h"

#define TEST

#endif

3.7 STC11XX.h ：


sfr ACC  = 0xE0;
sfr B    = 0xF0;
sfr PSW  = 0xD0;

sbit CY  = PSW^7;
sbit AC  = PSW^6;
sbit F0  = PSW^5;
sbit RS1 = PSW^4;
sbit RS0 = PSW^3;
sbit OV  = PSW^2;
sbit P   = PSW^0;

sfr SP   = 0x81;
sfr DPL  = 0x82;
sfr DPH  = 0x83;

sfr PCON   = 0x87;

sfr AUXR  = 0x8E;

sfr AUXR1 = 0xA2;

sfr WAKE_CLKO = 0x8F;

sfr CLK_DIV = 0x97;

sfr BUS_SPEED = 0xA1;

sfr IE      = 0xA8;

sbit EA       = IE^7;
sbit ELVD     = IE^6;
sbit EADC     = IE^5;
sbit ES       = IE^4;
sbit ET1      = IE^3;
sbit EX1      = IE^2;
sbit ET0      = IE^1;
sbit EX0      = IE^0;

sfr IE2       = 0xAF;

sfr IP      = 0xB8;

sbit PPCA     = IP^7;
sbit PLVD     = IP^6;
sbit PADC     = IP^5;
sbit PS       = IP^4;
sbit PT1      = IP^3;
sbit PX1      = IP^2;
sbit PT0      = IP^1;
sbit PX0      = IP^0;

sfr IPH   = 0xB7;
sfr IP2   = 0xB5;
sfr IPH2  = 0xB6;

sfr P0   = 0x80;
sfr P0M0 = 0x94;
sfr P0M1 = 0x93;
sfr P1   = 0x90;
sfr P1M0 = 0x92;
sfr P1M1 = 0x91;
sfr P1ASF = 0x9D;
sfr P2   = 0xA0;
sfr P2M0 = 0x96;
sfr P2M1 = 0x95;
sfr P3   = 0xB0;
sfr P3M0 = 0xB2;
sfr P3M1 = 0xB1;
sfr P4   = 0xC0;
sfr P4M0 = 0xB4;
sfr P4M1 = 0xB3;

sfr P4SW = 0xBB;

sfr P5   = 0xC8;
sfr P5M0 = 0xCA;
sfr P5M1 = 0xC9;

sfr TCON = 0x88;

sbit TF1 = TCON^7;
sbit TR1 = TCON^6;
sbit TF0 = TCON^5;
sbit TR0 = TCON^4;
sbit IE1 = TCON^3;
sbit IT1 = TCON^2;
sbit IE0 = TCON^1;
sbit IT0 = TCON^0;

sfr TMOD = 0x89;
sfr TL0  = 0x8A;
sfr TH0  = 0x8C;
sfr TL1  = 0x8B;
sfr TH1  = 0x8D;

sfr SCON = 0x98;

sbit SM0 = SCON^7;
sbit SM1 = SCON^6;
sbit SM2 = SCON^5;
sbit REN = SCON^4;
sbit TB8 = SCON^3;
sbit RB8 = SCON^2;
sbit TI  = SCON^1;
sbit RI  = SCON^0;

sfr SBUF = 0x99;
sfr SADEN = 0xB9;
sfr SADDR = 0xA9;

sfr S2CON = 0x9A;
sfr S2BUF = 0x9B;
sfr BRT = 0x9C;

sfr WDT_CONTR = 0xC1;

sfr CCON   = 0xD8;

sbit CF     = CCON^7;
sbit CR     = CCON^6;

sbit CCF1   = CCON^1;
sbit CCF0   = CCON^0;

sfr CMOD  = 0xD9;

sfr CL     = 0xE9;
sfr CH     = 0xF9;

sfr CCAPM0 = 0xDA;
sfr CCAPM1 = 0xDB;

sfr CCAP0L = 0xEA;
sfr CCAP0H = 0xFA;
sfr CCAP1L = 0xEB;
sfr CCAP1H = 0xFB;

sfr PCA_PWM0 = 0xF2;
sfr PCA_PWM1 = 0xF3;

sfr ADC_CONTR = 0xBC;
sfr ADC_RES  = 0xBD;
sfr ADC_RESL = 0xBE;

sfr SPCTL  = 0xCE;
sfr SPSTAT = 0xCD;
sfr SPDAT  = 0xCF;

sfr IAP_DATA    = 0xC2;
sfr IAP_ADDRH   = 0xC3;
sfr IAP_ADDRL   = 0xC4;

sfr IAP_CMD     = 0xC5;
sfr IAP_TRIG    = 0xC6;
sfr IAP_CONTR   = 0xC7;

码字不易 求个三连

LD3320语音识别模块开发

Original: https://blog.csdn.net/MRDOCMAN/article/details/125275026
Author: 纪录先生
Title: LD3320语音识别模块开发

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/515081/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球