单片机作品

⑴ 每一个单片机做作品都要把最小系统做上去吗

一般是的。
但有些单片机内部集成了复位和震荡电路，只要下载了程序接电源就可以了。

⑵ 单片机作品

http://www.ourdev.cn/bbs/

到上面搜索下

⑶ 请介绍一些有一定深度的单片机作品(像数字钟、流水灯那种就不必了)

用PWM功能来做DA输出。
CAN通信。
PID算法控制电机运行。
无刷电机的电调控制（用单片机接收旋转位置的信号，并控制器启停，转速大小）。
还有一个，还是做数字钟，但要求屏幕不能使数码管。而是至少有1000个以上的LED灯组成的阵列。就像公交车上或一些户外广告屏上那样，上千个LED灯组成的阵列，能显示滚动汉字……
估计上述这几个够你做一年的了。最后那个我现在还没做出来呢，因为太繁琐了，但这个很挣钱的，做一个LED屏能买好几千了。

⑷ 求at89c51单片机作品

密码锁：
#include<reg51.h>
#include<intrinS.h>
#include<absacc.h>

#define uchar unsigned char
#define C02_write 0xa0
#define C02_read 0xa1

#define no0 0x28
#define no1 0x14
#define no2 0x24
#define no3 0x44
#define no4 0x12
#define no5 0x22
#define no6 0x42
#define no7 0x11
#define no8 0x21
#define no9 0x41
#define enter 0x88
#define backspace 0x81

#define lcm_write_cmd_add XBYTE[0x80FF]
#define lcm_write_data_add XBYTE[0x81FF]
#define lcm_read_busy_add XBYTE[0x82FF]
#define lcm_read_data_add XBYTE[0x83FF]

uchar idata temp5_password[6]={0x00,0x00,0x00,0x00,0x00,0x00};
uchar idata key_code[]={no0,no1,no3,no4,no5,no6,no7,no8,no9};

sbit SCL=P3^0;
sbit SDA=P3^1;
sbit i=P3^2;
bit ack;

uchar int_counter_1;
unsigned int int_counter_2;

void delayms(uchar i)
{
uchar j;
for(;i>0;i--)
for(j=124;j>0;j--);
}

void longdelay(uchar i)
{
unsigned int j;
for(;i>0;i--)
for(j=10000;j>0;j--);
}

void lcm_wait()
{
while(lcm_read_busy_add&0x80);
}

void lcm_write_cmd(uchar lcm_cmd)
{
lcm_wait();
lcm_write_cmd_add=lcm_cmd;
}

void lcm_write_data(uchar lcm_data)
{
lcm_wait();
lcm_write_data_add=lcm_data;
}

uchar lcm_read_data(void)
{
uchar lcm_data;
lcm_wait();
lcm_data=lcm_read_data_add;
return(lcm_data);
}

void lcm_setxy(uchar x,uchar y)
{
if(y==1) lcm_write_cmd(x|0x80);
if(y==2) lcm_write_cmd(x|0xc0);
}

void lcm_write_string(uchar *string)
{
uchar i=0;
while(string[i]!='\0')
{
lcm_write_data(string[i]);
i++;
}
}

void lcm_roll_display(uchar *string,uchar y)
{
uchar counter;
lcm_write_cmd(0x06);
lcm_setxy(0,y);
while(string[counter]!='\0')
{
lcm_write_data(string[counter]);
counter++;
if (counter==19) lcm_setxy(19,y);
longdelay(2);

}
lcm_write_cmd(0x07);
lcm_setxy(19,y);
while(string[counter]!='\0')
{
lcm_write_data(string[counter]);
counter++;
if (counter==19) lcm_setxy(19,y);
longdelay(2);

}
}

void lcm_init()
{
delayms(20);
lcm_write_cmd_add=0x38;
delayms(4);
lcm_write_cmd_add=0x38;
delayms(1);
lcm_write_cmd_add=0x38;
lcm_write_cmd(0x38);
lcm_write_cmd(0x0f);
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
}

void I2C_start(void)
{
SDA=1;
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SDA=0;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
}

void I2C_stop(void)
{
SDA=0;
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SDA=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
}

void I2C_ackownledge(void)
{
SDA=0;
_nop_();
_nop_();
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
_nop_();
}

void I2C_no_ackownledge(void)
{
SDA=1;
_nop_();
_nop_();
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
_nop_();
}

