嵌入式系统项目设计——电子琴（完整代码）-Toy模板网

这篇具有很好参考价值的文章主要介绍了嵌入式系统项目设计——电子琴（完整代码）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

内容摘自上学期嵌入式系统课程设计最终的实验报告，我作为小组组长负责代码部分的编写，与上一个实验相比，使用了相同的硬件，所以硬件示意图完全相同，实现的功能不同但原理类似。因为CSDN不支持上传word资料，所以我就摘录下来写进文章里了，希望可以帮助到你。

第一章绪论

1.1选题背景
在中国，1958年北京邮电学院研制了一台电子管单音电子琴。由于种种原因，至1977年后，我国才大批生产电子琴。1989年，我国年产儿童电子琴200万台，并出口39万台。中国的电子琴事业正在迅速发展。
电子琴发展很快，琴的各项功能日趋完善。音色和节奏有最初的几种发展到现在的几百种。除寄存音色外，还可通过插槽外接音色卡。合成器的某些功能，如音色的编辑修改、自编节奏、多轨录音、演奏程序记忆等也运用到电子琴上。

1.2 项目需求分析
1.2.1 基本功能
按下各个按键使，蜂鸣器会响起，并且根据按键的不同，蜂鸣器响起不同音调，且对应led灯发光。松手后蜂鸣器会自动停止发声。

1.2.2 扩展功能
在按下特定键位后，蜂鸣器进行特定歌曲的播放。
1.3 论文主要工作
论文主要包括四个部分，第一部分为绪论，对课题的设计背景及所要实现的功能进行简单的介绍；第二部分为系统的总体方案设计，这部分主要阐述了电子琴的设计思路与系统的设计框图，对电子琴进行一个整体的概括；第三部分为系统的实现过程及关键技术分析，此部分主要对电子琴所涉及的软硬件进行分析；第四部分为问题与解决，这部分交代了设计过程中遇到的问题与解决方法；最后一部分为总结与展望，主要分析此课题设计方案的优缺点，并给出未来的改进方向。

第二章系统的总体方案设计

2.1 设计思路
系统的主要设计思路是：1.打开设备文件，定义变量。 2.按照顺序按下键位，蜂鸣器按照对应音调发出声响，led灯也按顺序发光。 3.按下特殊按键播放歌曲。

2.2 系统框图
按照功能可以将系统划分为LED模块，按键模块，蜂鸣器模块。具体系统框图如下：

嵌入式系统项目设计——电子琴（完整代码）

第三章关键技术分析及实现过程

课题实现的关键技术主要分为软硬件部分，硬件主要包括三部分：LED模块、按键模块及蜂鸣器模块，接下来我分别对这三个模块进行介绍。

3.1系统硬件驱动部分
3.1.1 LED模块
硬件电路如下：
嵌入式系统项目设计——电子琴（完整代码）

图中U3是CH452，U8和U9是两个3位数码管。CH452是数码管显示驱动和键盘扫描控制芯片，内置时钟振荡电路，可以动态驱动8位数码管或者64只LED，具有BCD 译码、闪烁、移位、段位寻址、光柱译码等功能，同时还可以进行64键的键盘扫描。CH452 通过可以级联的4线串行接口或者2线IIC串行接口与主芯片交换数据。本实训平台CH452芯片与S5PV210主芯片采用2线接口方式相连。

程序：

