嵌入式开发岗位职责（精选多篇）

发布时间：2020-05-12 08:38:30 来源：岗位职责收藏本文下载本文手机版

推荐第1篇：软件开发工程师(嵌入式开发)岗位职责

1.设计芯片驱动程序，编写软件概要和详细设计说明书。2.编写驱动代码,并进行单元测试和系统测试。3.配合硬件工程师调试硬件电路。4.单板软件需求分析、设计、编码与测试。

推荐第2篇：嵌入式开发学习心得

个人学习嵌入式心得体会

就我个人而言，从最开始对嵌入式一窍不通到现在越学越感兴趣，当然相应在嵌入式方面的提高也是很明显的。学习潜入式越来越成为我学习生活的一部分，现在把我的学习过程与大家一起分享，希望那些和我一样对嵌入式想学而又迷茫，不知从哪入手的同学朋友有所帮助。

一、语言基础

嵌入式开发很大一部分靠C语言，尤其在底层驱动等用的很多，当然在应用开发还用到诸如C++等其他语言，但我想对于一个初学者有C基础就足够了，等到学到一定程度再去扩展。所以，C 基础是学嵌入式的前提。

二、单片机等知识的储备

我觉得单片机、嵌入式等这一类都有很大的相似性，知识功能不一样，但工作的原理、控制原理都和大的相似。就我个人而言，能比较快的进入嵌入式的学习与提高，很大一部分依赖于对单片机的原理有较深入的学习和理解，单片机比较简单，学习起来相对比较容易，所以我建议哪些想学潜入式的同学，可以和我一样从单片机入手，那样不仅可以理解这些微处理器、微控制器的操作与控制原理，当然还可以顺便学学汇编语言，这对后面的嵌入式学习都有很大的帮助。

三、接受培训

暑假，我在学院的组织下参加过ICC的嵌入式培训，虽然接触的都是皮毛，但是对我进入嵌入式的学习起了一个很好的引导作用。所以，如果有条件的可以去报名正规的专门的培训班，这样如果遇到问题也可以比较容易的得到老师或专业人士的指导，提高学习效率。

四、买开发板自己动手做

个人觉得这是最重要的一种做法。这东西没自己亲手做，程序没亲手写，没有进行调试等，都是很难学到东西，因为很多东西感觉看的都懂，其实真正做起来就什么都不会了。因此买块板来自己做，这样才能真正将所学的应用到实际中去。而且这样做映像很深，死记硬背原理及规则不但不可行还会拖垮你的学习兴趣，自然学不下。

总之，我觉得，基础知识很重要，但是动手做更重要！我能说的就这些了，能力有限，不好的地方请指教！

推荐第3篇：嵌入式开发学习心得

嵌入式开发学习心得

就我个人而言，从最开始对嵌入式一窍不通到现在越学越感兴趣，当然相应在嵌入式方面的提高也是很明显的。学习嵌入式越来越成为我学习中的一部分，现在把我的学习过程的心得体会与大家一起分享，希望那些和我一样对嵌入式想学而又迷茫，不知从哪入手的同学朋友有所帮助。

1 基础知识

嵌入式开发很大一部分靠C语言，尤其在底层驱动等用的很多，当然在应用开发还用到诸如C++等其他语言，但我想对于一个初学者有C基础就足够了，等到学到一定程度再去扩展。所以C 基础是学嵌入式的前提。

关于C语言需要知道基本的语法，什么是结构体，什么是共用体，有什么区别，不用强记一些实际中用的很少的东西。C++要知道什么是类，怎么定义，继承，接口，要深刻理解，当然基本语法也是必不可少的。

操作系统原理也需要基本理解和掌握的，我记得我上课的时候不以为然没有认真学习，后来发现很多的东西都是在这个课上讲到的。什么时间片啊，任务调度啊，都是在那里知道的。

Linux基本命令的使用（vi编辑器必须会用，因为在终端修改文件的时候只能用这个），我们现在很多的人都习惯用鼠标了，很少用到命令，我学习嵌入Linux就强迫自己去改掉这个习惯了，Linux用命令操作一是效率高，二是功能非常强大，远非图形界面能比的了的，其实我们用图形界面的操作都要转化为命令传给硬件的。Linux文件系统的管理要清楚，哪个目录存放是什么东西，有什么用，文件权限管理等。

2 单片机知识的学习

我觉得单片机、嵌入式等这一类都有很大的相似性，知识功能不一样，但工作的原理、控制原理都和大的相似。就我个人而言，能比较快的进入嵌入式的学习与提高，很大一部分依赖于对单片机的原理有较深入的学习和理解，单片机比较简单，学习起来相对比较容易，所以我建议想学嵌入式的同学，可以和我一样从单片机入手，那样不仅可以理解这些微处理器、微控制器的操作与控制原理，当然还可以顺便学学汇编语言，这对后面的嵌入式学习都有很大的帮助。

看书不要希望一次就会，一次就明白是什么意思，也不要死记硬背，看不明白也没关系，以后遇到了知道去哪里去找就可以了，以后遇到的多了，也就记住了，遇到的少的，忘记也就忘记了。还有，不要直接阅读Linux内核源代码，看一些自己把头撞破也想不明白的事，一开始很打击我的积极性，要循序渐进，刚开始我就从学习做led开始的，接着学习做个串口，慢慢的就开始学着做硬件编解码了。

3 学习开发板

我在刚开始学习嵌入式时就买了一块学习板，现在的开发板不是很贵，给很我们初学者减轻了经济负担。看再多的视频，看再多的书，也不如自己动手试一下，看着很简单的东西，做起来就可能遇到很多的问题，遇到问题找到原因，解决问题，只有这样才能学到东西，记得我第一次写led的驱动，想自己试一下，网上也有人写过相关的代码，可是自己一试，就出了好多的问题，那个led弄了我一天才把led灯点亮。所以不要眼高手低。

4 不要好高骛远，要脚踏实地

我拿到开发板时，很兴奋也很激动，想法自然也很多，想用开发板实现自己的这个想法，实现那个想法，然后又不知道从何下手，然后就去论坛中发一个贴， “那个什么什么怎么实现啊，哪位大侠能详细说一下啊，跪求！！”，然后等着别人去回复。我觉得有想法是好的，我们要实现自己的想法也是有前提的，首先，我们对这部分知识了解吗？如果不了解就去Google一下（最好别用百度，不太好用），了解了一些，也就大概知道要怎么做了。如果再遇到问题，再去发贴问，这样也显得我们有一点点水平啦。比如自己连串口是什么都不太清楚呢，就问串口通信怎么做啊，就是人家把代码给我们，我们也不明白是怎么回事啊。

5 多看代码，多写代码

见多识广，熟能生巧。多看代码，要从代码中读出代码的意思来。自己平时也要多写代码，多练习(这一点我做的不好，写的少)。

个人觉得这是最重要的一种做法。这东西没自己亲手做，程序没亲手写，没有进行调试等，都是很难学到东西，因为很多东西感觉看的都懂，其实真正做起来就什么都不会了。因此买块板来自己做，这样才能真正将所学的应用到实际中去。而且这样做印象才能深刻，死记硬背原理及规则不但不可行还会拖垮你的学习兴趣，自然学不下。

总之，我觉得，基础知识很重要，但是动手做更重要！

推荐第4篇：嵌入式开发工程师

任职要求：

1、大学本科及以上学历，2年以上工作经验，计算机电子通讯类专业毕业；

2、能够熟练使用POWER PCB或PROTEL或ORCAD等电路设计软件进行PCB设计；

3、熟悉电子元器件，能独立设计数字及模拟电路，拥有单片机开发工作经验，懂得RF433\\无线及红外遥控等相关知识；

4、熟练使用C语言，有嵌入式开发工作开发及智能家居防盗报警产品经验者优先。

岗位职责：

1、新产品项目设计开发工作；

2、为相关部门及项目提供技术支持；

3、产品售后返修分析，品质不断提升性能改进；

4、组织对新研发产品的制样、验证、试产、量产等工作的确认与审核。

推荐第5篇：Android 嵌入式开发心得体会

Android 嵌入式开发心得体会

刚开始接触Android感觉到它很有意思，在界面开发上和web也可以形成了相通的架构，更加方便，视觉上也是非常的酷，在前期我通过的大量的Android SDK开发范例大全中的例子以及Android提供的APIDEMOS进行学习，尽管例子之间的连接比较零散，不过通过这些例子的学习我可以学习到了很多和以前java上相通的思想，因为Android在现在也是全新的技术和框架，在其中我也学到了如何用单例模式、工厂模式等常用的设计模式进行学习，通过API进行开发客户端，对Request发送，Response处理中通过比较方便的JSON对象传输，以及对XML、JSON、图片、业务等下载处理，对API接口调用等问题处理，学习Android心得体会。首先在界面上，我们同样可以通过不同布局进行设计非常酷的界面，这些界面可以通过include进行引入，和jsp、html也有相通的地方，同样在android上可以用到自定义的样式这和c也有比较相通的地方，我们可以通过一些公用的方法写个BaseActivity这个基类，通过继承方式比较不错的实现了Activity的界面，因为这样你可以Header(头部)和Footer(尾部)进行处理一些触发事件或者特效等，布局模式以相对模式为主，线线布局模式可以在比较简单的include进行完成，最重要的一点就是：我们可以自己通过重写方法或者通过实现View或者Layout等类进行扩充项目需要的布局(或者控件),在学习界面中，我发现Android为我们提供了很好的类似反射机制，通过Layout文件夹下的配置文件，可以快速的形成界面，在配置文件可以设置属性或者样式都是很快捷方便。对比较特殊的界面也可以通过处理嵌入到指定的界面，同样你可以通过java代码直接创建View进行添加，不过这种方式比较复杂。对一些点击、选中、按键等处理的事件，界面之间的跳转Intent管理，通过Bundle对数据在界面之间进行传输。其次在手机交互式通信服务中，学习了Android手机之间进行短信发送、广播、对广播的监听、服务等，在Service类中没有context，可以通过Handler来每秒反复运行，自动送出系统广播信息，同时在这里我们也知道可以设计一个常用的变量类，设计一个当前的CurrentActivity这个变量进行控制，进行处理。

总而言之，Android设计还是比较自由开阔的，只要有想法，自己动手便能实现。

推荐第6篇：嵌入式底层开发总结

嵌入式底层开发总结

51单片机应该是大部分搞嵌入式最先接触的，也是学生时期接触的第一款单片机，本人是电子信息工程毕业的，接触的第一个单片机也是51，然后是STM32.51和STM32 STM32比51 难一点，不过本质上都是单片机，STM32片上外设多很多，定时器啥的复杂多的多。STM32片上外设多，功能强大，可以说学了STM32之后基本上所有的单片机应该都能马上上手的，虽然我也只是只接触到51 和STM32.。大四全国电子设计大赛之后就再也没有接触到单片机了。后来工作就一直是ARM+linux，android。

------------------ 任何计算机系统都是软件和硬件的结合体，如果只有硬件而没有软件，则硬件是没有灵魂的躯壳；如果只有软件没有硬件，则软件就是一堆无用的字符。在底层硬件的基础上，操作系统覆盖一层驱动，屏蔽底层硬件的操作，通过特定的软件接口去操作底层硬件，用户在用户空间可以很容易的把软件设计目标放在策略与需求上，可以很方便的屏蔽掉底层实现，从而很好的完成客户功能需求。计算机系统是软件和硬件的结合体。而软件又分为应用层软件和驱动层软件。驱动层软件是应用层软件和底层硬件的纽带。通过驱动层软件实现对底层硬件屏蔽。