void I2C_sendB(uchar byte)
{
uchar counter;
for(counter=0;counter<8;counter++)
{
if(byte&0x80) SDA=1;
else SDA=0;
_nop_();
SCL=1;
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
byte<<=1;
}
_nop_();
_nop_();
SDA=1;
_nop_();
_nop_();
_nop_();
SCL=1;
_nop_();
_nop_();
_nop_();
if(SDA==0) ack=1;
else ack=0;
SCL=0;
_nop_();
_nop_();
}

uchar I2C_receiveB(void)
{
uchar temp;
uchar counter;
temp=0;
SDA=1;
_nop_();
_nop_();
for(counter=0;counter<8;counter++)
{
_nop_();
_nop_();
_nop_();
_nop_();
_nop_();
SCL=1;
_nop_();
_nop_();
if(SDA==1) temp=(temp<<1)|0x01;
else temp=temp<<1;
_nop_();
_nop_();
SCL=0;
_nop_();
_nop_();
_nop_();
}
_nop_();
_nop_();
return(temp);
}

/*bit I2C_write_byte(uchar byte,uchar address)
{
I2C_sendB(address);
if(ack=0)
{
I2C_stop();
return(0);
}
else I2C_sendB(byte); */

bit I2C_send_string(uchar *string,uchar no,uchar address)
{
uchar counter;
for(counter=0;counter<no;counter++)
{
I2C_start();
I2C_sendB(C02_write);
if(ack==0) return(0);
I2C_sendB(address+counter);
if(ack==0) return(0);
I2C_sendB(string[counter]);
I2C_stop();
delayms(20);
}
return(1);
}

bit I2C_receive_string(uchar *string,uchar no,uchar address)
{
uchar counter;
for(counter=0;counter<no;counter++)
{
I2C_start();
I2C_sendB(C02_write);
if(ack==0) return(0);
I2C_sendB(address+counter);
if(ack==0) return(0);
I2C_start();
I2C_sendB(C02_read);
if(ack==0) return(0);
*(string+counter)=I2C_receiveB();
I2C_no_ackownledge();
I2C_stop();
}
}

uchar get_key()
{
uchar row_code;
uchar col_code;
P1=0xf0;
if(P1!=0xf0)
{
delayms(10);
if(P1!=0xf0)
{
row_code=0xfe;
while(row_code!=0x7f)
{
P1=row_code;
if(P1!=row_code)
{
col_code=(P1&0xf0)|0x0f;
return( (~col_code)|(~row_code));
}
row_code=((row_code<<1)|0x01);
}
}
}
return(0x00);
}

void convert_code(uchar *string)
{
uchar counter=0;
for(counter=0;counter<6;counter++)
{
switch(*string)
{
case no0:
*string=0x00;
break;
case no1:
*string=0x01;
break;
case no2:
*string=0x02;
break;
case no3:
*string=0x03;
break;
case no4:
*string=0x04;
break;
case no5:
*string=0x05;
break;
case no6:
*string=0x06;
break;
case no7:
*string=0x07;
break;
case no8:
*string=0x08;
break;
case no9:
*string=0x09;
break;
default:
break;
}
string++;
}
}

bit compare_string(uchar *string1,uchar *string2)
{
uchar counter;
for(counter=0;counter<6;counter++)
{
if(string1[counter]!=string2[counter]) return(0);
}
return(1);
}

uchar step_choose(void)
{
unsigned int i;
uchar key;
do{
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("input password");
lcm_setxy(0,2);
lcm_write_string("please press 1");
for(i=0;i<30000;i++)
{
key=get_key();
if((key==no1)||(key==no2)) break;
}
if((key!=no1)&&(key!=no2))
{
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("change password");
lcm_setxy(0,2);
lcm_write_string("please press 2");
for(i=0;i<30000;i++)
{
key=get_key();
if((key==no1)||(key==no2)) break;
}
}
}
while((key!=no1)&&(key!=no2));
return(key);
}

