设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机+SIM900防幼儿误锁车内装置程序PCB设计
返回列表 发新帖
查看: 1572|回复: 1
收起左侧

单片机+SIM900防幼儿误锁车内装置程序PCB设计

[复制链接]
ID:713392 发表于 2020-3-22 14:52 | 显示全部楼层 |阅读模式
供大家参考内附有电路图，棒棒
Altium Designer画的原理图和PCB图如下：(51hei附件中可下载工程文件)
51hei.png 51hei.png

单片机源程序如下:
  1. /************************************************************
  2. 程序说明：
  3. 1.将自己的51单片机的串口1连接到GSM 232上
  4. 2.找到程序中前面的#define处，根据说明修改好自己的单片机配置，编译程序
  5. 2.下载程序
  6. 3.等待发送成功
  7. *************************************************************/
  8. #include <REG51.H>
  9. #define uchar unsigned char
  10. #define uint unsigned int
  11. #define FOSC_110592M
  12. //#define FOSC_12M
  13. //无论接收到信号还是发送完信号，都会进中断服务程序的
  14. /*初始化程序（必须使用，否则无法收发），次程序将会使用定时器1*/
  15. void SerialInti()//初始化程序（必须使用，否则无法收发）
  16. {
  17.         TMOD=0x20;//定时器1操作模式2:8位自动重载定时器

  19. #ifdef FOSC_12M                   //在这里根据晶振大小设置不同的数值初始化串口
  20.         TH1=0xf3;//装入初值，波特率2400
  21.         TL1=0xf3;       
  22. #else        
  23.         TH1=0xfd;//装入初值，波特率9600
  24.         TL1=0xfd;
  25. #endif //end of SOC_12M
  26.        
  27.         TR1=1;//打开定时器
  28.         SM0=0;//设置串行通讯工作模式，（10为一部发送，波特率可变，由定时器1的溢出率控制）
  29.         SM1=1;//(同上)在此模式下，定时器溢出一次就发送一个位的数据
  30.         REN=1;//串行接收允许位（要先设置sm0sm1再开串行允许）
  31.         EA=1;//开总中断
  32.         ES=1;//开串行口中断       
  33. }

  35. /*串行通讯中断，收发完成将进入该中断*/
  36. void Serial_interrupt() interrupt 4
  37. {
  38. //        a=SBUF;
  39.         P2=SBUF;
  40.         RI=0;//接收中断信号清零，表示将继续接收
  41. //        flag=1;//进入中断的标志符号
  42. }


  45. void Uart1Send(uchar c)
  46. {
  47.         SBUF=c;
  48.         while(!TI);//等待发送完成信号（TI=1）出现
  49.         TI=0;       
  50. }

  52. //串行口连续发送char型数组，遇到终止号/0将停止
  53. void Uart1Sends(uchar *str)
  54. {
  55.         while(*str!='\0')
  56.         {
  57.                 SBUF=*str;
  58.                 while(!TI);//等待发送完成信号（TI=1）出现
  59.                 TI=0;
  60.                 str++;
  61.         }
  62. }

  64. //延时函数大概是1s钟，不过延时大的话不准...
  65. void DelaySec(int sec)
  66. {
  67.         uint i , j= 0;

  69.         for(i=0; i<sec; i++)
  70.         {
  71.                 for(j=0; j<65535; j++)
  72.                 {       
  73.                 }
  74.         }
  75. }
  76. void main()
  77. {
  78.         uchar i = 0;
  79.         SerialInti();  
  80.         //程序执行到这里，模块已经注册到了网络，可以将让模块开机，等待模块注册到网络，然后开单片机电源。
  81.         Uart1Sends("AT+CMGF=1\r\n");
  82.         DelaySec(3);//延时3秒        //延时不准，此处加了这么长的延时 就是单纯为了 能让模块执行此条指令，实际中最好加判断，判断模块是否执行成功
  83.         Uart1Sends("AT+CSCS=\"UCS2\"\r\n");
  84.         DelaySec(3);//延时3秒                 
  85.         Uart1Sends("AT+CSCA?\r\n");
  86.         DelaySec(3);//延时3秒
  87.         Uart1Sends("AT+CSMP=17,167,0,25\r\n");
  88.         DelaySec(3);//延时3秒       
  89.         //下面的短信号，短信内容都为UNICON编码，可以用UNICON编码工具来获取
  90.         Uart1Sends("AT+CMGS=\"00310033003800310038003200370030003000360039\"");//此处修改为对方的电话号 注意此条指令后不要加回车换行
  91.         DelaySec(5);//延时3秒
  92.         Uart1Sends("4F60597D00680065006C006C006F");
  93.         Uart1Send(0x1a);
  94.         DelaySec(15);//延时20秒
  95.        
  96. }
