内容摘自上学期嵌入式系统课程设计最终的实验报告，我作为小组组长负责代码部分的编写，与上一个实验相比，使用了相同的硬件，所以硬件示意图完全相同，实现的功能不同但原理类似。因为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 展望
本次课程设计我们设定了相对较为准确的音调，在演奏时，听众有较好的听觉体验。如今是互联网时代，我们要紧跟时代潮流，我们设计电子琴的代码也要与时俱进，在未来我们可以实现多个音阶的替换使用。还可连接调用多个蜂鸣器，设置和弦背景乐，使演奏内容更加丰富。还有许多我们可以考虑的地方，但是需要我们进行更进一步的实践与完善。
电子琴的制作是我们进行软硬件开发的一次小小的经历，希望在未来我们可以做出更多有意义的东西，能运用到我们的生活中，使我们的生活更加丰富，能为祖国做出贡献。