bit input_password(uchar *password)
{
uchar counter;
uchar key;
lcm_setxy(0,2);
for(counter=0;counter<7;counter++)
{
longdelay(3);
if(counter<6)
{
do{
key=get_key();
}
while(key==0x00);
if((key!=backspace)&&(key!=enter))
{
lcm_write_data('*');
password[counter]=key;
}
if(key==backspace)
{
if(counter>0)
{
lcm_setxy(--counter,2);
lcm_write_data(' ');
password[counter]=0x00;
lcm_setxy(counter,2);
counter--;
}
}
if(key==enter)
{
lcm_setxy(0,1);
return( 0);
}
}
if(counter==6)
{
do{
key=get_key();
}
while((key!=backspace)&&(key!=enter));
if(key==backspace)
{
lcm_setxy(--counter,2);
lcm_write_data(' ');
password[counter]=0x00;
lcm_setxy(counter,2);
counter--;
}
if(key==enter)
{
return(1);
}
}
}
}

void mima()
{
uchar key;
uchar idata temp1_password[6]={0,0,0,0,0,0};
uchar idata temp3_password[6]={0,0,0,0,0,0};
uchar idata temp2_password[6]={0,0,0,0,0,0};
uchar idata temp4_password[6]={0,0,0,0,0,0};
key=step_choose();
if(key==no1)
{
I2C_receive_string(temp1_password,6,0x00);
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(2,0);
lcm_write_string("input password");
if(input_password(temp2_password))
{
convert_code(temp2_password);
if(compare_string(temp1_password,temp2_password))
{
lcm_setxy(0,2);
lcm_write_string("correct!");
longdelay(6);
return;
}
else
{
lcm_setxy(0,2);
lcm_write_string("wrong password");
longdelay(6);
return;
}
}
else
{
lcm_setxy(0,2);
lcm_write_string("error! ");
longdelay(6);
}
}
else
{
I2C_receive_string(temp1_password,6,0x00);
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,0);
lcm_write_string("input old password");
if(input_password(temp2_password))
{
convert_code(temp2_password);
if(compare_string(temp1_password,temp2_password))
{
lcm_setxy(0,2);
lcm_write_string("password correct!");
longdelay(6);
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("input new password");
if(input_password(temp3_password))
{
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("input password again");
if(input_password(temp4_password))
{
if(compare_string(temp3_password,temp4_password))
{
convert_code(temp3_password);
I2C_send_string(temp3_password,6,0x00);
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("password has");
lcm_setxy(0,2);
lcm_write_string("been changed");
longdelay(10);
return;
}
else
{
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_setxy(0,1);
lcm_write_string("twice input");
lcm_setxy(0,2);
lcm_write_string("is different");
longdelay(10);
return;
}
}
else
{
lcm_setxy(0,2);
lcm_write_string("error! ");
longdelay(10);
return;
}
}
else
{
lcm_setxy(0,2);
lcm_write_string("error! ");
longdelay(10);
return;
}
}
else
{
lcm_setxy(0,2);
lcm_write_string("wrong password");
longdelay(6);
return;
}
}
else
{
lcm_setxy(0,2);
lcm_write_string("error! ");
longdelay(6);
return;
}
}

}

void int_service(void) using 0 interrupt 0
{
EA=0;
EX0=0;
for(int_counter_1=10;int_counter_1>0;int_counter_1--)
{
for(int_counter_2=0xffff;int_counter_2>0;int_counter_2--)
{
if(i)
{
EA=1;
EX0=1;
return;
}
}
}
lcm_write_cmd(0x01);
lcm_write_cmd(0x06);
lcm_write_string("rest success!");
longdelay(12);
I2C_send_string(temp5_password,6,0x00);

(*(void(*)())0)();
}

void main(void)
{

IT0=1;
EX0=1;
EA=1;

lcm_init();
while(1)
{
mima();
}
}

⑸ 51单片机令人惊艳的作品

51单片机
51单片机是对所有兼容Intel 8031指令系统的单片机的统称。该系列单片机的始祖是Intel的8004单片机，后来随着Flash rom技术的发展，8004单片机取得了长足的进展，成为应用最广泛的8位单片机之一，其代表型号是ATMEL公司的AT89系列，它广泛应用于工业测控系统之中。很多公司都有51系列的兼容机型推出，今后很长的一段时间内将占有大量市场。51单片机是基础入门的一个单片机，还是应用最广泛的一种。需要注意的是51系列的单片机一般不具备自编程能力。

中文名称
51单片机

外文名称
mcu

定义
兼容Intel 8031系统的单片机统称

始祖
Intel公司始创的8004单片机

缺点
不具备自编程能力

用途
工业测控系统

主要产品
*Intel(英特尔)的：80C31、80C51、87C51，80C32、80C52、87C52等；