复制代码
  1. /************************************************************
  2. 程序说明：
  3. 本程序运行后如果gprs模块找到服务商信号可实现接打电话发送短信等功能


  6. *************************************************************/
  7. #include <REG51.H>
  8. #include <string.H>
  9. #define uchar unsigned char
  10. #define uint unsigned int
  11. //以下是板子上LED的配置，把Px_x改成自己对应的脚。
  12. sbit P10=P1^0;
  13. sbit P11=P1^1;
  14. sbit P12=P1^2;
  15. sbit P13=P1^3;
  16. sbit P14=P1^4;
  17. sbit P15=P1^5;
  18. sbit P16=P1^6;   //rst for sim900a
  19. #define FOSC_110592M
  20. //#define FOSC_12M
  21. //以下是开机后拨打的手机号，改成自己想要打的号码即可。
  22. uchar num[] = "ATD10086;\r\n";
  23. //以下是GSM模块返回数据
  24. uchar rec_data[50];
  25. uchar rec_num;
  26. //注意，无论接收到信号还是发送完信号，都会进中断服务程序的
  27. /*初始化程序（必须使用，否则无法收发），次程序将会使用定时器1*/
  28. void SerialInti()//初始化程序（必须使用，否则无法收发）
  29. {
  30.         TMOD=0x20;//定时器1操作模式2:8位自动重载定时器

  32. #ifdef FOSC_12M                   //在这里根据晶振大小设置不同的数值初始化串口
  33.         TH1=0xf3;//装入初值，波特率2400
  34.         TL1=0xf3;       
  35. #else        
  36.         TH1=0xfd;//装入初值，波特率9600
  37.         TL1=0xfd;
  38. #endif //end of SOC_12M
  39.        
  40.         TR1=1;//打开定时器
  41.         SM0=0;//设置串行通讯工作模式，（10为一部发送，波特率可变，由定时器1的溢出率控制）
  42.         SM1=1;//(同上)在此模式下，定时器溢出一次就发送一个位的数据
  43.         REN=1;//串行接收允许位（要先设置sm0sm1再开串行允许）
  44.         EA=1;//开总中断
  45.         ES=1;//开串行口中断       
  46. }

  48. /*串行通讯中断，收发完成将进入该中断*///如：+CMTI:"SM",2
  49. void Serial_interrupt() interrupt 4
  50. {

  52.         uchar temp;
  53.         temp=SBUF;
  54.         rec_data[rec_num++]=temp;
  55.         if(rec_num>=50)
  56.                 rec_num=0;
  57.         else
  58.                 ;
  59.         RI=0;//接收中断信号清零，表示将继续接收

  61. }

  63. //串行口连续发送char型数组，遇到终止号/0将停止
  64. void Uart1Sends(uchar *str)
  65. {
  66.         while(*str!='\0')
  67.         {
  68.                 SBUF=*str;
  69.                 while(!TI);//等待发送完成信号（TI=1）出现
  70.                 TI=0;
  71.                 str++;
  72.         }
  73. }
  74. void Uart1BYTE(uchar temp)
  75. {
  76.                 SBUF=temp;
  77.                 while(!TI);//等待发送完成信号（TI=1）出现
  78.                 TI=0;

  80. }

  82. uchar hand(uchar *ptr)
  83. {
  84.         if(strstr(rec_data,ptr)!=NULL)
  85.                 return 1;
  86.         else
  87.                 return 0;
  88. }

  90. void clear_rec_data()
  91. {
  92.         uchar i;
  93.         for(i=0;i<strlen(rec_data);i++)
  94.         {
  95.                 rec_data[i]='0';
  96.        
  97.         }
  98.         rec_num=0;


  101. }
  102. //延时函数大概是1s钟，不过延时大的话不准...
  103. void DelaySec(int sec)
  104. {
  105.         uint i , j= 0;

  107.         for(i=0; i<sec; i++)
  108.         {
  109.                 for(j=0; j<65535; j++)
  110.                 {       
  111.                 }
  112.         }
  113. }

  115. void Delayms(int sec)
  116. {
  117.         uint i , j= 0;

  119.         for(i=0; i<sec; i++)
  120.         {
  121.                 for(j=0; j<30000; j++)
  122.                 {       
  123.                 }
  124.         }
  125. }
  126. void main()
  127. {
  128.         uchar i = 0;
  129.         uint rst_time;
  130.         SerialInti();

  132.         //Uart1Sends(num);
  133.         //建议在单片机控制GSM模块前，加上两条 AT 指令，用来同步模块与单片机的波特率
  134.        
  135.         Uart1Sends("ATI\r\n"); //握手
  136.         /*
  137.         while(!hand("OK"))
  138.         {
  139.                 clear_rec_data();
  140.                 i++;
  141.                 Uart1Sends("ATI\r\n");//
  142.                 DelaySec(1);//延时
  143.                 if(i>=5)
  144.                 {
  145.                         break;
  146.                         //return;
  147.                 }
  148.                 else
  149.                         ;
  150.         }
  151.         P10=0;
  152.         clear_rec_data();//删除存储的GSM模块返回的数据，以便于以后继续判断
  153.         Delayms(1);
  154.         Uart1Sends("AT+CSQ\r\n");//信号质量
  155.         DelaySec(1);//延时
  156.         i=0;
  157.         while(!hand("OK")) //检测此条指令GSM模块是否执行OK
  158.         {
  159.                 clear_rec_data();
  160.                 i++;
  161.                 Uart1Sends("AT+CSQ\r\n");//
  162.                 DelaySec(1);//延时
  163.                 if(i>=5)
  164.                 {
  165.                         break;
  166.                         //return;
  167.                 }
  168.                 else
  169.                         ;
  170.         }
  171.         P11=0;
  172.         clear_rec_data();
  173.         Delayms(1);
  174.         Uart1Sends("AT+CPIN?\r\n");//查看是否读到手机卡
  175.         DelaySec(1);//延时
  176.         i=0;
  177.         while(!hand("READY")) //检测SIM模块是否收到SIM卡READY
  178.         {
  179.                 clear_rec_data();
  180.                 i++;
  181.                 Uart1Sends("AT+CPIN?\r\n");//是否注册到网络
  182.                 DelaySec(1);//延时
  183.                 if(i>=5)
  184.                 {
  185.                         break;
  186.                         //return;
  187.                 }
  188.                 else
  189.                         ;               
  190.         }
  191.         P12=0;
  192.         Uart1Sends("AT+COPS?\r\n");//是否注册到网络
  193.         DelaySec(1);//延时
  194.         i=0;
  195.         while(!hand("CHINA")) //检测是否收到模块返回的CHINA
  196.         {
  197.                 clear_rec_data();
  198.                 i++;
  199.                 Uart1Sends("AT+COPS?\r\n");//是否注册到网络
  200.                 DelaySec(1);//延时
  201.                 if(i>=5)
  202.                 {
  203.                         break;
  204.                         //return;
  205.                 }
  206.                 else
  207.                         ;               
  208.         }
  209.         P13=0;
  210.         clear_rec_data();
  211.         Delayms(1);
  212.         Uart1Sends("AT+CMMI=2,1\r\n"); //开回显
  213.         DelaySec(1);//延时
  214.         Uart1Sends("AT+CMGF=1\r\n");  //方式1
  215.         DelaySec(1);//延时
  216.         Uart1Sends("AT+CMGD=1\r\n");//删除SIM卡中的内容

  218.         //以下内容没有实际测试，仅供参考
  219.         */
  220.         while(1)
  221.         {
  222.                 if(hand("CMTI"))
  223.                 {
  224.                         P13=0;
  225.                         clear_rec_data();
  226.                         Delayms(1);
  227.                         Uart1Sends("AT+CMGR=1\r\n");//
  228.                         Delayms(10);
  229.                         //DelaySec(1);//延时
  230.                         i=0;
  231.                         while(!hand("OK"))
  232.                         {
  233.                                 clear_rec_data();
  234.                                 i++;
  235.                                 Uart1Sends("AT+CMGR=1\r\n");//
  236.                                 Delayms(10);
  237.                                 if(i>=4)   //chucuo
  238.                                 {
  239.                                         break;
  240.                                         //return;
  241.                                 }
  242.                                 else
  243.                                         ;               
  244.                         }
  245.                         for(i=0;i<2;i++) //读两次命令内容
  246.                         {
  247.                                 Delayms(1);
  248.                                 if(hand("relay on"))
  249.                                 {
  250.                                         P16=~P16;
  251.                                         break;
  252.                                 }
  253.                                 else if(hand("relay off"))
  254.                                 {
  255.                                        
  256.                                         P16=~P16;
  257.                                         break;
  258.                                 }
  259.                                 else
  260.                                 {
  261.                                         //break;
  262.                                 }
  263.                         }
  264.                         Uart1Sends("AT+CMGD=1\r\n");//删除短信，释放内存
  265.                         DelaySec(1);//延时
  266.                         clear_rec_data();
  267.                         Delayms(1);

  269.                
  270.                 }
  271.                 else if(hand("RING")) //电话进来 挂断电话
  272.                 {
  273.                        
  274.                         Uart1Sends("ATH\r\n");//
  275.                         Delayms(10);
  276.                         i=0;
  277.                         while(!hand("OK"))
  278.                         {
  279.                                 clear_rec_data();
  280.                                 i++;
  281.                                 Uart1Sends("ATH\r\n");//
  282.                                 Delayms(10);
  283.                                 if(i>=2)
  284.                                 {
  285.                                         break;
  286.                                         //return;
  287.                                 }
  288.                                 else
  289.                                         ;               
  290.                         }
  291.                         clear_rec_data();
  292.        
  293.                 }
  294.                 else
  295.                 {
  296.                        
  297.                         Delayms(1);//延时
  298.                         rst_time++;
  299.                         i=0;
  300.                         if(rst_time>=200)
  301.                         {
  302.                                 rst_time=0;
  303.                                 Uart1Sends("ATI\r\n");//
  304.                                 Delayms(10);
  305.                                 Uart1Sends("AT+CMGD=1\r\n");//
  306.                                 DelaySec(1);//延时
  307.                                 while(!hand("OK"))
  308.                                 {
  309.                                         clear_rec_data();
  310.                                         i++;
  311.                                         Uart1Sends("ATI\r\n");//
  312.                                         Delayms(10);
  313.                                         Uart1Sends("AT+CMGD=1\r\n");//
  314.                                         DelaySec(1);//延时
  315.                                         if(i>=2)   //超过四次无正确返回，模块可能死机，复位一下
  316.                                         {
  317.                                                 P16=0; //复位
  318.                                                 DelaySec(1);//延时
  319.                                                 DelaySec(1);//延时
  320.                                                 DelaySec(1);//延时
  321.                                                 DelaySec(1);//延时长些，确保复位有效
  322.                                                 P16=1; //复位
  323.                                                 DelaySec(1);//延时
  324.                                                 break;
  325.                                                 //return;
  326.                                         }
  327.                                         else
  328.                                                 ;               
  329.                                 }
  330.                         }
  331.                
  332.                 }
  333.         }

  335. }
复制代码

所有资料51hei提供下载:
防幼儿误锁车内装置设计(含电路图原理图,程序).7z (1.49 MB, 下载次数: 38)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:894266 发表于 2021-3-20 13:25 | 显示全部楼层
谢谢分享，可以把主要元器件和功能说一下嘛，有些小白

回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表