在裸机时代，比如单片机系统，程序员往往是直接操作硬件寄存器，直接设置硬件。而在Linux操作系统中，硬件驱动程序中实现对硬件直接操作，而用户空间，通过通用的系统调用接口，实现对硬件操作，应用程序没有直接操作底层设备，通过posix标准，应用程序的系统调用往往是被规定和限值，用户只能通过规定的接口实现对底层硬件的操作，导致了应用程序在类UINIX操作系统具有非常好的可移植性。

图2.1 直接操作硬件程序

上图2.1 是裸机时代，应用程序和硬件操作糅合在一起，应用程序和硬件操作高度耦合的框图，上述代码一般很难有良好的代码互用和移植性。往往从一个平台移植到另一个平台，甚至是同一平台不同硬件配置都要求很大的代码改动，另外从应用层来说，应用与驱动高度耦合，应用程序也几乎难以移植，甚至说是没有应用程序概念，原因在于应用与驱动的纠缠不清。

图2.2 无操作系统应用程序和设备驱动程序关系

上图2.2所示，良好的裸机代码框架，设备驱动层和应用层之间有良好的分层思想，用户可以较好的实现策略和需求，例如：客户要求实现流水灯程序，程序员在底层机制实现(硬件操作)的基础下，可以充分在用户应用程序中把主要精力方法流水灯的实现，即策略。但是在良好的裸机程序设计，代码移植性可能从一个平台移植到另外一平台只需要修改少量的底层驱动，例如：LED_ON()的实现。但是在用户空间，没有系统调用概念，函数接口千差万别。应用程序移植性差。

图2.3 Linux系统调用框图

操作系统中，需求决定应用程序，通过系统调用，调用底层驱动，此外，在驱动程序中，把一部分公用的驱动接口抽象出来，如此，程序员只需修改很少量的驱动资源，形成特定的驱动框架。导致用户只需添加专用的硬件属性作为平台资源，在内核中获取资源，大大解放了设备驱动开发，提高了设备驱动的通用型。在用户空间，由于遵循posix标准，类UNIX操作系统中，所有操作接口基本一样，从而方便了应用程序的移植，应用程序几乎不要做修改。如图2.3所示。

Linux操作系统对于所有的硬件都是当做一个文件来操作：一切设备皆文件。Linux设备文件一般分为字符设备，块设备，网络设备。在Linux系统中，除了网络设备之外，所有的设备都被映射到Linux的文件系统中。如图2.4所示。

图2.4 Linux操作系统与应用程序关系

---------------- 讲讲51，linux，安卓之间的差别。先申明一下，我是实际工作中没有使用过单片机，我使用单片机仅仅是用来参加全国电子设计大赛。工作主要在android driver这一块。我们这一行很多人说单片机是有瓶颈的，我也不是很清楚。但是实话实说，这鸟东西太简单了，没啥技术含量的，你要之后android的庞大。

欢迎点赞。后面会说说android，linux，51,32单片机之间的联系与学习方法，虽然我也是菜鸟，如果你现在看不懂也没关系，有个映像就行。以后就有方向去学习了。想当初我真的是一个人孤孤学习linux ================= 补充一个：单片机要点亮一个led等，同样在安卓上你点亮一个灯也要驱动的，不然怎么亮呢，只是我们只看到了app。背后驱动，怎么实现的，安卓架构，跟单片机有啥区别，相同的地方。其实手机arm芯片跟单片机都是嵌入式微处理器，单片机叫做微控制器。高通，mtk啥的也是嵌入式微处理器～都是一样的～但是难度你想想看就知道了。

51单片机大家都知道了，裸机，直接操作硬件，直观，简单，没有框架，没有系统。 STM32，可以学习一下RTOS了，实时的小系统，ucos II等等许多实时系统，STM32+ucos II这种组合学习方式还是挺好的。STM32比较难的在我印象中一个是时钟树，因为我们从51，没有时钟树的概念12M晶振，时钟不要你配置，而比较新的ARM框架，外设都是有时钟的。可能刚刚接触概念不是很清楚，但是也是很简单的。另外一个是定时器，什么输入捕获模式，定时器模式，编码器模式。。。。。强大的多，比起51。总的来说还是简单的。因为是没有框架的原因，代码量真的很少。你要知道，MTK android 5.1 所有的东西加起来 10G多，包括bootloader，linux kernel，android framework ，定制的部分。等等。我们接触的就那些目录，当你去看C++，java代码时，你就知道面向过程的代码真的很容易看。可能有些朋友不知道android的框架，以及android 与linux之间的关系，以及linux驱动与裸机的关系，联系与区别。你现在只要知道linux驱动比较大，android框架更大。单片机简单。单片机一般是C语言，而android一般涉及三种语言：底层linux内核C，中间的JNI层是C++，framework和app是java。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 学过51单片机的朋友知道，我们要点亮一个LED灯，是这样子的P0 = xxx ，我们就点亮了一个，好。一烧写，好，灯亮了。linux，上我们要亮一个灯，有点难了，有了操作系统，没那么容易了。一般人搞不定了。好，到android，更加难了。但是你想一想手机芯片也是ARM。亮灯这种肯定都是CPU的管脚操作。上了系统了，难了，点个灯都费劲的。本质上是一样的。很多人都知道单片机有瓶颈的。原因是会点硬件，会点C，轻轻松松就可以亮灯的。入门容易。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 我举一个小的例子说明一下51，linux，android三者的之间的差别。你就知道是啥区别。下面是51单片机：大概是这样: int main(void) //一个main函数搞定 { P0 = 0xxx; while(1); return 0; } linux：驱动程序： #include #include #include //file_operatios

//cla_create/device_create #include #include //kmalloc #include //ioremap #include #include\"led.h\"

struct s5pv210_device *s5pv210_dev;

volatile unsigned long *gpc0con = NULL; volatile unsigned long *gpc0dat = NULL;