*ATMEL(艾德梅尔)的：89C51、89C52、89C2051，89S51（RC），89S52（RC）等；

*Philips(飞利浦)、华邦、Dallas(达拉斯)、Siemens(西门子)等公司的许多产品；

STC(国产宏晶)单片机：89c51、89c52、89c516、90c516等众多品牌。

功能

·8位CPU·4kbytes程序存储器(ROM) (52为8K)

·128bytes的数据存储器(RAM) （52有256bytes的RAM）

·32条I/O口线·111条指令，大部分为单字节指令

·21个专用寄存器

·2个可编程定时/计数器·5个中断源，2个优先级（52有6个）

·一个全双工串行通信口

·外部数据存储器寻址空间为64kB

·外部程序存储器寻址空间为64kB

·逻辑操作位寻址功能·双列直插40PinDIP封装

·单一+5V电源供电

CPU：由运算和控制逻辑组成，同时还包括中断系统和部分外部特殊功能寄存器；

RAM：用以存放可以读写的数据，如运算的中间结果、最终结果以及欲显示的数据；

ROM：用以存放程序、一些原始数据和表格；

I/O口：四个8位并行I/O口，既可用作输入，也可用作输出

T/C：两个定时/记数器，既可以工作在定时模式，也可以工作在记数模式；

五个中断源的中断控制系统；

一个全双工UART（通用异步接收发送器）的串行I/O口，用于实现单片机之间或单片机与微机之间的串行通信；

片内振荡器和时钟产生电路，石英晶体和微调电容需要外接。最佳振荡频率为6M—12M。

学习
作为一个初学者，如何单片机入门？

实际上，其实不需要多少东西，会简单的C语言，知道51单片机的基本结构就可以了。一般的大学毕业生都可以了，自学过这2门课程的高中生也够条件。设备上，一般是建议购买一个仿真器，例如，的“双功能下载线”就具有良好的稳定性和较快的下载速度，上位机可扩展，可以下载更多的单片机及嵌入式芯片。通过实验，这样才可以进行实际的，全面的学习。日后在工作上，仿真器也大有用处。还有，一般光有仿真器是不行，还得有一个实际的电路，即学习板，如图，即为，单片机最小系统。

学习板以强大的接口为主，单片机的学习分两方面，一方面是单片机的原理及内部结构，另一方面是单片机的接口技术。这些都是需要平时多积累，多动手，多思考，这样才能学好单片机技术。

注：“双功能下载线”在网络文库里有详细的使用说明，并且上位机会定期更新以支持更多的单片机。

⑹ 自制单片机作品的介绍怎么写

你是准备发表文章吗？
首先，你得确定将文章发表到什么刊物，然后买几本那刊物，看看别人是怎样写的，参照他们的风格，OK
祝你成功。

⑺ 单片机小作品

都是给你的垃圾建议，你做完还是屁都不是的入门生。
建议你做点实用的项目，哪怕是做现有的项目，对你也是巨大的提升。
例如 笔记本电池，就做你自己笔记本的电池，只要不是DELL 联想，其它牌子都没有加密，是可以做的，一整套做下来。你所学的基本全部得到了应用。IIC变种的SMBUS，电压检测，可以是最差的电阻分压，也可以是高端点的共模差分，甚至是买个模拟前端，串口控制。电流检测模拟前端IC一般都有，你还可以用LM358运放做。温度检测温度电阻，容量累计算法，静态功耗，长期放置1年都可以用。还有保护电路，短路保护都可以用三极管做个模拟电路搭建，BQ2060的电路里有，可以抄袭研究。
简单点还可以自己做个充电宝，充电IC用4056 4057，甚至你自己做到单片机里，利用PWM自己做，连接检测，升压，
以上还能在进一步，做个在线升级功能，做个BOOT程序，笔记本电池做个上位机，利用SMBUS在线升级更新程序，更改数据。
做这些项目，比你做什么烟感，音乐喷泉，智能温控风扇，超声波测距，电子秤，电子表等等耍着玩的东西强多了，这些才能真正锻炼你。

⑻ 我是一个单片机初学者，希望各位大神能给我一些制作简单小作品的实例；最好有电路图和程序。

我把我做过的一些小东西发给你吧，你解压里面有两个图，一个是流水灯，一个是交通信号灯，流水灯有几种实现方式，里面有程序