/*********************CH452******************/
void CH452_I2c_WrByte(unsigned char dat)	//写一个字节数据
{
	unsigned char i;
	CH452_SDA_D_OUT;   /* 设置SDA为输出方向 */
	for(i=0;i!=8;i++)  // 输出8位数据
	{
		if(dat&0x80) {CH452_SDA_SET;}
		else {CH452_SDA_CLR;}
		DELAY_1US;//延迟1US
		CH452_SCL_SET;
		dat<<=1;
		DELAY_1US;
		DELAY_1US;
		CH452_SCL_CLR;
		DELAY_1US;
	}
	CH452_SDA_D_IN;   /* 设置SDA为输入方向 */
	CH452_SDA_SET;
	DELAY_1US;
	CH452_SCL_SET;  // 接收应答
	DELAY_1US;
	DELAY_1US;
	CH452_SCL_CLR;
	DELAY_1US;
}
void CH452_Write(unsigned short cmd)
{
	CH452_I2c_Start();             
#ifdef	ENABLE_2_CH452				// 若有两个CH452并联
	CH452_I2c_WrByte(((unsigned char)(cmd>>7)&CH452_I2C_MASK)|CH452_I2C_ADDR0);  // CH452的ADDR=0时
#else 
	CH452_I2c_WrByte(((unsigned char)(cmd>>7)&CH452_I2C_MASK)|CH452_I2C_ADDR1);  // CH452的ADDR=1时(默认)
#endif
	CH452_I2c_WrByte((unsigned char)cmd);    
	CH452_I2c_Stop();   
}
static ssize_t ch452_dev_write(struct file *file, const char *buffer,
		size_t count, loff_t *ppos)
{
	unsigned short cmd;
	int ret;
	if (count == 0) {
		return count;
	}
	ret = copy_from_user(&cmd, buffer, sizeof cmd) ? -EFAULT : 0;
//实现了从用户写入到led设备文件
	if (ret) {
		return ret;
	}
	CH452_Write(cmd);
	return count;
}
static int ch452_open(struct inode *inode,struct file *filp)
{
   CH452_Write(CH452_RESET);
delay(100);
   CH452_Write(CH452_SYSON1);//开显示
delay(100);
   CH452_Write(CH452_NO_BCD);
printk("open CH452 device");
return 0;
}
static struct file_operations CH452_fops={
        .owner=        THIS_MODULE,
        .open=         ch452_open, 
        .write=		ch452_dev_write,
}; //一个函数指针的集合，定义能在设备上进行的操作,这里主要有打开和写设备。
static int __init CH452_init(void)
{
	int ret=0;
	ret = gpio_request(S5PV210_GPD1(2), "I2C1_SDA");//gpio口的请求
	if (ret) {
		printk("%s: request GPIO %d for 452 failed, ret = %d\n", "452",
				S5PV210_GPD1(2), ret);
		return ret;
	}
		ret = gpio_request(S5PV210_GPD1(3), "I2C1_SCL");
	if (ret) {
		printk("%s: request GPIO %d for 452 failed, ret = %d\n", "452",
				S5PV210_GPD1(3), ret);
		return ret;
	}
 ret = register_chrdev(Major, "CH452", &CH452_fops);//字符设备的注册
if(ret < 0)
        {printk("fail to registern");
return -1;
        }
        s3c_gpio_cfgpin(S5PV210_GPD1(2), S3C_GPIO_OUTPUT);//sda output
        s3c_gpio_cfgpin(S5PV210_GPD1(3), S3C_GPIO_OUTPUT);//scl output
printk("success to registern");
	return 0;
}
static void __exit CH452_exit(void)
{gpio_free(S5PV210_GPD1(2));
gpio_free(S5PV210_GPD1(3));
unregister_chrdev(Major,"CH452");
}
module_init(CH452_init);
module_exit(CH452_exit);
MODULE_LICENSE("GPL");

3.1.2 按键模块
硬件电路如下：
嵌入式系统项目设计——电子琴（完整代码）

电路中八只按键通过GPIO端口与S5PV210主芯片相连，用到了GPH2(4)、GPH0(4)、GPH0(3)、GPH0(0)、GPH0(2)、GPH3(5)、GPH3(6)、GPH3(7)八个端口作为输入端，GPB7、GPB8、GPB9、GPB10作为输出端。所以相应的端口需要设置成相应输入/输出模式。