staticintled_open(structinode *inode, struct file *file) { printk(KERN_INFO\"%s()-%d\\n\", __func__, __LINE__);

/*初始化GPC0_3，GPC0_4引脚功能为输出功能*/ *gpc0con &= ~((0xf

staticize_tled_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { printk(KERN_INFO\"%s()-%d\\n\", __func__, __LINE__); return 0; }

//write(fd, &val, 4) static ize_tled_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { int ret; unsignedintval; printk(KERN_INFO\"%s()-%d\\n\", __func__, __LINE__);

/*获取用户空间数据*/ ret = copy_from_user(&val,buf,count); if(ret) { printk(KERN_ERR\"copy data from user failed!\\n\"); return -ENODATA; }

printk(KERN_INFO\"copy data from user: val=%d\\n\",val); if(val) { //点亮LED *gpc0dat |= ((0x1

staticstructfile_operationsled_fops={ .owner = THIS_MODULE, .open = led_open, .read = led_read, .write = led_write, .release = led_close, };

staticint __initled_init(void) { int ret; printk(KERN_INFO\"%s()-%d\\n\", __func__, __LINE__); s5pv210_dev = kmalloc(sizeof(struct s5pv210_device),GFP_KERNEL); if(s5pv210_dev==NULL) { printk(KERN_INFO\"no memory malloc for s5pv210_dev!\\n\"); return -ENOMEM; } /*注册*/ led_major = register_chrdev(0,\"led\",&led_fops); if(led_major

/*创建设备文件*/ s5pv210_dev->led_cla = cla_create(THIS_MODULE,\"led_cla\"); if (IS_ERR(s5pv210_dev->led_cla)) { printk(KERN_ERR \"cla_create() failed for led_cla\\n\"); ret = -EINVAL; goto err2; }

s5pv210_dev->led_device = device_create(s5pv210_dev->led_cla,NULL,MKDEV(led_major,0),NULL,\"led\"); if (IS_ERR(s5pv210_dev->led_device)) { printk(KERN_ERR \"device_create failed for led_device\\n\"); ret = -ENODEV; goto err3; }

/*将物理地址映射为虚拟地址*/ gpc0con = ioremap(S5PV210_PA_GPC0CON,8); if(gpc0con==NULL) { printk(KERN_INFO\"ioremap failed!\\n\"); ret = -ENOMEM; goto err4; } gpc0dat = gpc0con + 1;

return 0; err4: device_destroy(s5pv210_dev->led_cla,MKDEV(led_major,0)); err3: cla_destroy(s5pv210_dev->led_cla); err2: unregister_chrdev(led_major,\"led\"); err1: kfree(s5pv210_dev); return ret; } static void __exit led_exit(void) { printk(KERN_INFO\"%s()-%d\\n\", __func__, __LINE__); unregister_chrdev(led_major,\"led\"); device_destroy(s5pv210_dev->led_cla,MKDEV(led_major,0)); cla_destroy(s5pv210_dev->led_cla); iounmap(gpc0con); kfree(s5pv210_dev); } module_init(led_init); module_exit(led_exit); MODULE_LICENSE(\"GPL\");

应用程序：

#include #include #include #include #include #include #include #include /* ** ./led_test on 点亮LED ** ./led_test off 熄灭LED */ int main(intargc, char **argv) { intfd; intval =0; fd = open(\"/dev/led\", O_RDWR); if(fd

if(strcmp(argv[1], \"on\")==0) { val = 1; } else { val = 0; }

if(write(fd, &val, 4)!=4) { perror(\"write failed!\\n\"); exit(1); } close(fd); return 0; }

android：

不知道大家清不清楚android与linux之间的关系。

android是基于linux内核的，linux操作系统的5大组件：驱动，内存管理，文件系统，进程管理，网络套接字。android是基于linux kernel上的，大家平时只看到了app。app是java语言的，其实每运行一个java应用程序，实际上是fork一个linux应用程序。android四大组件，activity，service，Broadcast Receiver,Content Provider。这是android的主要框架，java应用开发是基于这开发的。android平台是基于linux内核的。在linux运行之后才建立起java世界。

直接上代码：上面的linux的驱动在android是一样的，适用于android。驱动ok之后是应用层了，也就是应用程序。我下面就是最直接的应用，不包含任何android框架性的东西，大家可以直接看到，应用app->jni->linux驱动这三层调用关系。下面是jni代码是c++； #define LOG_TAG \"led-jni-log\" #include

#include \"jni.h\"

#include #include #include #include #include #include #include

staticintfd = -1; jintopen_led(JNIEnv *env, jobjectthiz) { LOGD(\"$$%s\\n\", __FUNCTION__); fd = open(\"/dev/led1\", O_RDWR); if(fd

jintled_on(JNIEnv *env, jobjectthiz) { LOGD(\"$$%s\\n\", __FUNCTION__); intval = 1; jint ret = 0; ret = write(fd, &val, 4); if(ret != 4) { LOGE(\"write : %s\\n\", strerror(errno)); return -1; } return 0; }

jintled_off(JNIEnv *env, jobjectthiz) { LOGD(\"$$%s\\n\", __FUNCTION__); intval = 0; jint ret = 0; ret = write(fd, &val, 4); if(ret != 4) { LOGE(\"write : %s\\n\", strerror(errno)); return -1; } return 0; }

jintclose_led(JNIEnv *env, jobjectthiz) { LOGD(\"$$%s\\n\", __FUNCTION__); if(fd>0) close(fd); return 0; }

staticJNINativeMethodmyMethods[] ={ {\"openDev\", \"()I\", (void *)open_led}, {\"onDev\", \"()I\", (void *)led_on}, {\"offDev\", \"()I\", (void *)led_off}, {\"closeDev\", \"()I\", (void *)close_led}, }; jintJNI_OnLoad(JavaVM * vm, void * reserved) { JNIEnv *env = NULL; jint ret = -1; ret = vm->GetEnv((void **)&env, JNI_VERSION_1_4); if(ret

jclamyclz = env->FindCla(\"com/ledtest/LedActivity\"); if(myclz == NULL) { LOGE(\"FindCla error\\n\"); return -1; } ret = env->RegisterNatives(myclz, myMethods, sizeof(myMethods)/sizeof(myMethods[0])); if(ret

return JNI_VERSION_1_4; } 然后是java app： packagecom.ledtest;

importandroid.os.Bundle; importandroid.app.Activity; importandroid.util.Log; importandroid.view.Menu; importandroid.view.View; importandroid.view.View.OnClickListener; importandroid.widget.Button;

public cla LedActivity extends Activity {

final String TAG = \"LedActivity\"; public Button btn_on = null; public Button btn_off = null;

public void init() { btn_on = (Button) this.findViewById(R.id.btn1); btn_on.setOnClickListener(clickListener);

btn_off = (Button) this.findViewById(R.id.btn2); btn_off.setOnClickListener(clickListener); }

OnClickListenerclickListener = new OnClickListener() { public void onClick(View v) { switch (v.getId()) { case R.id.btn1: Log.d(TAG, \"led on in app\"); onDev(); break; case R.id.btn2: Log.d(TAG, \"led off in app\"); offDev(); break; default: break; } } };

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_led); init(); openDev(); }

@Override publicbooleanonCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present.getMenuInflater().inflate(R.menu.activity_led, menu); return true; }

@Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy();

closeDev(); } static { System.loadLibrary(\"led_jni\"); }

public native intopenDev();

public native intonDev();

public native intoffDev();

public native intcloseDev(); }

框架是这样的：最上层是java ，点开app，点击一下一个button，点亮了LED，调用onDev();onDev调用c++的led_on，然后led_on是调用驱动的led_write，明白不？这样说吧：linux驱动是最下层的，驱动嘛。然后是c++层，c++包装一下是给java调用的，然后到java层。下面是android比价经典的一张框架图。

linux在最下面。lib 是动态库。然后是JNI，然后是Framework（android框架），然后是大家喜闻乐见的app。linux在最下面。lib 是动态库。然后是JNI，然后是Framework（android框架），然后是大家喜闻乐见的app。

推荐第7篇：嵌入式Linux开发流程

嵌入式Linux开发流程

嵌入式 linux开发，根据应用需求的不同有不同的配置开发方法，但是一般都经过以下过程：

建立开发环境。操作系统一般 REDHAT－LINUX，版本 7 到9 都可以，选择定制安装或全部安装，通过网络下载相应的 GCC 交叉编译器进行安装（比如 arm-linux-gcc、arm-uclibc-gcc），或者安装产品厂家提供的交叉编译器。

配置开发主机。配置 MINICOM，一般参数为115200，数据位 8位，停止位 1，无奇偶校验，软硬件控制流设为无。在 WINDOWS 下的超级终端的配置也是这样。MINICOM软件的作用是作为调试嵌入式开发板信息输出的监视器和键盘输入的工具；配置网络，主要是配置 NFS 网络文件系统，需要关闭防火墙，简化嵌入式网络调试环境设置过程。

建立引导装载程序BOOTLOADER，从网络上下载一些公开源代码的BOOTLOADER，如 U-BOOT、BLOB、VIVI、LILO、ARM-BOOT、RED-BOOT等，根据自己具体芯片进行移植修改。有些芯片没有内置引导装载程序，比如三星的 ARM

7、ARM9 系列芯片，这样就需要编写烧写开发板上 flash 的烧写程序，网络上有免费下载的 WINDOWS 下通过JTAG并口简易仿真器烧写 ARM 外围 flash 芯片的程序。也有 LINUX 下公开源代码的J-FLASH 程序。如果不能烧写自己的开发板，就需要根据自己的具体电路进行源代码修改。这是让系统可以正常运行的第一步。如果你购买了厂商提供的仿真器，当然比较容易烧写flash了，但是其中的核心技术是无法了解的。这对于需要迅速开发应用的人来说可以极大地提高开发速度。

下载别人已经移植好的 LINUX 操作系统，如 UCLINUX、ARM-LINUX、PPC-LINUX等，如果有专门针对你所使用的CPU移植好的 LINUX 操作系统那是再好不过，下载后再添加自己的特定硬件的驱动程序，进行调试修改，对于带 MMU的 CPU可以使用模块方式调试驱动，对于 UCLINUX 这样的系统好像只能编译进内核进行调试。

建立根文件系统，从下载使用 BUSYBOX 软件进行功能裁减，产生一个最基本的根文件系统，再根据自己的应用需要添加其他的程序。默认的启动脚本一般都不会符合应用的需要，所以就要修改根文件系统中的启动脚本，它的存放位置位于 /etc目录下，包括：/etc/init.d/rc.S、/etc/profile、/etc/.profile 等，自动挂装文件系统的配置文件/etc/fstab，具体情况会随系统不同而不同。根文件系统在嵌入式系统中一般设为只读，需要使用 mkcramfs、genromfs 等工具产生烧写映象文件。

建立应用程序的 flash 磁盘分区，一般使用JFFS2 或 YAFFS 文件系统，这需要在内核中提供这些文件系统的驱动，有的系统使用一个线性 flash（NOR 型）512K－32M，有的系统使用非线性 flash（NAND型）8－512M，有的两个同时使用，需要根据应用规划 flash的分区方案。

开发应用程序，可以下载到根文件系统中，也可以放入 YAFFS、JFFS2 文件系统中，有的应用程序不使用根文件系统，而是直接将应用程序和内核设计在一起，这有点类似于UCOS-II 的方式。

烧写内核、根文件系统、应用程序。

发布产品。

推荐第8篇：嵌入式开发工程师简历

【个人信息】姓名：

身高：

性别：

学历：

籍贯：

专业：电子信息工程

联系电话：

E-mail：

【求职意向】 嵌入式开发工程师或相关工作,对LINUX驱动开发极感兴趣

【工作经验】 2009.3----2010.3中山长宝GPS卫星导航有限公司

 2009.1----2009.3中山世博游艺有限公司

【教育背景】 2010.3——2010.7广州粤嵌通信科技股份有限公司（简称粤嵌教育）ARM+Linux培训

 2005.9——2009.6广州大学松田学院电子信息工程工学学士

【项目经验】



 GPS车载终端，GPS个人定位器（从事一年相关工作）基于ARM9的嵌入式智能家居系统（QT图像界面，应用程序，驱动等）基于ARM9的嵌入式视频点播系统（包括本地播放，网络播放） ARM9（S3C2440）的嵌入式系统移植（Uboot,Kernel,Rootfs,Driver） LINUX简单聊天工具

【相关技能】



 英语水平: 四级掌握C、C++编程，有良好的编程风格了解Linux内核机制，熟悉Linux驱动开发熟练使用单片机(如STC系列,SST系列,INTEL系列) 熟悉ARM9的硬件结构熟悉Linux操作系统、交叉编译环境，掌握常用脚本编写熟悉BootLoader制作，内核的剪裁，驱动及根文件系统的移植熟悉QT编程 , TCP/IP协议，掌握Linux应用编程了解SQL基础知识熟悉GSM.GPS的使用

【语言水平】 粤语/国语流利；英语已通过CET-4，可阅读专业相关资料

项目简介

 GPS车载终端,GPS个人定位器

软件环境： KEIL 51

硬件环境： BENQ M23,M33 通信模块,51单片机,和GPS模块

项目描述：通过MCU把GPS采集的数据处理后,通过串过发送AT指令使GSM

拨通GPRS网络,再把采集的GPS数据,按照定义好的协议上存到监

控平台

 ARM9 (S3C2440) LED流水灯、LCD文字及图片显示设计

软件环境： ADS1.2

硬件环境：ARM9(2440)开发板

项目描述：将设计的程序移植到ARM9上，并成功驱动LED、LCD，完成LED

流水灯、LCD文字及图片显示项目

 ARM9（S3C2440）嵌入式系统移植

软件环境： Linux2.6.24，U-boot，Qtopia

硬件环境： ARM9(2440)开发板

项目描述：在2440上成功完成了U-boot移植，Linux内核的剪裁与移植，根文

件系统的制作，并完成了LED、LCD等驱动的移植。

 基于ARM9的VOD点播系统

软件环境： Linux2.6.12，U-boot，Qtopia

硬件环境： GEC2440开发板

项目描述：培训实战项目，完成了S3C2440嵌入式系统的整体移植，它基于

QT图形界面，移植了MPlayer播放器，实现了VOD(本地和网络)

多媒体点播,

 ARM9（S3C2440）嵌入式智能家居系统

软件环境： Linux2.6.12，U-boot，Qtopia

硬件环境： ARM9(2440)开发板

项目描述：本系统主要实现温度检测,红外检测,蜂鸣器报警,步进机转动(模拟控

制家电),GSM短信通知等驱动,QT图形界面显示和应用编程.把温

度传感器和红外线采集的数据,传给应用程序,应用程序把数据显示

在QT界面,当应用程序检测到温度过高或有人闯进时,应用程序就调

用蜂鸣器报警驱动,并发短信通知主人,主人也可以下发短信控制步

进机转动

本人做的LINUX驱动简介

 ds18b20温度传感器Linux驱动

该驱动为字符型驱动程序，能从ds18b20芯片读取温度信息.ds18b20芯片采用了独特的1-wire bus技术，只用一根数据线即可实现与cpu芯片的连接(利用了cpu gpio本身的弱上拉电阻)。本驱动程序的重点是实现字符驱动的读函数接口。由于硬件连线简单，对ds18b20的软件操作较为繁琐，每一个操作都要要经过以下三个步骤：(1)芯片初始化 (2)芯片选择(因为一线总线上可挂载多个ds18b20, 所以必须通过一定的机制指明操作的对象) (3)发送功能命令(例如，温度查询命令)和读取数据。在初始化的步骤中，cpu拉低数据线，然后释放数

据线，经过一定时间读取数据线上的值，如为低电平，则表明数据上挂载了ds18b20，否则初始化失败。在芯片选择的步骤中，由于只挂载了一片ds18b20, 所以只需发送skip rom命令即可。在发送功能命令的步骤中，首先发送温度查询命令(convert t), 然后在数据线上读取两个字节的温度数据，温度数据按由低位低字节向高位高字节的顺序发送，余下的为温度无关数据，可忽略。温度数据的0-10位为数值位(最小单位为0.0625), 11-15位为扩展符号位。该驱动使用linux的udelay函数来实现时序操作所要求的延时操作。

 使用内存模拟块设备并挂载ext2文件系统(简单块设备驱动)

本驱动程序使用kmalloc分配出一块内存区域来模拟块设备，并在该块设备上挂载ext2文件系统。本驱动程序同时实现了字符设备和块设备驱动接口。块设备的内容通过字符驱动的写函数由用户空间写入。块设备接口实现的重点是其初始化函数和request函数的实现。在初始化函数中完成以下操作：注册块设备主设备号(register_blkdev)，注册request函数的实现并获取与之关联的request_queue，设置request_queue的一些参数(例如，blk_queue_hardsect_size和blk_queue_max_sectors)，分配(alloc_disk)和设置块设备结构体gendisk，注册gendisk。在request函数的实现中完成以下操作：获取request_queue中的第一个request结构体(elv_next_request), 遍历该request结构体中每一个bio(rq_for_each_bio)中的每一个segment(bio_for_each_segment)，在循环体中将每个segment的数据发送到块设备控制器(或从块设备控制器中读入segment中)。遍历完成后，从request_queue中移除该request结构体(end_that_request_first)，重复以上操作，直到request_queue为空，最后调用end_that_request_last做一些收尾工作。可以看到，块设备的驱动格式较为固定，不像字符驱动那样灵活。文件系统通过以下方法制作：首先建立一个2M大小的“空白”文件(dd)，然后格式化该文件(mkfs.ext2)，最后通过mount命令进行挂载，并创建文件系统内容。制作好的文件系统通过字符驱动的写接口写入驱动内存(cat), 最后挂载块设备。

 蜂鸣器驱动

本驱动程序属于字符型驱动,由于该蜂鸣器物理硬件连接的是定时器的TOUT1管脚,只要实现定时器1的PWM功能即可,实现PWM功能,我们需要设置定时器的频率,也就是蜂鸣器的频率,并设置占空比.蜂鸣器启动的代码在IOCTL系统调用里实现,并把蜂鸣器的响应时间,以参数形式传给IOCTL这自己定义的函数.驱动蜂鸣器。

 红外感应驱动

本驱动程序属于字符型驱动,红外感应的原理,简单的描述就是当有人靠近时,该模块相应的管脚会产生高电平,没人靠近时,该管脚为低电平.此工作原理,相当于一个外部中断,所以只要住一个带有外部中断的字符驱动即可

 GSM驱动(即串口驱动)

本驱动程序属于字符型驱动,首先用ioremap申请串口相关控制寄存器,再编写串口接受和发送的中断程序,当寄存器UTRSTAT的第0位为真,表示接受到收据,当寄存器UTRSTART第2位为1时,表示可以发送寄存器为空,可以发送数据

【求职感言】 我对嵌入式计算机行业抱有热情，有强烈的求知欲和对新技术和新方法的热

忱，希望能得到一个良好的平台和起点，得到锻炼和提升的机会

【业余爱好】

● 看书,篮球,足球,魔兽争霸

【自我评价】●具备吃苦、耐劳的能力，敢于面对错误和承担责任。

推荐第9篇：嵌入式研发工程师岗位职责

1.领导本部门实施产品开发、研制工作，制订开发计划。2.执行方案，并进行产品鉴定，生产转化，技术规范制定工作。3.积极关注行业发展动态，积累研发素材。4.总结产品研发经验，持续改进产品性能。5.主持产品技术转化和制造技术交底工作。6.为产品的投标提供技术支持。7.为代理商与合作伙伴的产品提供技术支持。8.根据用户或公司其他部门的要求进行设计修改和设计改进。

推荐第10篇：嵌入式开发—C语言面试题

嵌入式开发—C语言面试题

1.用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想看到几件事情：

1).#define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）

2).懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。

3).意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。

4).如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

2.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B) ((A)

这个测试是为下面的目的而设的：

1).标识#define在宏中应用的基本知识。这是很重要的，因为直到嵌入(inline)操作符变为标准C的一部分，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。

2).三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。

3).懂得在宏中小心地把参数用括号括起来

4).我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？

least = MIN(*p++, b);

3.预处理器标识#error的目的是什么？

如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种

问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。

死循环（Infinite loops）

4.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？

这个问题用几个解决方案。我首选的方案是：

while(1) { } 一些程序员更喜欢如下方案：

for(;;) { }

这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的

基本原理。如果他们的基本答案是：“我被教着这样做，但从没有想到过为什么。”这会给我留下一个坏印象。

第三个方案是用 goto Loop: ...

goto Loop;

应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。

数据声明（Data declarations）

5.用变量a给出下面的定义

a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）

d) 一个有10个整型数的数组（An array of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道

所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？

Static

6.关键字static的作用是什么？

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1).在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2).在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3).在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

Const

7．关键字const是什么含意？

我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.

如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思？

const int a; int const a; const int *a; int * const a;

int const * a const;

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：

1).关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）

2).通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。

3).合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

Volatile

8.关键字volatile有什么含意并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1).并行设备的硬件寄存器（如：状态寄存器）

2).一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) 3).多线程应用中被几个任务共享的变量

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。

假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。

1).一个参数既可以是const还可以是volatile吗？解释为什么。

2).一个指针可以是volatile 吗？解释为什么。

3).下面的函数有什么错误：

int square(volatile int *ptr) { return *ptr * *ptr; } 下面是答案：

1).是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2).是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

3).这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr) { int a,b; a = *ptr; b = *ptr; return a * b;

} 由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr) { int a; a = *ptr; return a * a; }

位操作（Bit manipulation）

9.嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。

对这个问题有三种基本的反应

1).不知道如何下手。该被面者从没做过任何嵌入式系统的工作。

2).用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。

3).用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：

#define BIT3 (0x1

void set_bit3(void) { a |= BIT3;

} void clear_bit3(void) { a &= ~BIT3;

} 一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。我希望看到几个要点：说明常数、|=和&=~操作。

10.嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：

int *ptr;

ptr = (int *)0x67a9; *ptr = 0xaa55;

一个较晦涩的方法是：

*(int * const)(0x67a9) = 0xaa55;

即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。

中断（Interrupts）

11.中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。

__interrupt double compute_area (double radius) { double area = PI * radius * radius; printf(\" Area = %f\", area); return area; }

这个函数有太多的错误了，以至让人不知从何说起了：

1).ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。

2).ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。

3).在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。

4).与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。

