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

原创 已于 2023-10-02 14:22:35 修改 · 2.2k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#51单片机 #proteus #嵌入式硬件

于 2022-11-23 09:30:30 首次发布
介绍了一款基于STC89C52单片机的波形发生器，支持正弦波、方波、三角波和锯齿波输出，频率范围10~100Hz。用户可以通过按键调整波形类型和频率，并设置频率更改步进值。

功能：
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/

Proteus仿真实现信号发生器汇编设计51单片机
weixin_62742962的博客
12-13 1033
【代码】利用proteus进行51单片机汇编设计。
播放一段音乐51单片机PROTEUS仿真-23.rar
最新发布
03-07
在Proteus仿真环境中，我们需要连接51单片机到一个虚拟扬声器或蜂鸣器，并确保单片机的I/O口与扬声器的输入端相连。当运行仿真时，单片机会按照程序执行，控制扬声器输出声音，从而播放出"生日快乐歌"的旋律。 总结...
proteus仿真函数信号发生器
08-11
该压缩包中含有函数信号发生器的程序，而且包含proteus仿真图，可以验证设计，仅供参考！
简易信号发生器proteus仿真（频率、幅度可调），四种波形输出，附带c程序源码（淘宝买来的）
05-17
诸位，这个文件是我从淘宝花了五十多买下来的，绝对好使。 功能是一种简易信号发生器（频率（从1-100hz）、幅度可调（5v之内）），四种波形输出（正弦波 三角波 方波 锯齿波），附带proteus仿真以及c文件。 然后程序都有代码的注释，需要改频率调节的可以直接去改就行，都好使呢。 拿这个做毕设，做论文，写仿真，都是可以的呢。
基于51单片机+DAC0832的信号发生器
weixin_30372371的博客
05-25 4314
最近帮别人设计一个毕业设计，做一个多种信号发生器(四种波形：方波、三角波、锯齿波、梯形波)，现在贴上来给大家参考，如果有错误的地方，望指出~ 下面先贴上仿真的电路图（仿真的软件是Protuse，上传一个大点的图，方便大家看的清楚点）： 原件清单：STC89C52单片机X1、DAC0832转换器X1、12M晶振X1、电容22pfX2、10uf的电容X1、1nf陶瓷电容X1、独立按键X4、10千欧...
[Proteus仿真]基于51单片机的五种信号发生器(梯形波、正弦波、三角波、方波、锯齿波)
夜间去看海的博客
03-01 8395
该项目旨在基于51单片机，采用Proteus设计一款多波形发生器，能够产生正弦波、方波、三角波、梯形波、锯齿波等不同波形。通过五个开关（K1-K5）的选择，用户可以灵活切换并观察各种波形的输出。项目融合了硬件设计和嵌入式系统开发，具备可扩展性，便于后续优化和升级。
基于DAC0832的DDS信号发生器设计与仿真
结合标签信息（如DDS、DAC0832、信号发生器、Proteus仿真、ISIS、原理图、PCB图、程序代码、单片机、波形生成），可以深入展开多个关键知识点。 首先，“DDS”即直接数字频率合成技术（Direct Digital Synthesis）...
基于单片机的函数信号发生器设计与实现
本项目《C语言开发课程设计基于单片机的函数信号发生器的设计与制作》是一项综合性极强的嵌入式系统开发实践，涵盖了从硬件电路设计、单片机编程、数模转换技术到人机交互界面实现等多个关键技术领域。该项目以C语言...
基于51单片机的双通道波形发生器设计与实现
该设计以经典的STC89C52或AT89S52等51系列单片机为核心控制器，结合DAC0832数模转换芯片、LCD1602液晶显示模块、独立按键输入模块以及Proteus仿真平台，构建了一个具备双通道输出、支持四种基本波形（正弦波、方波、...
单片机信号发生器proteus仿真
10-03
基于51单片机的函数信号发生器，利用proteus仿真电路
基于51单片机的信号发生器
07-11
利用AT89S52单片机采用程序设计产生固定幅度的方波、锯齿波、三角波及正弦波，通过D/A转换器DAC0832将数字信号转换成模拟信号，滤波放大，最终由示波器显示出来。
基于51单片机信号发生器
04-18
基于51单片机信号发生器
51单片机信号发生器.zip
04-05
51单片机制作的简易型号发生器， 首先通过51单片机输出相应的0~255的数值给DA芯片，然后输出相应的波形
波形信号发生器设计 Proteus仿真--输出频率可调的正弦波、三角波、方波
热门推荐
Backlight__的博客
10-10 6万+
第一次写博客，记录一下自己做的一个小实验，不喜勿喷！文中若有不正确的地方，欢迎大家指正！ 1 绪论 1.1 设计任务与要求 使用分立元器件设计一个频率可调（100-10KHz）产生正弦波、方波、三角波的电路。 1.2 主要内容 本文主要描述了波形信号发生器的设计，详细的介绍了基于运算放大器LM324波形信号发生电路的搭建，能够实现输出频率在100Hz-10KHz可调的正弦波、方波、三角波。本设计以LM324为核心芯片，由RC桥式振荡电路产生正弦波，再经由过零比较器产生方波，最后经过积分电路产...
【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，是不存在中间状态
51单片机可调幅度频率波形信号发生器( proteus仿真+程序+原理图+报告+讲解视频）
weixin_52733843的博客
10-03 6019
51单片机可调幅度频率信号发生器( proteus仿真+程序+原理图+报告+讲解视频）仿真图proteus7.8及以上程序编译器：keil 4/keil 5编程语言：C语言设计编号：S0055。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值