程序：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>
#define DEVICE_NAME "Buttons"
struct button_desc {
int gpio;
int number;
char *name;
struct timer_list timer;
};
static struct button_desc buttons[] = {
{ S5PV210_GPH2(4), 0, "KEY0" },
{ S5PV210_GPH0(4), 1, "KEY1" },
{ S5PV210_GPH0(3), 2, "KEY2" },
{ S5PV210_GPH0(0), 3, "KEY3" },
{ S5PV210_GPH0(2), 4, "KEY4" },{ S5PV210_GPH3(5), 5, "KEY5" },
{ S5PV210_GPH3(6), 6, "KEY6" },
{ S5PV210_GPH3(7), 7, "KEY7" },
};
static volatile char key_values[] = {
'0', '0', '0', '0', '0', '0', '0', '0'
};
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
static volatile int ev_press = 0;
static void lx_buttons_timer(unsigned long _data)
{
struct button_desc *bdata = (struct button_desc *)_data;
int down;
int number;
unsigned tmp;
tmp = gpio_get_value(bdata->gpio);
/* active low */
down = !tmp;
printk("KEY %d: %08x\n", bdata->number, down);
number = bdata->number;
if (down != (key_values[number] & 1)) {
key_values[number] = '0' + down;
ev_press = 1;
wake_up_interruptible(&button_waitq);
}
}
//*************中断处理程序********
static irqreturn_t button_interrupt(int irq, void *dev_id)
{
struct button_desc *bdata = (struct button_desc *)dev_id;
mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(40));//定时器
return IRQ_HANDLED;
}
//************打开设备**************static int lx_buttons_open(struct inode *inode, struct file *file)
{
int irq;
int i;
int err = 0;
for (i = 0; i < ARRAY_SIZE(buttons); i++) {
if (!buttons[i].gpio)
continue;
setup_timer(&buttons[i].timer, lx_buttons_timer,
(unsigned long)&buttons[i]);
irq = gpio_to_irq(buttons[i].gpio);
err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH, 
buttons[i].name, (void *)&buttons[i]);//把中断注册进内核
if (err)
break;
}
if (err) {
i--;
for (; i >= 0; i--) {
if (!buttons[i].gpio)
continue;
irq = gpio_to_irq(buttons[i].gpio);
disable_irq(irq);
free_irq(irq, (void *)&buttons[i]);
del_timer_sync(&buttons[i].timer);
}
return -EBUSY;
}
ev_press = 1;
return 0;
}
//************关闭设备********************
static int lx_buttons_close(struct inode *inode, struct file *file)
{
int irq, i;
for (i = 0; i < ARRAY_SIZE(buttons); i++) {if (!buttons[i].gpio)
continue;
irq = gpio_to_irq(buttons[i].gpio);
free_irq(irq, (void *)&buttons[i]);//中断注销
del_timer_sync(&buttons[i].timer);
}
return 0;
}
//*************读设备************************
static int lx_buttons_read(struct file *filp, char __user *buff,
size_t count, loff_t *offp)
{
unsigned long err;
//阻塞方式
if (!ev_press) {
if (filp->f_flags & O_NONBLOCK)
return -EAGAIN;
else
wait_event_interruptible(button_waitq, ev_press);
}
ev_press = 0;
err = copy_to_user((void *)buff, (const void *)(&key_values),
min(sizeof(key_values), count));//从设备中读取键值
return err ? -EFAULT : min(sizeof(key_values), count);
}
//***********用来实现按键多路监听*************
static unsigned int lx_buttons_poll( struct file *file,
struct poll_table_struct *wait)
{
unsigned int mask = 0;
poll_wait(file, &button_waitq, wait);//使用 poll_wait 将等待队列添加到
poll_table 中。
if (ev_press)
mask |= POLLIN | POLLRDNORM;//返回描述设备是否可读的掩码return mask;
}
//一个函数指针的集合，定义能在设备上进行的操作,这里主要有打开，关闭，读和监
听设备。
static struct file_operations dev_fops = {
.owner = THIS_MODULE,
.open = lx_buttons_open,
.release = lx_buttons_close, 
.read = lx_buttons_read,
.poll = lx_buttons_poll,//用来实现按键多路监听
};
//使用 struct miscdevice 来描述一个混杂设备。
static struct miscdevice misc = {
.minor = MISC_DYNAMIC_MINOR,//动态获取次设备号，混杂设备的主设备号
为 10
.name = DEVICE_NAME,//设备名
.fops = &dev_fops,//设备的操作集合
};
//***************模块加载函数************
static int __init button_dev_init(void)
{
int ret;
ret = misc_register(&misc);//使用 misc_register 函数来注册一个混杂设备驱
动。
printk(DEVICE_NAME"\tinitialized\n");
return ret;
}
//***************模块卸载函数*************
static void __exit button_dev_exit(void)
{
misc_deregister(&misc);//使用 misc_deregister 函数来注销一个混杂设备驱动。
}
module_init(button_dev_init);
module_exit(button_dev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lixin Inc.");

3.1.3 蜂鸣器模块
硬件电路如下：嵌入式系统项目设计——电子琴（完整代码）

S5PV210 主芯片通过通过 GPD0.0 管脚连接蜂鸣器，高电平时驱动三极管 Q1 导通，蜂鸣器鸣响。当使用交流信号驱动蜂鸣器时，信号频率改变蜂鸣器鸣叫频率。

程序：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/fb.h>
#include <linux/backlight.h>
#include <linux/err.h>
#include <linux/pwm.h>
#include <linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <mach/gpio.h>
#include <mach/regs-gpio.h>
#include <plat/gpio-cfg.h>
#define DEVICE_NAME "pwm"
#define PWM_IOCTL_SET_FREQ 1
#define PWM_IOCTL_STOP 0
#define NS_IN_1HZ (1000000000UL)
#define BUZZER_PWM_ID 0
#define BUZZER_PMW_GPIO S5PV210_GPD0(0)
static struct pwm_device *pwm4buzzer;
static struct semaphore lock;
//**********设置蜂鸣变频的频率**********
static void pwm_set_freq(unsigned long freq) {
int period_ns = NS_IN_1HZ / freq;
pwm_config(pwm4buzzer, period_ns / 2, period_ns);
pwm_enable(pwm4buzzer);
s3c_gpio_cfgpin(BUZZER_PMW_GPIO, S3C_GPIO_SFN(2));
}
static void pwm_stop(void) {s3c_gpio_cfgpin(BUZZER_PMW_GPIO, S3C_GPIO_OUTPUT);
pwm_config(pwm4buzzer, 0, NS_IN_1HZ / 100);
pwm_disable(pwm4buzzer);
}
//************打开设备**************
static int mini210_pwm_open(struct inode *inode, struct file *file) {
if (!down_trylock(&lock))
return 0;
else
return -EBUSY;
}
//************关闭设备**************
static int mini210_pwm_close(struct inode *inode, struct file *file) {
up(&lock);
return 0;
}
//***********设备的 ioctl 控制***************
static long mini210_pwm_ioctl(struct file *filep, unsigned int cmd,
unsigned long arg)
{
//cmd 参数由应用程序传递进来
switch (cmd) {
case PWM_IOCTL_SET_FREQ:
if (arg == 0)
return -EINVAL;
pwm_set_freq(arg);
break;
case PWM_IOCTL_STOP:
default:
pwm_stop();
break;
}
return 0;
}
//一个函数指针的集合，定义能在设备上进行的操作,这里主要有打开，关闭和 ioctl
控制设备。
static struct file_operations mini210_pwm_ops = {
.owner = THIS_MODULE,
.open = mini210_pwm_open,
.release = mini210_pwm_close, .unlocked_ioctl = mini210_pwm_ioctl,//设备的 ioctl 控制
};
//使用 struct miscdevice 来描述一个混杂设备。
static struct miscdevice mini210_misc_dev = {
.minor = MISC_DYNAMIC_MINOR,//动态获取次设备号，混杂设备的主设备号为 10
.name = DEVICE_NAME,//设备名
.fops = &mini210_pwm_ops,//设备的操作集合
};
//***************模块加载函数************
static int __init mini210_pwm_dev_init(void) {
int ret;
ret = gpio_request(BUZZER_PMW_GPIO, DEVICE_NAME);
if (ret) {
printk("request GPIO %d for pwm failed\n", BUZZER_PMW_GPIO);
return ret;
}
gpio_set_value(BUZZER_PMW_GPIO, 0);
s3c_gpio_cfgpin(BUZZER_PMW_GPIO, S3C_GPIO_OUTPUT);
pwm4buzzer = pwm_request(BUZZER_PWM_ID, DEVICE_NAME);
if (IS_ERR(pwm4buzzer)) {
printk("request pwm %d for %s failed\n", BUZZER_PWM_ID, DEVICE_NAME);
return -ENODEV;
}
pwm_stop();
 sema_init(&lock, 1);
ret = misc_register(&mini210_misc_dev);//使用 misc_deregister 函数来注销
一个混杂设备驱动。
printk(DEVICE_NAME "\tinitialized\n");
return ret;
}
//***************模块卸载函数*************
static void __exit mini210_pwm_dev_exit(void) {
pwm_stop();
misc_deregister(&mini210_misc_dev);
gpio_free(BUZZER_PMW_GPIO);
}
module_init(mini210_pwm_dev_init);
module_exit(mini210_pwm_dev_exit);MODULE_LICENSE("GPL");
MODULE_AUTHOR("FriendlyARM Inc.");
MODULE_DESCRIPTION("S5PV210 PWM Driver");

3.2 程序设计分析
电子琴代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <termios.h>
#include <string.h>

#define CH452_CLR_BIT 0x0180
#define CH452_SET_BIT 0x01C0

#define PWM_IOCTL_SET_FREQ 1
#define PWM_IOCTL_STOP 0
#define ESC_KEY 0x1b

#define a1 1047
#define a2 1175
#define a3 1319
#define a4 1397
#define a5 1568
#define a6 1760
#define a7 1967

static int fd = -1;
static int led_fd = -1;
static int buttons_fd;

static void close_buzzer(void);

static void open_buzzer(void)
{
fd = open("/dev/pwm", 0);//打开蜂鸣器设备
if (fd < 0) 
{
perror("open pwm_buzzer device");
exit(1);
}
atexit(close_buzzer);
}

static void sleep_ms(unsigned int secs)
{
struct timeval tval;
tval.tv_sec=secs/1000;
tval.tv_usec=(secs*1000)%1000000;
select(0,NULL,NULL,NULL,&tval);
}

static void close_buzzer(void)
{
if (fd >= 0)
{
ioctl(fd, PWM_IOCTL_STOP);//使用 ioctl 来控制蜂鸣器，这里是关闭蜂鸣器
if (ioctl(fd, 2) < 0)
{
perror("ioctl 2:");
}
close(fd);
fd = -1;
}
}

static void stop_buzzer(void)
{
int ret = ioctl(fd, PWM_IOCTL_STOP);
if(ret < 0) 
{
perror("stop the buzzer");
exit(1);
}
if (ioctl(fd, 2) < 0) 
{
perror("ioctl 2:");
}
}

static void set_buzzer_freq(int freq)
{
int ret = ioctl(fd, PWM_IOCTL_SET_FREQ, freq);
if(ret < 0)
{
        perror("set the frequency of the buzzer");
        exit(1);
}
}

static open_device(void)
{
buttons_fd = open("/dev/Buttons", 0);
if (buttons_fd < 0) 
    {
perror("open device buttons");
exit(1);
   }

	
led_fd = open("/dev/CH452", O_RDWR);
if(led_fd < 0)
        {
fprintf(stderr, "Error open: %s\n", strerror(errno));
return -1;
        }
}

int main()
{
unsigned yuepu[]={a1,a2,a3,a1,a2,a5,a5,a3,a6,a6,a6,a6,a5,a3,a5,a3,a1,a1,a1,a6,a6,a5,a3,a5,a2,a2,a3,a3,a2,a1,a3,a2};
int k = 0;
	
unsigned short cmd;
int r;
char buttons[8] = {'0', '0', '0', '0', '0', '0', '0', '0'};
open_device();
	
open_buzzer();

while(1){
char current_buttons[8];
int count_of_changed_key;
int i, j;

for (j=0;j<8;j++) //灭灯
 {
 cmd=CH452_CLR_BIT|0x08+j;
 write(led_fd,&cmd,sizeof(cmd)); 
 }
if(read(buttons_fd,current_buttons,sizeofcurrent_buttons)!=sizeofcurrent_buttons)
{
perror("read buttons:");
exit(1);
}

for (i = 0, count_of_changed_key = 0; i < sizeof buttons / sizeof buttons[0]; i++) //读按键
{
if (buttons[i] != current_buttons[i])
 {
 buttons[i] = current_buttons[i];
if(buttons[i] != '0')
{					
 switch(i)
 {
  case 0 : {set_buzzer_freq(a1);sleep_ms(200);stop_buzzer();break;}
  case 1 : {set_buzzer_freq(a2);sleep_ms(200);stop_buzzer();break;}
  case 2 : {set_buzzer_freq(a3);sleep_ms(200);stop_buzzer();break;}
  case 3 : {set_buzzer_freq(a4);sleep_ms(200);stop_buzzer();break;}
  case 4 : {set_buzzer_freq(a5);sleep_ms(200);stop_buzzer();break;}
  case 5 : {set_buzzer_freq(a6);sleep_ms(200);stop_buzzer();break;}
  case 6 : {set_buzzer_freq(a7);sleep_ms(200);stop_buzzer();break;}
  case 7 : {
              for(k = 0; yuepu[k]>0 ; k++)
             {
              set_buzzer_freq(yuepu[k]);
              sleep_ms(1000);
              }
stop_buzzer();break;
           }
       default : break；
}
cmd=CH452_SET_BIT|0x08+i;
    write(led_fd,&cmd,sizeof(cmd));
    sleep(1);
}	
printf("%skey %d is %s", count_of_changed_key? ", ": "", i+1, buttons[i] == '0' ? "up" : "down");
count_of_changed_key++;
}
}
if (count_of_changed_key)
       {
printf("\n");
}
}
close(led_fd);
close(buttons_fd);
return 0;
}

总体分析：在现实生活中，我们按下电子琴的按键，电子琴会响起不同音调的声音。我们把七个不同的按键赋值，来对应不同的音调，这样按下它们时，输出不不同的值，蜂鸣器识别不同的值并输出对应的音调。为了实现这一功能，我们调用了set_buzzer_freq()函数，使按键和对应的蜂鸣器音调可以匹配，并在按下按键时可以正常输出。除此之外，我们也对播放按键进行赋值，把歌曲选段的每个音符所对应的音调按合适的频率录入，按下按键时就会按照设置好的音调播放，以达到播放歌曲的功能

第四章问题与解决

问题一：主函数中只用一个while循环，每按一个按键获取键值，覆盖当前open_buzzer中的频率值，程序不够简明健壮。
解决：在while函数中设置一个switch分支，输入键值后对应进入某一个分支，使得程序简明健壮。

问题二：在刚开始运行程序，发现蜂鸣器不会按照指定的音调发出声音。
解决：在代码中，我们未设置合适的频率，导致音调上下相差不大，在听觉上没有明显差异，后更改了频率，得以解决。

问题三：按下按键后，蜂鸣器能改变音频，但一直响，不能要求的只响一声
解决：设置了延时函数，设置了sleep_ms值，用open_buzzer和stop_buzzer控制蜂鸣器开关。得以解决。

第五章总结与展望

5.1总结
本次课程设计基本完成了我们所想要实现的功能，由于时间的问题，我们没有解决更换音阶的问题，这样会使得歌曲的音调高低不准确，只能到达识别歌曲的效果，无法更加完美的演奏，但总的来说，功能已经相当完善了。通过这次课程设计，我们对主要模块的驱动及多线程有了一定的了解，熟悉了如何通过驱动完成代码要实现的功能。

5.2 展望
本次课程设计我们设定了相对较为准确的音调，在演奏时，听众有较好的听觉体验。如今是互联网时代，我们要紧跟时代潮流，我们设计电子琴的代码也要与时俱进，在未来我们可以实现多个音阶的替换使用。还可连接调用多个蜂鸣器，设置和弦背景乐，使演奏内容更加丰富。还有许多我们可以考虑的地方，但是需要我们进行更进一步的实践与完善。
电子琴的制作是我们进行软硬件开发的一次小小的经历，希望在未来我们可以做出更多有意义的东西，能运用到我们的生活中，使我们的生活更加丰富，能为祖国做出贡献。文章来源地址https://www.toymoban.com/news/detail-475871.html

到了这里，关于嵌入式系统项目设计——电子琴（完整代码）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！