代码例子（Code examples）

12 .下面的代码输出是什么，为什么？

void foo(void)

{ unsigned int a = 6; int b = -20;

(a+b >6) puts(\">6\") : puts(\"

这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是“>6”。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

13.评价下面的代码片断：

unsigned int zero = 0;

unsigned int compzero = 0xFFFF; /*1\'s complement of zero */

对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：

unsigned int compzero = ~0;

这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。

到了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如何，你就当是这个娱乐吧„

动态内存分配（Dynamic memory allocation）

14.尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？

这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J.Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：下面的代码片段的输出是什么，为什么？

char *ptr;

if ((ptr = (char *)malloc(0)) == NULL) puts(\"Got a null pointer\"); else

puts(\"Got a valid pointer\");

这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输出是“Got a valid pointer”。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。

Typedef

15.Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子： #define dPS struct s * typedef struct s * tPS;

以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？

这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：

dPS p1,p2; tPS p3,p4;

第一个扩展为

struct s * p1, p2;

上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。

晦涩的语法

16.C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？

int a = 5, b = 7, c; c = a+++b;

这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：

c = a++ + b;

因此, 这段代码持行后a = 6, b = 7, c = 12。

如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是:这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题

What will print out?

main()

{ char *p1=“name”; char *p2;

p2=(char*)malloc(20); memset (p2, 0, 20); while(*p2++ = *p1++); printf(“%sn”,p2);

}

Answer:empty string.

What will be printed as the result of the operation below:

main()

{ int x=20,y=35; x=y++ + x++; y= ++y + ++x;

printf(“%d%dn”,x,y); }

Answer : 5794

What will be printed as the result of the operation below:

main() { int x=5;

printf(“%d,%d,%dn”,x,x>2); }

Answer: 5,20,1

What will be printed as the result of the operation below:

#define swap(a,b) a=a+b;b=a-b;a=a-b; void main() { int x=5, y=10; swap (x,y);

printf(“%d %dn”,x,y); swap2(x,y);

printf(“%d %dn”,x,y); }

int swap2(int a, int b) { int temp; temp=a; b=a; a=temp; return 0;

}

Answer: 10, 5 10, 5

What will be printed as the result of the operation below:

main()

{ char *ptr = ” Cisco Systems”; *ptr++; printf(“%sn”,ptr); ptr++;

printf(“%sn”,ptr); }

Answer:Cisco Systems isco systems

What will be printed as the result of the operation below:

main()

{ char s1[]=“Cisco”; char s2[]= “systems”; printf(“%s”,s1); } Answer: Cisco

What will be printed as the result of the operation below:

main() { char *p1; char *p2;

p1=(char *)malloc(25); p2=(char *)malloc(25);

strcpy(p1,”Cisco”); strcpy(p2,“systems”); strcat(p1,p2);

printf(“%s”,p1);

}

Answer: Ciscosystems

The following variable is available in file1.c, who can acce it?:

static int average; Answer: all the functions in the file1.c can acce the variable.

WHat will be the result of the following code?

#define TRUE 0 // some code while(TRUE) {

// some code

}

Answer: This will not go into the loop as TRUE is defined as 0.

What will be printed as the result of the operation below:

int x;

int modifyvalue() { return(x+=10);

} int changevalue(int x) { return(x+=1); }

void main() { int x=10; x++;

changevalue(x); x++;

modifyvalue();

printf(\"First output:%dn\",x);

x++;

changevalue(x);

printf(\"Second output:%dn\",x); modifyvalue();

printf(\"Third output:%dn\",x);

}

Answer: 12 , 13 , 13

What will be printed as the result of the operation below:

main() { int x=10, y=15; x = x++; y = ++y;

printf(“%d %dn”,x,y); }

Answer: 11, 16

What will be printed as the result of the operation below:

main() { int a=0; if(a==0)

printf(“Cisco Systemsn”); printf(“Cisco Systemsn”); }

Answer: Two lines with “Cisco Systems” will be printed.

再次更新C++相关题集

1.以下三条输出语句分别输出什么？[C易] char str1[] = \"abc\"; char str2[] = \"abc\";

const char str3[] = \"abc\"; const char str4[] = \"abc\"; const char* str5 = \"abc\"; const char* str6 = \"abc\";

cout

13.非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A？[C++中等] 答：

a.cla B : public A { „„} // B公有继承自A，可以是间接继承的

b.cla B { operator A( ); } // B实现了隐式转化为A的转化

c.cla A { A( const B& ); } // A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数

d.A& operator= ( const A& ); // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

12.以下代码中的两个sizeof用法有问题吗？[C易]

void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母

{ for( size_t i=0; i

} char str[] = \"aBcDe\";

cout

7.以下代码有什么问题？[C难]

void char2Hex( char c ) // 将字符以16进制表示

{ char ch = c/0x10 + \'0\'; if( ch >\'9\' ) ch += (\'A\'-\'9\'-1); char cl = c%0x10 + \'0\'; if( cl >\'9\' ) cl += (\'A\'-\'9\'-1); cout

} char str[] = \"I love 中国\";

for( size_t i=0; i

4.以下代码有什么问题？[C++易] struct Test { Test( int ) {} Test() {} void fun() {} };

void main( void ) { Test a(1); a.fun(); Test b(); b.fun(); }

5.以下代码有什么问题？[C++易] cout

8.以下代码能够编译通过吗，为什么？[C++易] unsigned int const size1 = 2; char str1[ size1 ];

unsigned int temp = 0; cin >>temp;

unsigned int const size2 = temp; char str2[ size2 ];

9.以下代码中的输出语句输出0吗，为什么？[C++易] struct CLS { int m_i; CLS( int i ) : m_i(i) {} CLS() { CLS(0); } };

CLS obj;

cout

10.C++中的空类，默认产生哪些类成员函数？[C++易] 答：

cla Empty { public:

Empty(); // 缺省构造函数

Empty( const Empty& ); // 拷贝构造函数

~Empty(); // 析构函数

Empty& operator=( const Empty& ); // 赋值运算符

Empty* operator&(); // 取址运算符

const Empty* operator&() const; // 取址运算符 const };

3.以下两条输出语句分别输出什么？[C++难] float a = 1.0f;

cout

float b = 0.0f;

cout

2.以下反向遍历array数组的方法有什么错误？[STL易] vector array;

array.push_back( 1 ); array.push_back( 2 ); array.push_back( 3 );

for( vector::size_type i=array.size()-1; i>=0; --i ) // 反向遍历array数组

{ cout

6.以下代码有什么问题？[STL易] typedef vector IntArray; IntArray array;

array.push_back( 1 ); array.push_back( 2 ); array.push_back( 2 ); array.push_back( 3 );

// 删除array数组中所有的2

for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor ) { if( 2 == *itor ) array.erase( itor ); }

11.写一个函数，完成内存之间的拷贝。[考虑问题是否全面] 答：

void* mymemcpy( void *dest, const void *src, size_t count )

{

char* pdest = static_cast( dest );

const char* psrc = static_cast( src );

if( pdest>psrc && pdest

{

for( size_t i=count-1; i!=-1; --i )

pdest[i] = psrc[i];

}

else

{

for( size_t i=0; i

pdest[i] = psrc[i];

}

return dest;

}

int main( void )

{

char str[] = \"0123456789\";

mymemcpy( str+1, str+0, 9 );

cout

system( \"Pause\" );

return 0;

}

C语言面试题总汇

static有什么用途？（请至少说明两种） 1.限制变量的作用域 2.设置变量的存储域

引用与指针有什么区别？ 1) 引用必须被初始化，指针不必。

2) 引用初始化以后不能被改变，指针可以改变所指的对象。

2) 不存在指向空值的引用，但是存在指向空值的指针。

描述实时系统的基本特性

在特定时间内完成特定的任务，实时性与可靠性

全局变量和局部变量在内存中是否有区别？如果有，是什么区别？全局变量储存在静态数据库，局部变量在堆栈 10.

什么是平衡二叉树？

左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1 11.

堆栈溢出一般是由什么原因导致的？没有回收垃圾资源 12.

什么函数不能声明为虚函数？ constructor 13.

冒泡排序算法的时间复杂度是什么？ O(n^2) 14.

写出float x 与“零值”比较的if语句。 if(x>0.000001&&x

Internet采用哪种网络协议？该协议的主要层次结构？ tcp/ip 应用层/传输层/网络层/数据链路层/物理层

17.

Internet物理地址和IP地址转换采用什么协议？ ARP (Addre Resolution Protocol)（地址解析协议） 18.IP地址的编码分为哪俩部分？

IP地址由两部分组成，网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。

2.用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。循环链表，用取余操作做

3.不能做switch()的参数类型是： switch的参数不能为实型。

华为

1、局部变量能否和全局变量重名？

答：能，局部会屏蔽全局。要用全局变量，需要使用\"::\" 局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内

2、如何引用一个已经定义过的全局变量？答：extern 可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错

3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错

4、语句for( ；1 ；)有什么问题？它是什么意思？答：和while(1)相同。

5、do„„while和while„„do有什么区别？

答：前一个循环一遍再判断，后一个判断以后再循环

6、请写出下列代码的输出内容＃i nclude main() { int a,b,c,d; a=10; b=a++; c=++a; d=10*a++; printf(\"b，c，d：%d，%d，%d\"，b，c，d）; return 0; }

答：10，12，120

1、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用; static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；

static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

2、程序的局部变量存在于（堆栈）中，全局变量存在于（静态区）中，动态申请数据存在于（堆）中。

3、设有以下说明和定义：

typedef union {long i; int k[5]; char c;} DATE; struct data { int cat; DATE cow; double dog;} too; DATE max; 则语句 printf(\"%d\",sizeof(struct date)+sizeof(max));的执行结果是：___52____ 答：DATE是一个union, 变量公用空间.里面最大的变量类型是int[5], 占用20个字节.所以它的大小是20 data是一个struct, 每个变量分开占用空间.依次为int4 + DATE20 + double8 = 32.所以结果是 20 + 32 = 52.当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20

4、队列和栈有什么区别？队列先进先出，栈后进先出

5、写出下列代码的输出内容＃i nclude int inc(int a) { return(++a); } int multi(int*a,int*b,int*c) { return(*c=*a**b); } typedef int(FUNC1)(int in); typedef int(FUNC2) (int*,int*,int*); void show(FUNC2 fun,int arg1, int*arg2) { INCp=&inc; int temp =p(arg1); fun(&temp,&arg1, arg2); printf(\"%d\\n\",*arg2); } main() { int a; show(multi,10,&a); return 0; } 答：110

7、请找出下面代码中的所以错误

说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”

1、＃i nclude\"string.h\"

2、main()

3、{

4、char*src=\"hello,world\";

5、char* dest=NULL;

6、int len=strlen(src);

7、dest=(char*)malloc(len);

8、char* d=dest;

9、char* s=src[len];

10、while(len--!=0)

11、d++=s--;

12、printf(\"%s\",dest);

13、return 0;

14、} 答：方法1： int main(){ char* src = \"hello,world\"; int len = strlen(src); char* dest = (char*)malloc(len+1);//要为\\0分配一个空间 char* d = dest; char* s = &src[len-1];//指向最后一个字符 while( len-- != 0 ) *d++=*s--; *d = 0;//尾部要加\\0 printf(\"%s\\n\",dest); free(dest);// 使用完，应当释放空间，以免造成内存汇泄露 return 0; } 方法2：

＃i nclude ＃i nclude main() { char str[]=\"hello,world\"; int len=strlen(str); char t; for(int i=0; i

str[i]=str[len-i-1]; str[len-i-1]=t; } printf(\"%s\",str); return 0; } 1.-1,2,7,28,,126请问28和126中间那个数是什么？为什么？第一题的答案应该是4^3-1=63 规律是n^3-1(当n为偶数0，2，4)

n^3+1(当n为奇数1，3，5) 答案：63 2.用两个栈实现一个队列的功能？要求给出算法和思路！设2个栈为A,B, 一开始均为空. 入队: 将新元素push入栈A; 出队: (1)判断栈B是否为空；

(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B； (3)将栈B的栈顶元素pop出；

这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。3.在c语言库函数中将一个字符转换成整型的函数是atool()吗，这个函数的原型是什么？函数名: atol

功能: 把字符串转换成长整型数

用法: long atol(const char *nptr); 程序例:

＃i nclude ＃i nclude int main(void) {

long l;

char *str = \"98765432\"; l = atol(lstr);

printf(\"string = %s integer = %ld\\n\", str, l); return(0); } 2.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现? c用宏定义，c++用inline

3.直接链接两个信令点的一组链路称作什么? PPP点到点连接

4.接入网用的是什么接口?

5.voip都用了那些协议?

6.软件测试都有那些种类? 黑盒：针对系统功能的测试

白合：测试函数功能，各函数接口

7.确定模块的功能和模块的接口是在软件设计的那个队段完成的? 概要设计阶段

8.enum string

{

x1,

x2,

x3=10,

x4,

x5,

}x;

问x= 0x801005，0x8010f4 ;

9.unsigned char *p1;

unsigned long *p2;

p1=(unsigned char *)0x801000;

p2=(unsigned long *)0x810000;

请问p1+5= ;

p2+5= ; 三.选择题:

1.Ethternet链接到Internet用到以下那个协议?

A.HDLC;B.ARP;C.UDP;D.TCP;E.ID

2.属于网络层协议的是:

A.TCP;B.IP;C.ICMP;D.X.25

3.Windows消息调度机制是:

A.指令队列;B.指令堆栈;C.消息队列;D.消息堆栈;

4.unsigned short hash(unsigned short key)

{

return (key>>)%256

}

请问hash(16),hash(256)的值分别是:

A.1.16;B.8.32;C.4.16;D.1.32 四.找错题:

1.请问下面程序有什么错误?

int a[60][250][1000],i,j,k;

for(k=0;k

for(j=0;j

for(i=0;i

a[i][j][k]=0; 把循环语句内外换一下

2.#define Max_CB 500

void LmiQueryCSmd(Struct MSgCB * pmsg)

{

unsigned char ucCmdNum;

......

for(ucCmdNum=0;ucCmdNum

{

......;

} 死循环

3.以下是求一个数的平方的程序,请找出错误:

#define SQUARE(a)((a)*(a))

int a=5;

int b;

b=SQUARE(a++);

4.typedef unsigned char BYTE

int examply_fun(BYTE gt_len; BYTE *gt_code)

{

BYTE *gt_buf;

gt_buf=(BYTE *)MALLOC(Max_GT_Length);

......

if(gt_len>Max_GT_Length)

{

return GT_Length_ERROR;

}

.......

} 五.问答题:

1.IP Phone的原理是什么? IPV6

2.TCP/IP通信建立的过程怎样，端口有什么作用？三次握手，确定是哪个应用程序使用该协议

3.1号信令和7号信令有什么区别，我国某前广泛使用的是那一种？

4.列举5种以上的电话新业务？

微软亚洲技术中心的面试题！！！ 1．进程和线程的差别。

线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别: (1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

(2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行

(3)拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.

(4)系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。 2.测试方法

人工测试：个人复查、抽查和会审机器测试：黑盒测试和白盒测试

2．Heap与stack的差别。 Heap是堆，stack是栈。

Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。 Stack空间有限，Heap是很大的自由存储区

C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。

程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行

3．Windows下的内存是如何管理的？ 4．介绍.Net和.Net的安全性。

5．客户端如何访问.Net组件实现Web Service？ 6．C/C++编译器中虚表是如何完成的？

7．谈谈COM的线程模型。然后讨论进程内/外组件的差别。 8．谈谈IA32下的分页机制

小页(4K)两级分页模式，大页(4M)一级

9．给两个变量，如何找出一个带环单链表中是什么地方出现环的？一个递增一，一个递增二，他们指向同一个接点时就是环出现的地方 10．在IA32中一共有多少种办法从用户态跳到内核态？

通过调用门，从ring3到ring0，中断从ring3到ring0，进入vm86等等 11．如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现？

用内存映射或全局原子（互斥变量）、查找窗口句柄..

FindWindow，互斥，写标志到文件或注册表,共享内存。.12．如何截取键盘的响应，让所有的‘a’变成‘b’？键盘钩子SetWindowsHookEx 13．Apartment在COM中有什么用？为什么要引入？

14．存储过程是什么？有什么用？有什么优点？

我的理解就是一堆sql的集合，可以建立非常复杂的查询，编译运行，所以运行一次后，以后再运行速度比单独执行SQL快很多

15．Template有什么特点？什么时候用？ 16．谈谈Windows DNA结构的特点和优点。

网络编程中设计并发服务器，使用多进程与多线程，请问有什么区别？ 1，进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。

2，线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。两者都可以提高程序的并发度，提高程序运行效率和响应时间。

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。

思科

1.用宏定义写出swap（x，y） #define swap(x, y)\\ x = x + y;\\ y = xy; 2.数组a[N]，存放了1至N-1个数，其中某个数重复一次。写一个函数，找出被重复的数字.时间复杂度必须为o（N）函数原型： int do_dup(int a[],int N) 3 一语句实现x是否为2的若干次幂的判断 int i = 512; cout

int a,b,c 请写函数实现C=a+b ,不可以改变数据类型,如将c改为long int,关键是如何处理溢出问题

bool add (int a, int b,int *c) { *c=a+b; return (a>0 && b>0 &&(*ca || *c>b))); }

分析： struct bit {

int a:3;

int b:2;

int c:3; };

int main() {

bit s;

char *c=(char*)&s;

cout

*c=0x99;

cout

int a=-1;

printf(\"%x\",a);

return 0; }

输出为什么是 4 1 -1 -4 ffffffff 因为0x99在内存中表示为 100 11 001 , a = 001, b = 11, c = 100 当c为有符合数时, c = 100, 最高1为表示c为负数，负数在计算机用补码表示，所以c = -4;同理

b = -1; 当c为有符合数时, c = 100,即 c = 4,同理 b = 3

位域：

有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态，用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。

一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：

struct 位域结构名

{ 位域列表 };

其中位域列表的形式为：类型说明符位域名：位域长度

例如：

struct bs

{

int a:8;

int b:2;

int c:6;

};

位域变量的说明与结构变量说明的方式相同。可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：

struct bs

{

int a:8;

int b:2;

int c:6;

}data;

说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

1.一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs

{

unsigned a:4

unsigned :0 /*空域*/

unsigned b:4 /*从下一单元开始存放*/

unsigned c:4

}

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

2.由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。

3.位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

struct k

{

int a:1

int :2 /*该2位不能使用*/

int b:3

int c:2

};

从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为：位域变量名•位域名位域允许用各种格式输出。

main(){

struct bs

{

unsigned a:1;

unsigned b:3;

unsigned c:4;

} bit,*pbit;

bit.a=1;

bit.b=7;

bit.c=15;

pri 改错：

＃i nclude int main(void) {

int **p;

int arr[100];

p = &arr;

return 0; } 解答：

搞错了,是指针类型不同, int **p; //二级指针

&arr; //得到的是指向第一维为100的数组的指针＃i nclude int main(void) { int **p, *q; int arr[100]; q = arr; p = &q; return 0; }

下面这个程序执行后会有什么错误或者效果: #define MAX 255 int main() {

unsigned char A[MAX],i;//i被定义为unsigned char

for (i=0;i

A[i]=i; } 解答：死循环加数组越界访问（C/C++不进行数组越界检查） MAX=255

数组A的下标范围为:0..MAX-1,这是其一..其二.当i循环到255时,循环内执行:

A[255]=255; 这句本身没有问题..但是返回for (i=0;i

char str;

short x;

int

num; }

struct name2{

char str;

int num;

short x; }

sizeof(struct name1)=8,sizeof(struct name2)=12 在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间；同时为保证整个结构的自然对齐（这里是4字节对齐），在x后还要补齐2个字节，这样就是12字节。

intel：

A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里（栈还是堆或者其他的）? static的全局变量，表明这个变量仅在本模块中有意义，不会影响其他模块。他们都放在数据区，但是编译器对他们的命名是不同的。

如果要使变量在其他模块也有意义的话，需要使用extern关键字。

struct s1 {

int i: 8;

int j: 4;

int a: 3;

double b; };

struct s2 {

int i: 8;

int j: 4;

double b;

int a:3; };

printf(\"sizeof(s1)= %d\\n\", sizeof(s1)); printf(\"sizeof(s2)= %d\\n\", sizeof(s2)); result: 16, 24 第一个struct s1 {

int i: 8;

int j: 4;

int a: 3;

double b; }; 理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。

第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数上面是基本问题，接下来是编程问题：

本人很弱，这几个题也搞不定，特来求救： 1）读文件file1.txt的内容（例如）： 12 34 56 输出到file2.txt： 56 34 12 （逆序）

2）输出和为一个给定整数的所有组合例如n=5 5=1+4；5=2+3（相加的数不能重复）则输出

1，4；2，3。望高手赐教！！

第一题,注意可增长数组的应用.＃i nclude ＃i nclude int main(void) {

int MAX = 10; int *a = (int *)malloc(MAX * sizeof(int)); int *b;

FILE *fp1; FILE *fp2;

fp1 = fopen(\"a.txt\",\"r\"); if(fp1 == NULL) {printf(\"error1\");

exit(-1); }

fp2 = fopen(\"b.txt\",\"w\"); if(fp2 == NULL) {printf(\"error2\");

exit(-1); }

int i = 0;

int j = 0;

while(fscanf(fp1,\"%d\",&a[i]) != EOF) { i++; j++; if(i >= MAX) { MAX = 2 * MAX; b = (int*)realloc(a,MAX * sizeof(int)); if(b == NULL) { printf(\"error3\"); exit(-1); } a = b; } }

for(;--j >= 0;)

fprintf(fp2,\"%d\\n\",a[j]); fclose(fp1); fclose(fp2); return 0;

}

第二题.＃i nclude int main(void) { unsigned long int i,j,k;

printf(\"please input the number\\n\"); scanf(\"%d\",&i);

if( i % 2 == 0)

j = i / 2; else j = i / 2 + 1;

printf(\"The result is \\n\");

for(k = 0; k

printf(\"%d = %d + %d\\n\",i,k,i1); QSort (L,pl + 1,high); } }

intmain () { intnarry[100],addr[100]; intsum = 1,t;

cout >t; while (t != -1) { narry[sum] = t; addr[sumkk]

return0; }

1、找错 Void test1() { char string[10]; char* str1=\"0123456789\"; strcpy(string, str1);// 溢出，应该包括一个存放\'\\0\'的字符string[11] }

Void test2() { char string[10], str1[10]; for(I=0; I

Void test3(char* str1) { char string[10]; if(strlen(str1)

void g(int**p) { (**p)++; (*p)++;// 无效 } 输出： 1 2 3 4 5 6 7 8 9 10 3.写出程序运行结果

int sum(int a) { auto int c=0; static int b=3; c+=1; b+=2; return(a+b+c); }

void main() { int I; int a=2; for(I=0;I

int func(int a) { int b; switch(a) { case 1: 30; case 2: 20; case 3: 16; default: 0 } return b; } 则func(1)=? // b定义后就没有赋值。

5: int a[3]; a[0]=0; a[1]=1; a[2]=2; int *p, *q; p=a; q=&a[2]; 则a[q-p]=a[2] 解释：指针一次移动一个int但计数为1

第11篇：嵌入式开发的技能专长描述

嵌入式开发的技能专长描述范文：

1 熟悉arm9（s3c2440）体系结构的编程；

1 精通c语言，熟悉嵌入式c语言高级编程，精通汇编语言，熟悉c++；

2 熟悉嵌入式网络编程，熟悉tcp/ip，udp协议的编程；

3 熟悉嵌入式驱动程序编程（以字符设备为主）的开发；

4 熟悉嵌入式多任务通信和同步编程；

5 熟悉嵌入式图形界面的移植（qt），对minigui有一定的了解；

6 熟悉嵌入式串口，ide，flash等外围模块驱动程序的移植；

7 熟悉u-boot的移植，linux内核移植；

8 对51单片机有着深入的了解，能熟练用kielc51进行编程；

9 能熟练用protel9绘图，制pcb板；

10 能熟练用ads，vi,gdb等嵌入式开发工具；

11 能熟练用vhdl语言编程，对fpga/cpld有一定的了解，能熟练运用quartus等fpga开发工具；

12 熟悉摸电，数电，信号与系统，自动控制等知识；

第12篇：嵌入式开发实训室设备维修制度

嵌入式开发实训室设备维修制度

为做好分院实验室仪器设备的维修管理工作，确保实验室仪器设备的完好，特制定本制度。

一、仪器设备的使用管理人员应熟悉仪器设备，会正确操作使用，平时要做到精心维护，认真保养，加强检查，及时排除隐患。

二、仪器设备维护保养要根据其性能进行，认真做好防锈、防火、防潮、防震工作，同时还应做好清洁润滑、紧固、通电、更换易损零部件等工作。

三、仪器设备出现故障隐患苗头时，应停止使用，及时检查，并做好安全检查记录。

四、仪器设备的维修必须在认真做好故障诊断记录的基础上，由管理人员向分院提出维修申请报告，经批准后，方可进行修理。仪器设备的修理采取鼓励校内修理，控制校外修理，尽可能减少异地修理。

五、仪器设备修理后，必须组织有关专业技术人员进行测试鉴定，并写出鉴定结论，经确定为合格后方可投入正常使用。

六、仪器设备的维修记录，应妥善保管，不得丢失。

七、实验室各类技术人员都要认真学习修理技术，增强修理能力，做到仪器设备的一般故障，本室即可排除。

电子与信息工程分院2012年8月29日

第13篇：嵌入式Linux开发环境搭建（优秀）

第一章

Ubuntu 8.10的安装和网络配置

1.安装虚拟机软件Vmware 6.0.2 虚拟机安装版本Vmware 6.0.2的版本

在 winxp操作系统下用鼠标双击VMware-workstation-6.0.2-59824图标，开始安装虚拟机Vmware,如下图所示：

双击VMware-workstation-6.0.2-59824图标，出现vmware的安装界面，所有的选项都采用默认值，用鼠标点【下一步】，然后出现安装进度条，系统开始安装vmware,等待安装完成后，出现如下安装完成界面：

用鼠标点【Finish】，虚拟机安装完成。系统提示重新启动计算机，选择【是】重新启动计算机，电脑重新启动后，虚拟机安装完成。

2.新建虚拟机

打开Vmware虚拟机软件，选【File】->【New】->【Virtual Machine】,弹出新建虚拟机向导对话框，注意以下几个重要的选项，其他都采用默认选项即可。选择操作系统和版本，如下图所示：

选择虚拟机名称和存放的路径，如下图所示：

设置虚拟机硬盘大小为20G ,如下图所示：

点击【完成】按钮，这样我们就新建了一个虚拟机，下面我们设置一下虚拟机的内存，步骤如下：

点击虚拟机Vmware的【VM】->【settings】时菜单，弹出虚拟机设置对话框，设置虚拟机使用的内存为512M或1024M，如下图所示：

点击【OK】按钮，这样我们就新建了一个虚拟机，该虚拟机的硬盘为20G, 内存为512M .接着我们就可以在该虚拟机上安装ubuntu操作系统了。

注: 键盘和鼠标控制权在虚拟机和Windows系统之间的切换是通过组合键【Ctrl】+【Alt】来实现的。

3 安装Linux操作系统ubuntu Ubuntu安装版本 ubuntu 8.10 点击vmware软件工具栏上的【绿色箭头】启动虚拟机，如下图所示：

点击【VM】->【Removable Devices】->【CD_ROM】->【Edit】菜单，弹出CD_ROM设备对话框，如下图所示：

在Connection中选中【Use ISO image】,设置ubuntu软件安装包的路径，如上图所示。然后重新启动虚拟机，开始在虚拟机上安装ubuntu操作系统。重新启动虚拟机后，出现如下ubuntu安装界面：

选择语言版本为【English】，然后按【回车】键，出现如下安装界面：

选择Install Ubuntu,然后【回车】，开始安装Ubuntu,出现ubuntu安装进度界面如下：

在出现的安装向导主要设置一下城市和用户名密码，如下图所示，其余的安装对话框都采用默认值，选择【Forward】即可。设置安装所在城市

当出现安装所在城市对话框时，选择【ShangHai】，通过选择地图上的点选择,如下图所示：

设置系统的用户名和密码

系统安装过程中出现设置用户名和密码对话框时，设置登陆到ubuntu的用户名和密码，如下图所示：

然后点击【Forward】按钮，在出现的最后安装向导对话框中点击【Install】按钮，开始安装ubuntu，ubuntu安装完成后，最后出现安装完成对话框，如下图所示：

点击【Restart now】开始重新启动ubuntu系统。在系统重启过程中出现如下界面：

提示移走光驱中的磁盘后按回车键，这时我们点击【VM】->【Removable Devices】->【CD_ROM】->【Edit】菜单，弹出CD_ROM设备对话框，如下图所示：

在Connection中选中【Use physical drive】,点【OK】按钮，然后按【回车】即可，系统正常启动，在出现输入用户名和密码提示框时，输入刚才在安装过程中设置的用户名和密码即可。这样就进入了我们刚安装好的ubuntu操作系统。

3.安装Vmware tools工具软件

Vmware tools工具软件用于在window系统和虚拟机的ubuntu系统之间进行数据传递，安装好Vmware tools之后，鼠标可以在window系统和虚拟机之间平滑切换，在window系统和虚拟机之间可以直接通过【复制】和【粘贴】的方式进行数据交换。Vmware tools的安装步骤如下： 1）设置Vmware tool软件的路径为 C:\\Program Files\\VMware\\VMware Workstation\\linux.iso .点击【VM】->【Removable Devices】->【CD_ROM】->【Edit】菜单，弹出CD_ROM设备对话框，如下图所示：

点击【OK】确定，这时在ubuntu的桌面上出现一个光驱图标，如下图所示：

双击Vmware Tools图标，打开光盘文件夹，可以看到在该光盘目录下看到VmwareTools-6.0.2-59824.tar.gz文件，如下图所示：

返回系统桌面，在点击系统菜单【Places】->【Home Folder】，进入用户目录cao,在用户目录下建立Soft目录，把VmwareTools-6.0.2-59824.tar.gz复制到Soft目录下。

在安装VmwareTools-之前我们要先解锁root用户，点击桌面系统菜单【System】->【Administration】->【Users and Groups】,弹出用户设置对话框如下：

选中root用户，然后点击下面的【Unlock】，在点【Close】按钮关闭对话框。接着开始设置root用户密码，点击桌面系统菜单【Applications】->【Acceories】->【Terminal】,进入用户字符终端操作界面如下图所示：

按照上图所示输入命令sudo pawd root设置root用户密码；提示paword for cao时，输入 cao 用户密码；

提示 Enter new UNIX paword时，输入root用户密码；

提示 Retype new UNIX paword时，再次输入root用户密码；最后显示paword更新成功。

最后输入命令 su切换到root用户，在提示Paword时，输入我们刚才设置的root用户密码即可，然后我们可以看到我们成功切换到root用户了，命令提示符由以cao开头改为以root开头了，表示我们已经成功切换到了root用户。

安装Vmware Tools工具打开ubuntu 字符操作终端，进入到Soft目录，解压VmwareTools-6.0.2-59824.tar.gz软件包，解压完成后，我们看到在Soft目录下生成了一个新的文件夹vmware-tools-distrib，如下图所示：

执行su命令切换到root用户，执行cd vmware-tools-distrib命令进入到vmware-tools-distrib目录，执行ls命令查看该文件夹下的文件，我们可以看到vmware-tools-distrib文件夹下有一个vmware-install.pl安装脚本文件，在操作终端下通过输入命令./ vmware-install.pl执行该脚本文件安装vmware-tools 即可。如下图所示：

然后开始安装vmware Tools工具，安装过程中出现一些选项全部采用默认值，一直按【回车】即可，最后操作终端输出如下提示安装成功信息，如下图所示：

Vmware Tools安装成功后，我们就可以在Windows和虚拟机的ubuntu之间直接通过【复制】和【粘贴】命令进行数据交换了。

网络配置

Ubuntu的虚拟机安装模式下的网络配置

虚拟机下安装好ubuntu之后，在【system】下点【Network Configuration】，弹出Network Connections对话框：

选取Wired选项卡，选中eth0, 点 Edit 按钮，弹出如下网络接口eth0编辑对话框：

注：如果此处没有显示eth0网络，则在windows 下手工配置网络接口的IP地址，然后再重新启动虚拟机，再进入上述网络配置对话框，一般都会出现eth0网络。

在网络接口eth0编辑对话框配置eth0的IP addre 为 192.168.0.220 ,Netmask为255.255.255.0 ， Gateway 为 192.168.0.1, DNS为 218.2.135.1，配置完成后，点OK即可。 IP地址，网络掩码，网关的具体配置值需要根据实际网络环境配置。

注：如果这样配置不能上网，可以尝试通过DHCP方式获取IP地址，DNS还是手动设置。

配置完成后，重新Enable Networking即可，如下图所示：

这样就完成了Ubuntu的网络配置，配置完成后，就可以在ubuntu里面打开浏览器上网了。

设置软件源服务器

在全球很多国家都设置有为ubuntu系统服务的服务器，上面有很多为ubuntu提供的应用软件，我们通过设置软件源服务器，来实现在线通过网络完成软件的安装，即通过一条命令实现软件的搜索，下载和安装，同时会安装该软件需要的依赖文件，同过在网络来安装ubuntu上的应用软件非常方便。Ubuntu软件源服务器的设置步骤如下：

1）在桌面系统菜单上点击【System】->【Administration】->【Software Source】,弹出软件源设置对话框如下：

在Download from 里选择软件源服务器，我们一般选择 Taiwan的倒数第1或第2个服务器，如上图所示，选择好软件源服务器后，点【Close】按钮，弹出如下对话框提示可获得的软件包信息已经过时，需要重新更新。

点击【Reload】按钮更新可获得的软件包信息。更新完成后，我们就完成了ubuntu软件源服务器的设置。

安装libncurses5-dev软件包在ubuntu环境下，我们用命令make menuconfig来对内核进行裁剪和配置时，需要用终端模式下的字符菜单支持软件包libncurses5-dev,下面我们就通过网络的方式来安装libncurses5-dev软件包，安装的前提是已经设置了软件源和ubuntu系统的网络工作正常。安装libncurses5-dev非常简单，在终端模式下输入：apt-get install libncurses5-dev即可。如下图所示：

这样，libncurses5-dev就安装好了，我们可以在终端模式下通过make menuconfig命令来配置和裁剪linux内核了。

安装交叉编译器arm-linux-gcc 嵌入式开发的应用程序编译好后不是在PC机上运行，而是在我们的ARM开发板上运行，这时需要用arm-linux-gcc 交叉编译器编译。安装交叉编译器非常简单，步骤如下：

1）拷贝arm-linux-gcc交叉编译器软件包arm-linux-gcc-4.3.2.tgz到/home/cao/Soft目录。 2）进入到Soft目录，在该目录下执行tar zxvf arm-linux-gcc-4.3.2.tgz –C / 命令解压arm-linux-gcc-4.3.2.tgz 。如下图所示：

注: C是大写，C后面有个空格

该命令执行后，将把arm-linux-gcc 安装到 /usr/local/arm/4.3.2 目录。 arm-linux-gcc编译器安装好后，我们还要把交叉编译器arm-linux-gcc的路径加入到系统的PATH环境变量，这样在操作终端的其他任意目录下都可以使用arm-linux-gcc。设置环境变量的步骤如下： 1）在终端界面下输入 gedit /root/.bashrc ,编辑 ./bashrc 文件，如下图所示：

2）在 .bashrc文件中增加如下命令把交叉编译器的路径增加到环境变量PATH中, export PATH=$PATH:/usr/local/arm/4.3.2/bin ，然后保存推出，如下图所示：

重新打开终端，通过su命令切换到root用户，输入arm-linux-gcc –v就可以看到我们安装的交叉编译器arm-linux-gcc的版本信息了。如下图所示：

我们可以看到我们的安装的gcc版本为4.3.2,到这里，我们的交叉编译器环境arm-linux-gcc就安装好了。

第14篇：【嵌入式】Android开发NDK C++开发注意事项

Android开发NDK C++开发注意事项

相信Android开发者都喜欢用C++编写一些高效的应用，有关Android NDK的C++开发相关知识Android123总结如下:

1.从Android NDK r5开始支持了STL Port，在这个版本开始就可以使用部分STL库的功能了，比如说vector、string摆脱c下面容易出现的数组未初始化、越界，增强应用的健壮性。

2.很多网友包含了include 这样头，但仍然无法编译，这里你首先要检查当前文件是否为.cpp后缀，同时为了使用标准库必须加入 APP_STL := stlport_static 在Application.mk文件中。相关对应还有

system 使用默认最小的C++运行库，这样生成的应用体积小，内存占用小，但部分功能将无法支持

stlport_static 使用STLport作为静态库，这项是Android开发网极力推荐的

stlport_shared STLport作为动态库，这个可能产生兼容性和部分低版本的Android固件，目前不推荐使用。

gnustl_static 使用 GNU libstdc++ 作为静态库

默认情况下STLPORT是不支持C++异常处理和RTTI，所以不要出现 -fexceptions或 -frtti ，如果真的需要可以使用gnustl_static来支持标准C++的特性，但生成的文件体积会偏大，运行效率会低一些。

3.支持C++异常处理，在Application.mk中加入 LOCAL_CPPFLAGS += -fexceptions这句，同理支持RTTI，则加入LOCAL_CPPFLAGS += -frtti，这里Android123再次提醒大家，第二条说的使用gnustl静态库，而不是stlport

4.强制重新编译 STLPort ，在Application.mk中加入 STLPORT_FORCE_REBUILD := true 可以强制重新编译STLPort源码，由于一些原因可能自己需要修改下STLPort库，一般普通的开发者无需使用此项。

5 Android目前最新的NDK版本为r6，相关的学习可以查看NDK中的Samples整体和在PC上开发没有太大的不同。

嵌入式相关资料，欢迎下载！

《嵌入式相关资料》

第15篇：嵌入式实时操作系统项目开发总结报告

项目开发总结报告

分类：软件项目计划使用者：E-fanciers

Version: 1.0

项目承担队伍：烟台大学

计算机学院 E-fanciers小组撰写人（签名）：许超于歌

完成日期： 2009-7-16 本文档使用小组： E-fanciers小组

评审负责人（签名）：孝瑞

评审日期： 2009-7-19

一、引言 .............................................3

1.1编写目的 .......................................3 1.2项目背景 .......................................3 1.3定义 ...........................................3 1.4参考资料： .....................................3

二、开发结果 ........................错误！未定义书签。

2.1产品 ..........................错误！未定义书签。 2.2主要功能 ......................错误！未定义书签。 2.3所用工时 .......................................4 2.3所用机时 .......................................4 2.3进度 ...........................................4

三、评价 ............................................4

3.1生产率评价 .....................................4 3.2技术方案评价 ...................................4 3.3产品质量评价 ...................................4

四、经验与教训 .......................................4

一．引言

1．编写目的（阐明编写总结报告的目的,指明读者对象。）

详细陈述项目开发过程，对项目开发做最后的总结完善，说明项目开发过程中遇到的难题及解决方案。

2．项目背景（说明项目的来源、委托单位、开发单位及主管部门。）

随着微电子技术、计算机技术和网络通信技术的发展，嵌入式系统已广泛应用在各个领域，包括消费电子、汽车电子、网络通信、工业设备、航空航天和国防军事等。随着嵌入式技术的发展，工业领域也一改过去传统的单片机应用模式，逐渐将一些新嵌入式技术引入到系统中。特别是作为软件基础的嵌入式操作系统已广泛为业界所接受，借以提高系统的开发效率和运行效率。是否采用嵌入式操作系统，已成为工业设备品质优劣的标志之一。

当今的嵌入式操作系统领域呈现百家争鸣的状态。据最近的调查数据显示，嵌入式操作系统有数十种之多的。这种多样性存在是必然的，是由嵌入式系统的定制性所决定的，是针对各个领域和行业的不同需求的应对。也就是说，各个嵌入式操作系统都有自己的应用领域，针对不同的应用没有绝对的优劣之分，不会出现一种操作系统垄断的局面。自主开发嵌入式操作系统绝对不是多余的，也是是对这种多样性的自然顺应，应该可拥有自己的用武之地。有些国内嵌入式厂商将希望寄托在Linux之上，以为它可以帮助解决所面临的版税和安全等问题。但事实并非完全如此，至少在嵌入式系统领域。首先，Linux还是泊来货，国人并未掌握其核心技术和进程，也并未解决对外依赖的问题。其次，Linux是为桌面系统而设计的，并不能很好地满足嵌入式系统高效性和灵活性的要求；再次，Linux的一统也违背了嵌入式系统应用灵活定制的本质特性。

3．定义（列出报告中用到的专门术语定义和缩写词的原意。）

int taskInit(void)；

/*创建一个任务, 返回: 返回任务编号tid, >0: 成功, 其他: 失败.*/ /*name: 任务名称, entryPtr : 任务函数入口, stack_size: 任务栈大小, priority: 任务优先级*/ int taskCreate(char *name, void *entryPtr, int stack_size, int priority); /*启动一个任务, 让taskCreat创建的任务参加调度*/ int taskStart(unsigned char tid); /*tid: 任务编号, 由taskCreate返回*/ int taskPriorityGet(unsigned char tid); int taskPrioritySet(unsigned char tid, int newPriority); /*获取和设置任务优先级, 用于动态调整*/ int taskSuspend(unsigned char tid); /*将任务挂起, 该任务退出调度*/ int taskDelete(unsigned char tid); /*将任务删除该任务退出调度且回收任务分配的资源*/ int semCreate(void); /*互斥信号量创建, 返回信号量标识sid,

（4）国家软件开发文档标准模板

二．开发结果

1．产品（可包括：（1）列出各部分的程序名称、源程序行数（包括注释行）或目标程序字节数及程序总计数量、存储形式；产品文档名称等。）

2．主要功能及性能基本功能

1.基于参考硬件平台，建立硬件抽象层，完成基本硬件初始化，建立时钟中断；2.在硬件抽象层基础上，建立多任务操作系统环境； 3.任务调度采用同级时间片轮询机制；

4.实现任务间基本通讯机制：互斥信号量（共享内存）；5.实现基本的时钟管理机制：任务睡眠阻塞；

6.实现一个RS232串口驱动。基于串口驱动实现一个命令行Shell（用一个独立的任务实现），可在超级终端显示信息和执行命令。

扩展功能

7.任务区分优先级，在同级轮询调度基础上添加优先级调度机制；8.不同优先级任务之间实现抢占调度；

9.在抢占调度的基础上实现优先级逆转保护，避免逻辑死锁问题；10.将代码移植到另一个硬件平台上运行，验证代码移植性。 3．所用工时（按人员的不同层次分别计时。）

编码成员工时：60小时/周，共约400小时；

编写文档成员：共约60小时。

4．所用机时

5小时/天，共约300小时的机时。

5．进度（给出计划进度与实际进度的对比。）

根据敏捷开发方法的指导，每天查漏补缺，实际进度基本和计划进度一致。三．评价

1．生产率评价（如平均每人每周源程序行数、文档的字数等。）

源程序：200行/周

文档：1500字/周

2．技术方案评价

严格遵循开发流程，运用科学开发方法。

3．产品质量评价

按照大赛要求完成了应有功能的基础上有所添加自己小组的特色，譬如，设置相应的出错处理机制，为加强该系统的安全性与稳定性也做了相应的措施，总体来说，我们小组开发的嵌入式实时操作系统功能良好，稳定性强，。

四．经验与教训

经过近两个月的对嵌入式实时操作系统的开发，经验学到了不少，当然也得到了很多教训，因为小组的不注意，导致2138开发板没法继续工作，有的时候会很耽误时间，有的时候进度报告拖后一点才写，也因此导致过进度不明了，不过，大多数时候，我们小组成员都认真对待大赛，努力想把自己小组的作品做的更完美，最后终于成功交付任务，完成大赛。

第16篇：为什么学习嵌入式开发要学习linux？

福州鼎嵌

首先，ARM只是一个32位处理器，可以像51单片机一样用汇编直接操作它的寄存器、RAM、ROM等内部资源，当然也可以用Ｃ语言！那么如果只是把ARM当做单片机来用，那就有点大材小用了，那也就没必要学什么linux了。

事实上，ARM是通常都是用来做比较复杂的系统的，而且一般都是多任务系统的，当任务比较多，程序比较大的时候，只用汇编和Ｃ可怕难以胜任，所以我们应该给ＡＲＭ配一个操作系统，用来管理这些任务，那么对于ＡＲＭ，我们可以作使用哪些操作系统呢？Ｗindows XP行吗？当然不行，太大了，不适合做嵌入式，微软倒是推出了专门针对嵌入式系统开发的WinCE，可是这可不是免费的，而且不提供源码的，给你就像一个黑夹子，对于一般的嵌入式学习，就不太合适了？那么什么样的操作系统才能用于做嵌入式呢？嵌入式操作系统通常有Ｖxworks,ＷinCE,uC/OS,Linux/ucLinux等。而uC/OS、Linux因为其免费，而且开源，深受学习者和小公司的欢迎。

uC/OS操作系统内核很小，特别适合初学，而且它是占先式内核，是一个实时的操作系统，特别适合实时性要求较高的场合，其内核很小当然其功能当然也就没有linux强大，而且uC/OS的图形用户界面（GUI）还是刚有雏形，没有linux的GUI好，而它的GUI是收费的。这样的话只是linux是最好了，但是linux本身不是实时的操作系统，不适合实时性高的场合，于是ucLinux产生了，ucLinux是一个实时操作系统（RTOS），因此学习ARM+ucLinux的人较多。

所以，如果只搞uc/OS＋ARM，那就可以不学linux了，如果想学习ARM+ucLinux，要在ARM上移植linux，那么移植后，这个装有linux的ARM处理器，当然只能运行linux环境下编译出来的应用程序（这里还有一个交叉编译的概念需要正确理解），所以理所当然要学linux。通常小红帽Red Hat Linux 使用比较广泛，那么不能在Windows下开发ARM+ucLinux吗？其实倒是可以在Windows使用虚拟机软件VMware装一个linux，但那样不如直接装个Linux来的爽快！

福州鼎嵌技术专业从事嵌入式领域，能够帮助求职无果的大学生朋友走上嵌入式开发高薪之路，鼎嵌目前已为福建省内多家知名IT企业输送大量的嵌入式开发人才，开辟的实达定向委培班和天下创世企业内训活动。福州鼎嵌技术致力打造福建省内最专业的嵌入式交流平台，为广大嵌入式爱好者提供专业嵌入式平台交流，实现嵌入式高薪就业梦想。

第17篇：关于嵌入式开发的一点建议

CSDN：很多人都讲嵌入式开发很难，能不能就你学习和工作经验与大家分享下嵌入式开发如何开始和深入？作为嵌入式研发工程师，你认为其应具备哪些知识结构和实战能力？卜茂霞：说到嵌入式开发如何开始和深入，其实我也没有特别的方法，在这里仅谈下我的个人见解吧。做嵌入式开发必须具备良好的C语言功底，汇编虽然不是必须，但懂点更好。其次可以到网上找一个比较流行的MCU开发板，比如STM32做为学习开发板，参照示例代码，自己动手编译烧录跑程序，比如跑马灯的程序，深刻了解整个开发过程。接下来可以学习小型的实时操作系统，比如UC/OS和RT-Thread等，如果C语言比较好的话可以尝试了解这个实时操作系统的原理部分，尝试阅读其源码，掌握其使用技巧。而接下来最好是能参与具体的开发项目，负责几个模块，写写驱动，或做应用。

需要强调的是，每个过程一定要自己尝试动手，不要停留在书本或官方提供的开发手册上，一定要通过自己的实践去验证自己想法，在这个过程中通过不断思考与验证，有问题找经验丰富的同事或在网上找答案，另外最好能将心得记录下来（比如说写CSDN博客），并不断总结。这样持之以恒，不知不觉你就会发现已经进入资深嵌入式开发工程师的行列了。个人认为嵌入式开发工程师应具备：1.良好的C语言功底。2.至少熟悉一款MCU，其它的技能可以在具体项目中不断学习来补充。

第18篇：产品开发岗位职责

技术总监职务描述为http://整理发布，类型为岗位管理，本站还有更多关于岗位管理，人力资源管理培训岗位管理的资料。正文：岗位名称技术总监岗位编号所在部门岗位定员

直接上级总经理工资等级二级

直接下级技术开发部、品管部薪酬类型

所辖人员岗位分析日期2002年2月

本职：负责组织和领导公司的产品开发、技术改良建立公司质量管理体系并组织实施确保公司产品开发满足市场需求并保证公司产品达到目标质量水平

职责与工作任务：

权力：

公司重大人事、财务、业务决策建议权

公司发展战略、技术开发战略和质量管理战略建议权

权限内技术开发方案的审批权重大技术开发方案的审核权

权限内公司质量管理标准的审批权重大质量事件的裁决建议权

新产品开发可行性研究的审核权和新产品开发成果的组织评审权

权限内的财务审批权

对直接下级人员调配、奖惩的建议权和任免的提名权考核评价权

对所属下级的工作的监督、检查权

对所属下级的工作争议有裁决权

产品开发主管的岗位职责为http://整理发布，类型为岗位管理，本站还有更多关于岗位管理，人力资源管理培训岗位管理的资料。正文：产品开发技术员职位名称产品开发技术员职位代码所属部门

职系职等职级直属上级产品开发工程师

薪金标准填写日期核准人

职位概要:

协助产品开发工程师完成产品研制、开发的日常事务工作

工作内容:

%协助产品开发工程师完成产品研发项目；

%按进度完成工作计划及时记录各种工作要素编制齐全的产品文件；

%严格遵循新产品开发流程保质保量完成试样；

%会同产品工艺工程师完成试生产处理试生产中的设计问题；

%指导样品的制作并对性能指标进行验证；

%协助质量、市场部门解决客户技术问题协助销售部搞好客户服务

任职资格:

教育背景:

◆理工类专业本科以上学历

经验:

◆2年以上相关行业工作经验

技能技巧:

◆熟悉公司的工艺工序、工作原理；

◆具有良好的英语阅读能力；

◆掌握AutoCAD、Office等相关计算机软件；

◆熟悉工程设计软件者为优

态度:

◆工作认真积极有较强的责任心；

◆能吃苦耐劳主动性强具有良好的沟通技巧和团队合作精神工作条件:

工作场所:办公室以及生产场所

环境状况:基本舒适

危险性:基本无危险无职业病危险

直接下属间接下属

晋升方向轮转岗位

第19篇：市场开发岗位职责

1在市场策划部的领导下，进行市场开发工作。 2 积极参与市场调研和预测，共同制订市场营销计划，确定经营目标。 3 有责任跟踪市场形势的变化和客户需求的变动。 4 拓展市场业务，开发营销项目，构建营销渠道的种类和能力。 5负责市场战略规划的起草的制定工作。 6有责任协同综合管理部提高整个营销队伍的营销理念。 7参加广告宣传计划的制定工作。 8参与编辑市场信息报告和市场动态。 9有责任收集市场发展信息。

第20篇：开发总监岗位职责

1.负责公司软件部门的行政管理和技术管理。2.负责制订和执行软件开发部门的工作计划。3.负责制定软件开发部门的长期发展战略。4.精通产品开发流程,控制公司所有产品的开发流程。5.协调研发部门和市场部门之间的工作接口。6.对产品开发进行严格的项目管理控制。

《嵌入式开发岗位职责.doc》

将本文的Word文档下载到电脑，方便编辑。

推荐度：

点击下载文档