基于51单片机的单电源DDS函数信号发生器proteus仿真原理图PCB

已于 2023-10-02 14:22:35 修改
阅读量1.8k 收藏 25
点赞数 1
文章标签： 51单片机 proteus 嵌入式硬件
于 2022-11-23 09:30:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimo167913/article/details/127994000
版权

功能：
0.本系统采用STC89C52作为单片机
1.LCD1602液晶显示当前输出波形类型和频率
2.可通过按键调整输出波形类型和频率
3.可通过按键设置频率更改步进值
4.支持正弦波/方波/三角波/锯齿波输出，输出频率范围:10~100Hz
5.采用DC002作为电源接口可直接输入5V给整个系统供电

原理图：
在这里插入图片描述

PCB ：
在这里插入图片描述

主程序：

#include <reg52.h> //包含头文件
#include <intrins.h>
#define uchar unsigned char //宏定义
#define uint unsigned int

sbit KEY_ADD = P2^1; //定义按键的接口
sbit KEY_SUB = P2^3;
sbit KEY_MODE = P2^2;
sbit KEY_SET = P2^0;

sbit LED_ZIGZAG = P3^2;
sbit LED_TRIANGLE = P3^3;
sbit LED_SQUARE = P3^5;
sbit LED_SINE = P3^4;

sbit LCD_RS = P3^6; //液晶控制位
sbit LCD_EN = P3^7;

char g_wave;
char g_cnt; //定义全局变量
int g_freq = 100; //*0.1Hz
int g_step = 1;
int g_stepDisp = 1;
uchar code g_table_num[] = "0123456789"; //定义显示的数组
uchar code g_table_str[] = "Freq:     Wave form:";
unsigned long T0CNT;
int T0RH;
int T0RL;
int g_mode;
unsigned char pwmValue = 50;
unsigned char outValue = 0;

//自定义字符
uchar code USER_CHAR[] = {
    0x0e, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x0e, 0x00, //正弦波	   0  1

    0x00, 0x07, 0x04, 0x04, 0x04, 0x04, 0x1c, 0x00,
    0x00, 0x1c, 0x04, 0x04, 0x04, 0x04, 0x07, 0x00, //矩形波	   2  3

    0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00,
    0x00, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, //三角波	   4  5

    0x00, 0x01, 0x03, 0x05, 0x09, 0x11, 0x00, 0x00, //锯齿波	   6
};
uchar code SINE_CHAR[64] = {
    135, 145, 158, 167, 176, 188, 199, 209, 218, 226, 234, 240, 245, 249, 252, 254, 254, 253, 251, 247, 243, 237, 230, 222, 213, 204, 193, 182, 170, 158,
    146, 133, 121, 108, 96, 84, 72, 61, 50, 41, 32, 24, 17, 11, 7, 3, 1, 0, 0, 2, 5, 9, 14, 20, 28, 36, 45, 55, 66, 78, 90, 102, 114, 128}; //正弦波取码

uchar code SQUARE_CHAR[64] = {
    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
    255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //矩形波取码

uchar code TRIANGLE_CHAR[64] = {
    0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248,
    248, 240, 232, 224, 216, 208, 200, 192, 184, 176, 168, 160, 152, 144, 136, 128, 120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0}; //三角波取码

uchar code ZIGZAG_CHAR[64] = {
    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138, 142,
    146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255}; //锯齿波取码

void DelayMs(uint t) //延时函数
{
    int i, j;
    for (i = t; i > 0; i--)
        for (j = 110; j > 0; j--)
            ;
}
void LCD_WriteCom(uchar com) //写命令函数
{
    LCD_RS = 0;
    P0 = com;
    DelayMs(1);
    LCD_EN = 1;
    DelayMs(1);
    LCD_EN = 0;
}

void LCD_WriteData(uchar dat) //写数据函数
{
    LCD_RS = 1;
    P0 = dat;
    DelayMs(1);
    LCD_EN = 1;
    DelayMs(1);
    LCD_EN = 0;
}

//自定义字符集
void LCD_RAM()
{
    uint i, j, k = 0, temp = 0x40;
    for (i = 0; i < 7; i++)
    {
        for (j = 0; j < 8; j++)
        {
            LCD_WriteCom(temp + j);
            LCD_WriteData(USER_CHAR[k]);
            k++;
        }
        temp = temp + 8;
    }
}

void Init_LCD() //初始化函数
{
    uchar i;
    LCD_EN = 0; //默认开始状态为关使能端，见时序图
    LCD_RAM();
    LCD_WriteCom(0x0f);
    LCD_WriteCom(0x38);       //显示模式设置，默认为0x38,不用变。
    LCD_WriteCom(0x01);       //显示清屏，将上次的内容清除，默认为0x01.
    LCD_WriteCom(0x0c);       //显示功能设置0x0f为开显示，显示光标，光标闪烁；0x0c为开显示，不显光标，光标不闪
    LCD_WriteCom(0x06);       //设置光标状态默认0x06,为读一个字符光标加1.
    LCD_WriteCom(0x80);       //设置初始化数据指针，是在读指令的操作里进行的
    for (i = 10; i < 20; i++) //显示初始化
    {
        LCD_WriteData(g_table_str[i]);
    }
    LCD_WriteCom(0x80 + 0x40);
    for (i = 0; i < 9; i++)
    {
        LCD_WriteData(g_table_str[i]);
    }
    LCD_WriteCom(0x80 + 10);
    LCD_WriteData(0);
    LCD_WriteData(1);
    LCD_WriteData(0);
    LCD_WriteData(1);
    LCD_WriteData(0);
    LCD_WriteData(1);
    LCD_WriteCom(0x80 + 0x40 + 0x09);
    LCD_WriteData(' ');
    LCD_WriteData('1');
    LCD_WriteData('0');
    LCD_WriteData('.');
    LCD_WriteData('0');
    LCD_WriteData('H');
    LCD_WriteData('z');
}
void Init_Timer() //时钟初始化
{
    TMOD = 0x01;
    TH0 = T0RH;
    TL0 = T0RL;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}
void Display() //显示函数
{
    uchar kilobit, hundredbit, tenbit, unitbit;
    kilobit = g_freq / 1000;
    hundredbit = g_freq % 1000 / 100;
    tenbit = g_freq % 1000 % 100 / 10;
    unitbit = g_freq % 1000 % 100 % 10;
    LCD_WriteCom(0x80 + 0x40 + 0x09);

    if (kilobit == 0)
        LCD_WriteData(' ');
    else
        LCD_WriteData(g_table_num[kilobit]);
    if (kilobit == 0 && hundredbit == 0)
        LCD_WriteData(' ');
    else
        LCD_WriteData(g_table_num[hundredbit]);
    LCD_WriteData(g_table_num[tenbit]);
    LCD_WriteData('.');
    LCD_WriteData(g_table_num[unitbit]);
    LCD_WriteData('H');
    LCD_WriteData('z');
    if (g_wave == 0)
    {
        LCD_WriteCom(0x80 + 10);
        LCD_WriteData(0);
        LCD_WriteData(1);
        LCD_WriteData(0);
        LCD_WriteData(1);
        LCD_WriteData(0);
        LCD_WriteData(1);

    }
    if (g_wave == 1)
    {
        LCD_WriteCom(0x80 + 10);
        LCD_WriteData(2);
        LCD_WriteData(3);
        LCD_WriteData(2);
        LCD_WriteData(3);
        LCD_WriteData(2);
        LCD_WriteData(3);
    }

    if (g_wave == 2)
    {
        LCD_WriteCom(0x80 + 10);
        LCD_WriteData(4);
        LCD_WriteData(5);
        LCD_WriteData(4);
        LCD_WriteData(5);
        LCD_WriteData(4);
        LCD_WriteData(5);
    }
    if (g_wave == 3)
    {
        LCD_WriteCom(0x80 + 10);
        LCD_WriteData(6);
        LCD_WriteData(6);
        LCD_WriteData(6);
        LCD_WriteData(6);
        LCD_WriteData(6);
        LCD_WriteData(6);
    }
}
void KeyScan() //键盘检测函数
{
    if (KEY_ADD == 0)
    {
        EA = 0;
        DelayMs(2);
        if (KEY_ADD == 0)
        {
            while (!KEY_ADD)
                ;
            g_freq += g_step;
            if (g_freq > 1000)
            {
                g_freq = 100;
            }
            Display();
            T0CNT = 65536 - (144000 / g_freq) + 25;
            T0RH = T0CNT / 256;
            T0RL = T0CNT % 256;
            EA = 1;
        }
    }
    if (KEY_SUB == 0)
    {

        DelayMs(5);
        if (KEY_SUB == 0)
        {
            EA = 0;
            while (!KEY_SUB)
                ;
            g_freq -= g_step;
            if (g_freq < 100)
            {
                g_freq = 1000;
            }
            Display();
            T0CNT = 65536 - (144000 / g_freq) + 25;
            T0RH = T0CNT / 256;
            T0RL = T0CNT % 256;
            EA = 1;
        }
    }
    if (KEY_MODE == 0)
    {
        DelayMs(5);
        if (KEY_MODE == 0)
        {
            EA = 0;
            while (!KEY_MODE)
                ;
            g_wave++;
            if (g_wave >= 4)
            {
                g_wave = 0;
            }
            Display();
            EA = 1;
        }
    }
}
void DisplayStep()
{
    uint hundredbit, tenbit, unitbit;
    hundredbit = g_stepDisp / 100;
    tenbit = g_stepDisp % 100 / 10;
    unitbit = g_stepDisp % 100 % 10;
    LCD_WriteCom(0x80 + 11);
    if (hundredbit == 0)
        LCD_WriteData(' ');
    else
        LCD_WriteData(g_table_num[hundredbit]);
    LCD_WriteData(g_table_num[tenbit]);
    LCD_WriteData('.');
    LCD_WriteData(g_table_num[unitbit]);
}
void ScanStep()
{
    if (KEY_SET == 0)
    {
        DelayMs(5);
        if (KEY_SET == 0)
        {
            while (!KEY_SET)
                ;
            g_mode++;
            if (g_mode == 1)
            {
                LCD_WriteCom(0x01);
                LCD_WriteCom(0x80);
                LCD_WriteData('S');
                DelayMs(1); //step value
                LCD_WriteData('t');
                DelayMs(1);
                LCD_WriteData('e');
                DelayMs(1);
                LCD_WriteData('p');
                DelayMs(1);
                LCD_WriteData(' ');
                DelayMs(1);
                LCD_WriteData('v');
                DelayMs(1);
                LCD_WriteData('a');
                DelayMs(1);
                LCD_WriteData('l');
                DelayMs(1);
                LCD_WriteData('u');
                DelayMs(1);
                LCD_WriteData('e');
                DelayMs(1);
                LCD_WriteData(':');
                DelayMs(1);
                g_stepDisp = g_step;

                DisplayStep();
            }
            if (g_mode == 2)
            {
                g_mode = 0;
                g_step = g_stepDisp;

                Init_LCD();
                Init_Timer();
                Display();
            }
        }
    }
    if (g_mode == 1)
    {
        if (KEY_ADD == 0)
        {
            DelayMs(5);
            if (KEY_ADD == 0)
            {
                while (!KEY_ADD)
                    ;
                g_stepDisp++;
                if (g_stepDisp >= 101)
                {
                    g_stepDisp = 1;
                }
                DisplayStep();
            }
        }
        if (KEY_SUB == 0)
        {
            DelayMs(5);
            if (KEY_SUB == 0)
            {
                while (!KEY_SUB)
                    ;
                g_stepDisp--;
                if (g_stepDisp <= 0)
                {
                    g_stepDisp = 100;
                }
                DisplayStep();
            }
        }
    }
}
void main() //主函数
{
    Init_LCD();
    T0CNT = 65536 - (144000 / g_freq) + 25;
    T0RH = T0CNT / 256;
    T0RL = T0CNT % 256;
    Init_Timer();
    LED_ZIGZAG = 0;
    while (1)
    {
        if (g_mode == 0)
        {
            KeyScan();
            // Display();
        }

        ScanStep();

        switch (g_wave)
        {
        case 0:
            P1 = SINE_CHAR[g_cnt];
            LED_ZIGZAG = 1;
            LED_SINE = 0;
            break;
        case 1:
            P1 = SQUARE_CHAR[g_cnt];
            // P1 = outValue;
            LED_SINE = 1;
            LED_SQUARE = 0;
            break;
        case 2:
            P1 = TRIANGLE_CHAR[g_cnt];
            LED_SQUARE = 1;
            LED_TRIANGLE = 0;
            break;
        case 3:
            P1 = ZIGZAG_CHAR[g_cnt];
            LED_TRIANGLE = 1;
            LED_ZIGZAG = 0;
            break;
        }
    }
}
void T0_time() interrupt 1 //定时器
{
    TH0 = T0RH;
    TL0 = T0RL;
    g_cnt++;
    if (g_cnt >= 64)
    {
        g_cnt = 0;
    }

    // if (g_cnt >= pwmValue)
    // {
    //     outValue = 255;
    // }
    // else
    // {
    //     outValue = 0;
    // }
}

仿真演示视频：
https://www.bilibili.com/video/BV1be411M7HE/

实物演示视频：
https://www.bilibili.com/video/BV1WN4y1K71W/

极寒钛科技
关注
  • 1
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DDS的Proteus仿真
07-18
键盘输入所需频率，1602显示，与AD9851接上就能工作
proteus仿真函数信号发生器
08-11
该压缩包中含有函数信号发生器的程序，而且包含proteus仿真图，可以验证设计，仅供参考！
DDS信号的发生器（验证篇）——FPGA学习笔记8
最新发布
m0_69082048的博客
06-23 1118
DDS（Direct Digital Synthesizer）即数字合成器，是一种新型的频率合成技术，具有低成本、低功耗、高分辨率、频率转换时间短、相位连续性好等优点，对数字信号处理及其硬件实现有着很重要的作用。DDS的基本结构主要由相位累加器、相位调制器、波形数据表 ROM、 D/A 转换器等四大结构组成，其中较多设计还会在数模转换器之后增加一个低通滤波器（LPF）。DDS 基本结构图如下图所示。由上图可以看出， DDS 主要由相位累加器、相位调制器、波形数据表以及 D/A 转换器构成。
基于51单片机+DAC0832的信号发生器
weixin_30372371的博客
05-25 4108
最近帮别人设计一个毕业设计，做一个多种信号发生器(四种波形：方波、三角波、锯齿波、梯形波)，现在贴上来给大家参考，如果有错误的地方，望指出~ 下面先贴上仿真的电路图（仿真的软件是Protuse，上传一个大点的图，方便大家看的清楚点）： 原件清单：STC89C52单片机X1、DAC0832转换器X1、12M晶振X1、电容22pfX2、10uf的电容X1、1nf陶瓷电容X1、独立按键X4、10千欧...
简易信号发生器proteus仿真（频率、幅度可调），四种波形输出，附带c程序源码（淘宝买来的）
05-17
诸位，这个文件是我从淘宝花了五十多买下来的，绝对好使。 功能是一种简易信号发生器（频率（从1-100hz）、幅度可调（5v之内）），四种波形输出（正弦波 三角波 方波 锯齿波），附带proteus仿真以及c文件。 然后程序都有代码的注释，需要改频率调节的可以直接去改就行，都好使呢。 拿这个做毕设，做论文，写仿真，都是可以的呢。
单片机信号发生器proteus仿真
10-03
基于51单片机的函数信号发生器，利用proteus仿真电路
基于51单片机的信号发生器
08-26
基于51单片机的信号发生器，包括方波、三角波】、正弦波等。内容包含C语言源码和proteus仿真。
基于51单片机+AD9833 DDS信号发生器课设原理图PCB软件源码及文档资料.rar
03-17
基于51单片机+AD9833DDS信号发生器课设原理图PCB软件源码及文档资料： 利用单片机STC89C51设计一个信号发生器，使其可产生正弦波、锯齿波、三角波、矩形波，并输出显示在示波器上。本设计中需要用到的电路有CPU、D/A...
基于DAC0832的DDS信号发生器报告+原理图+PCB图+程序代码+proteus的isis的仿真等文件
07-14
本项目旨在介绍一款基于DAC0832（数字模拟转换器）的DDS（直接数字频率合成）信号发生器的设计与实现过程，包括报告、原理图、PCB图、程序代码以及Proteus的ISIS仿真等文件，以帮助读者深入理解DDS技术及其实际应用...
基于51单片机的DAC0832信号发生器Proteus仿真及程序-C/C++代码类资源
12-05
标题中的“基于51单片机的DAC0832信号发生器Proteus仿真及程序-C/C++代码类资源”表明，这是一个关于使用51系列单片机设计的数字模拟转换器（DAC）信号发生器项目。在这个项目中，开发者使用了DAC0832芯片来生成模拟...
基于51单片机模拟DDS低频信号发生器电路方案-电路方案
04-20
总结来说，这个电路方案是基于51单片机的DDS低频信号发生器，利用单片机的强大计算能力生成高精度低失真的正弦波。通过分析DSN文件、原理图和源代码，我们可以深入学习51单片机在数字信号处理中的应用，以及DDS技术...
基于51单片机信号发生器
04-18
基于51单片机信号发生器
51单片机信号发生器.zip
04-05
51单片机制作的简易型号发生器， 首先通过51单片机输出相应的0~255的数值给DA芯片，然后输出相应的波形
基于51单片机的SPWM波信号发生器
08-14
基于51单片机的SPWM波形发生，载波比为24
基于51单片机的DDS函数信号发生器的设计电路图和汇编程序代码
06-01
通过以上分析，我们可以看出，基于51单片机的DDS函数信号发生器设计涉及了硬件电路设计、嵌入式系统编程、数字信号处理等多个领域，是一个综合性的实践项目。通过这样的设计，不仅可以学习到51单片机的使用，还能...
【51单片机】DAC0832制作信号发生器（方波，三角波，锯齿波）
热门推荐
cumtLeibnizDavid的博客
05-19 3万+
【51单片机】DAC0832制作信号发生器（方波，三角波，锯齿波）1 A/D与D/A2 电路与元器件3 源代码3.1 程序开始3.2 监视按钮操作3.3 按钮控制显示波形3.4 方波产生的方法3.5 锯齿波产生的方法3.6 三角波产生的方法3.7 程序结束4 效果4.1 方波4.2 锯齿波4.3 三角波5 参考资料 1 A/D与D/A 将模拟量转换为数字量称为模数转换（A/D转换），模拟量是连续的，比如电压、电流等，可以连续变化的量；数字量是离散的，对应于计算机中的位，每一个位只能是0或1，是不存在中间状态
基于MAX038的51单片机多功能信号发生器设计
基于51单片机的函数信号发生器是一种电子设备，用于产生多种波形，如正弦波、方波和三角波，以及进行频率计测。本文由陈敏撰写，主要介绍了该系统的硬件设计和软件控制原理。系统的核心是MAX038函数信号发生器集成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值