Arduino>> arduino>> 返回
项目作者： ybw2016v

项目描述 ：
基于arduino、树莓派、flask的光污染探测分析仪
高级语言： Jupyter Notebook
项目地址: git://github.com/ybw2016v/arduino.git
创建时间： 2018-01-29T23:56:46Z
项目社区：https://github.com/ybw2016v/arduino
开源协议：GNU General Public License v3.0
关键词：
arduino flask raspberrypi
下载


系统控制与结果查询

系统设计

设计目的

光污染是继废水、废气、废渣和噪声等污染之后的一种新的环境污染源。光污染不仅仅严重影响了人类的身体健康和其他生物的自然生活规律。除此之外，光污染还对科学探测特别是天文观测产生了严重的影响。

新《中华人民共和国环境保护法》（2015年）中第四十二条明确规定，要防治企业事业单位在生产中产生的包括光污染在内的多种污染。由此可见，我国渐渐认识到了光污染的严重危害，保护环境、治理光污染势在必行。

我们利用在单片机课程上学到的知识，用arduino单片机制作一个可以对光污染进行探测和分析的探测仪器，不仅可以帮助人们保护身体健康，践行绿色环保可持续的发展理念，而且可以在科学探测中保障探测结果的准确。

系统功能

基于arduino的光污染探测分析仪具备以下功能：

  1. 对整个空间的光强情况进行扫描，寻找出空间中光强最大的方向，也就是污染源的方向。

  2. 对于光强探测的结果，既能输出准确的数值，也能进行可视化输出。

  3. 网络查询功能：用树莓派做一个服务器，搭建一个网页，用户可以在网页上对探测器进行控制，探测器可以把扫描得到的空间中的光强分布以图片的形式发送到网页上，并且可以对光强最大的污染源拍照并且发送到网页上，方便用户查询。

主要硬件介绍

Arduino uno 开发板：

以ATmega328 MCU控制器为基础，具备14路数字输入/输出引脚(其中6路可用于PWM输出)、6路模拟输入、一个16MHz陶瓷谐振器、一个USB接口、一个电源插座、一个ICSP接头和一个复位按钮。它采用Atmega16U2芯片进行USB到串行数据的转换。它包含了组成微控制器的所有结构，同时，只需要一条USB数据线连接至电脑。目前，Arduino Uno已成为Arduino主推的产品。

1

树莓派3代B+型

这是树莓派的最新型号，主要参数chaxub如下：

  • 博通BCM2837B0 SoC，集成四核ARM Cortex-A53（ARMv8）64位@ 1.4GHz CPU，集成博通 Videocore-IV GPU

  • 内存：1GB LPDDR2 SDRAM

  • 有线网络：千兆以太网（通过USB2.0通道，最大吞吐量 300Mbps）

  • 无线网络:2.4GHz和5GHz 双频Wi-Fi，支持802.11b/g/n/ac

  • 蓝牙：蓝牙4.2&低功耗蓝牙（BLE）

  • 存储：Micro-SD

  • 其他接口：HDMI，3.5mm模拟音频视频插孔，4x USB 2.0，以太网，摄像机串行接口（CSI），显示器串行接口（DSI），MicroSD卡座，40pin扩展双排插针

  • 尺寸：82mmx 56mmx 19.5mm，50克

./pic/002.png

SG90舵机

  • 反应转速：0.12~0.13秒/60°；
  • 工作扭矩：1.6KG/CM；
  • 转动角度：180°

./pic/002.png

光强模块GY-30

通过光敏电阻的原理对光强进行探测，光强越大，电流越小。

./pic/002.png

硬件设计思路和电路图

硬件设计思路

  1. 将两个舵机按照转轴相互垂直的方向粘合起来，再把四个光强传感器组成探头粘在上方的舵机的转臂上。这样使得探头能够具有四个自由度，可以扫描整个空间。
  2. 舵机的转速通过arduino的PWM输出引脚输出PWM信号控制。、
  3. 在探头上加一个树莓派专用的摄像头，用于对光污染源拍照。将摄像头和树莓派相连，从而可以将拍到的照片通过树莓派传输的网页端。

电路图

探测器整体图

./pic/002.png

软件设计思路

软件设计

项目主要硬件可以划分为两个部分。arduino部分和raspberry pi部分。两个部分分别是不同的硬件架构。arduino是基于avr的单片机，然而，树莓派是基于arm架构的cpu。
硬件架构的不同导致主要的软件也被划分两部分，再加上显示在用户端的HTML，本项目的软件部分可以划分为三部分。

arduino部分

arduino主要负责硬件的控制与软件的采集。arduino通过串口接受来自树莓派的指令。

当arduino接收到树莓派的执行光污染源寻找指令时。arduino执行相关函数，首先通过pwm信号操纵水平方向舵机与竖直方向舵机进行转动，转动到初始位置。然后读取光强传感器阵列的数据。之后主次扫描过均匀分布的100各点。并从中找到光强最大的点，并记录位置。然后控制舵机旋转至该位置，然后传送信息至arduino。

当arduino接收到进行全角度扫描时，arduino将控制舵机转动至初始位置。然后开始对空间当中逐点扫描，每转到一个空间位置，遂及测量该点的亮度。并实时传回树莓派，直到遍历空间之中的所有点。扫描完毕之后将结束信号回传。

树莓派部分

树莓派作为整个仪器与用户之间的接口，是非常重要的。树莓派对外作为一个web服务器，负责给用户的浏览器分发内容，通过互联网接受用户指令，并根据不同指令返回用户结果或操纵单片机进行相关动作的执行。

web服务端采用nginx+uwsig+flask架构

Nginx 是一个很强大的轻量级的高性能Web和反向代理服务器。非常适合在树莓派上用于搭建小型网站。

uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。WSGI是一种Web服务器网关接口。它是一个Web服务器（如nginx，uWSGI等服务器）与web应用（如用Flask框架写的程序）通信的一种规范。uwsgi用于nginx与flask之间的通讯。

Flask是一个Python编写的Web 微框架，让我们可以使用Python语言快速实现一个网站或Web服务。flask在本项目之中可以用作动态网页服务器。用户浏览器发出的指令是由flask处理并执行。

本项目之中树莓派与arduino之间的互动是由python语言完成的。在python中导入了pyserial串口通讯模块用于与arduino通讯。还引入了numpy与matplotlib模块用于处理数据并画图。

系统技术测试

经过测试，光强探测器运行一切正常。探测器的探头可以扫描到探头上方整个空间，并且能够绘制出空间中的光强分布。如下图所示：

./pic/002.png

经过多次测试，探测器的光源寻找功能也能正常工作。能够用树莓派把拍摄到的照片传到网页上。如下所示：

./pic/002.png

我们根据探测到的光强的范围，设置了一个光强标准，光强范围为0~1000，数值越大，广强越强。

软件源代码

arduino部分

f7.h

  1. #include <Servo.h>
  2. struct pw
  3. {
  4.     int x;
  5.     int y;
  6.     float l;
  7.     struct pw * next;
  8. };
  10. struct pw * h = NULL;
  11. int a0;
  12. int a1;
  13. int b0;
  14. int b1;
  15. Servo s0;
  16. Servo s1;
  17. char com;

f7.ino

  1. #include "f7.h"
  2. void readlight();
  3. void findmaxq();
  4. void saomiao();
  5. void sf();
  6. void showlight();
  7. void setup()
  8. {
  9.     // 初始化舵机和串口
  10.     s0.attach(7);
  11.     s1.attach(8);
  12.     Serial.begin(9600);
  13. }
  14. void loop()
  15. {
  16.     if (Serial.available())
  17.     {
  18.         com=Serial.read();
  20.         switch (com)
  21.         {
  22.             case 's':
  23.                 saomiao();
  24.                 break;
  25.             case 'f':
  26.                 findmaxq();
  27.                 break;
  28.             case 'q':
  29.                 sf();
  30.                 break;
  31.             case 'l':
  32.                 showlight();
  33.                 break;
  34.             default:
  35.                 Serial.println("bad com");
  36.                 break;
  37.         }
  38.     }
  39. }
  40. void readlight()
  41. {
  42.     // 光强获取函数。
  43.     a0=analogRead(A0)-5;
  44.     a1=analogRead(A1)+5;
  45.     b0=analogRead(A2)-5;
  46.     b1=analogRead(A3)+5;
  47. }
  48. void saomiao()
  49. {
  50.     // 光强扫描函数
  51.     float l;
  52.     int i,j;
  54.     for( i = 0; i < 180; i++)
  55.     {
  57.         for( j = 0; j < 180; j++)
  58.         {
  59.             delay(10);
  60.             s0.write(i);
  61.             delay(10);
  62.             s1.write(j);
  63.             delay(5);
  64.             readlight();
  65.             l=(a0+a1+b0+b1);
  66.             Serial.print(l,2);
  67.             Serial.print(',');
  68.         }
  69.         Serial.print('\n');
  70.         delay(10);
  71.     }
  74. }
  76. void findmaxq()
  77. {
  78.     // 空间光强极值获取函数。
  79.     int flog1=0;
  80.     int flog2=0;
  81.     int i=90;
  82.     int j=90;
  83.     s0.write(i);
  84.     s1.write(j);
  85.     for(int ip = 0; ip <= 4096; ip++)
  86.     {
  87.         readlight();
  88.         delay(2);
  90.         if (a0>(a1+3))
  91.         {
  92.             // i++;
  93.             if (i<=179)
  94.             {
  95.                 i++;
  96.             }
  97.             else
  98.             {
  99.                 flog1=1;
  100.             }
  101.         }
  102.         if (a0<(a1-3))
  103.         {
  104.             // i--;
  105.             if (i>=1)
  106.             {
  107.                 i--;
  108.                 Serial.print("*");
  109.             }
  110.             else
  111.             {
  112.                 flog1=1;
  113.             }
  114.         }
  115.         if ((a0<=(a1+3))&&(a0>=(a1-3)))
  116.         {
  117.             flog1=1;
  118.         }
  119.         Serial.print(i);
  120.         Serial.print(',');
  121.         Serial.print(flog1);
  122.         Serial.print(',');
  123.         s0.write(i);
  124.         if (b0>(b1+3))
  125.         {
  126.             // j++;
  127.             if (j<=179)
  128.             {
  129.                 j++;
  130.             }
  131.             else
  132.             {
  133.                 flog2=1;
  134.             }
  135.         }
  136.         if (b0<=(b1-3))
  137.         {
  138.             // i--;
  139.             if (j>=1)
  140.             {
  141.                 j--;
  142.             }
  143.             else
  144.             {
  145.                 flog2=1;
  146.             }
  147.         }
  148.         if (b0<=(b1+3)&&b0>=(b1-3))
  149.         {
  150.             flog2=1;
  151.         }
  152.         Serial.print(flog2);
  153.         Serial.print(',');
  154.         Serial.println(j);
  155.         s1.write(j);
  156.         if (flog1==1&&flog2==1)
  157.         {
  158.             Serial.println('p');
  159.             Serial.print(i);
  160.             Serial.print(',');
  161.             Serial.print(j);
  162.             break;
  163.         }
  164.     }
  165. }
  166. void sf()
  167. {
  168.     // 光强极大值扫描函数
  169.     float l,ml;
  170.     int i,j;
  171.     int mx,my;
  172.     ml=100000;
  173.     mx=0;
  174.     my=0;
  175.     for( i = 0; i <= 180; i=i+10)
  176.     {
  178.         for( j = 0; j < 180; j=j+10)
  179.         {
  180.             delay(10);
  181.             s0.write(i);
  182.             delay(10);
  183.             s1.write(j);
  184.             delay(100);
  185.             readlight();
  186.             l=(a0+a1+b0+b1);
  187.             // Serial.print(l,2);
  188.             // Serial.print(',');
  189.             if (ml>=l)
  190.             {
  191.                 ml=l;
  192.                 mx=i;
  193.                 my=j;
  194.             }
  195.         }
  196.         // Serial.print('\n');
  197.         delay(10);
  198.     }
  199.     delay(1000);
  200.     s0.write(mx);
  201.     s1.write(my);
  202.     delay(20);
  203.     Serial.println('p');
  206. }
  207. void showlight()
  208. {
  209.     float l;
  210.     readlight();
  211.     delay(10);
  212.     l=a0+a1+b0+b1;
  213.     Serial.println(l);
  214.     delay(2);
  215. }

树莓派部分

ardlib.py

单片机操纵模块

  1. #!/usr/bin/env python3
  2. import serial
  3. import numpy as np
  4. import os
  5. import time
  6. import datetime
  7. import shutil
  8. import matplotlib
  9. matplotlib.use("Pdf")
  10. import matplotlib.pyplot as plt
  12. class ard(object):
  13. #面向对象的编程语言
  14.     def __init__(self):#初始化函数
  15.         self.ser=serial.Serial('/dev/ttyUSB0', 9600)
  16.         time.sleep(1)
  17.         sser=self.ser
  18.         try:
  19.             sser.open()
  20.         except:
  21.             pass
  22.     def saomiao(self):#扫描函数
  23.         nmp=np.zeros([180,180])
  24.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  25.         sser=self.ser
  26.         sser.write('s'.encode())
  27.         sser.flushInput()
  28.         for i in range(0,180):
  29.             time.sleep(1)
  30.             shi = str(sser.readline())
  31.             shi=shi[2:len(shi)-5]
  32.             shi=shi.strip()
  33.             shi=shi.split(',')
  34.             nmp[i,:]=np.array(shi)
  35.             pass
  36.         p=os.path.abspath('.')
  37.         ba=os.popen('mkdir '+p+'/static/res2/'+self.nowTime)
  38.         time.sleep(0.001)
  39.         plt.figure(dpi=500)
  40.         plt.imshow(nmp)
  41.         plt.title('space')
  42.         plt.colorbar()
  43.         plt.savefig('data.jpg')
  44.         b=os.popen('cp data.jpg '+p+'/static/res2/'+self.nowTime)
  45.         shutil.copyfile('./static/res2.html','./static/res2/'+self.nowTime+r'/res.html')
  48.     def qfm(self):#光强最大值寻找函数
  49.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  50.         sser=self.ser
  51.         time.sleep(1)
  52.         sser.write(b'q')
  53.         self.takephoto()
  54.         p=os.path.abspath('.')
  55.         print(p)
  56.         p2=os.path.join(p,'/static/res1/'+self.nowTime+r'/res1.html')
  58.         b=os.popen('mkdir '+p+'/static/res1/'+self.nowTime)
  59.         time.sleep(0.001)
  60.         a=os.popen('touch '+p+p2)
  61.         print(b)
  62.         print(a)
  63.         print(p+p2)
  64.         with open(p+p2,'w') as f:
  65.             f.write('dog\n'+self.nowTime)
  66.             shutil.copyfile('./static/res1.html','./static/res1/'+self.nowTime+r'/res.html')
  67.     def takephoto(self):#拍照函数
  68.         timedog=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
  69.         str = os.popen("echo takephoto"+timedog).read()
  70.         print(str)
  71.         pass
  72.     def test(self):
  73.         print("OK")
  74.         pass
  76.     pass

testlib.py

测试模块

  1. mport time
  2. import datetime
  3. import os
  4. import shutil
  6. class testlib(object):
  7.     def __init__(self):
  8.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  9.         pass
  10.     def tes1(self):
  11.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  12.         print("开始执行全域扫描")
  13.         p=os.path.abspath('.')
  14.         print(p)
  15.         p2=os.path.join(p,'/static/res1/'+self.nowTime+r'/res1.html')
  16.         # os.mkdir(os.path.join(p,'/static/res1/'+self.nowTime))
  17.         b=os.popen('mkdir '+p+'/static/res1/'+self.nowTime)
  18.         time.sleep(0.001)
  19.         a=os.popen('touch '+p+p2)
  20.         print(b)
  21.         print(a)
  22.         print(p+p2)
  23.         with open(p+p2,'w') as f:
  24.             f.write('dog\n'+self.nowTime)
  25.             shutil.copyfile('./static/res1.html','./static/res1/'+self.nowTime+r'/res.html')
  27.     def tes2(self):
  28.         print("开始寻找光污染源")
  29.         pass
  30.     def test3(self):
  31.         return self.nowTime
  32.     pass

fweb.py

互联网模块

  2. import numpy as np
  3. from flask import (Flask, abort, flash, redirect, render_template, request,
  4.                    url_for)
  5. import datetime
  6. from ardlib import *
  7. from testlib import *
  8. import json
  9. import os
  11. app = Flask(__name__)
  13. @app.route('/')
  14. def hello_world():
  15.     nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  16.     a=[]
  17.     a.append(nowTime)
  18.     a.append("you are a dog")
  19.     return render_template('test.html',time=a)
  21. @app.route('/fweb',methods=['GET', 'POST'])
  22. def fweb():
  23.     if request.method == 'POST':
  24.         s.tes1()
  25.     else:
  26.         abort(403)
  28.     # s=ard()
  30.     # s.qfm()
  31.     # abort(401)
  32.     return "dog"
  34. @app.route('/test1/',methods=['GET', 'POST'])
  35. def test1():
  36.     if request.method == 'POST':
  37.         print("666")
  38.         s.tes1()
  39.         return redirect(url_for('hello_world'))
  40.     else:
  41.         abort(403)
  43. @app.route('/test2/',methods=['GET', 'POST'])
  44. def test2():
  45.     if request.method == 'POST':
  46.         s.tes2()
  47.     else:
  48.         abort(403)
  49.     pass
  52. @app.route('/real1',methods=['GET','POST'])
  53. def real1():
  54.     if request.method == 'POST':
  55.         ss=ard()
  56.         a=ss.qfm()
  57.         return redirect(url_for('hello_world'))
  58.     else:
  59.         abort(403)
  61. @app.route('/real2',methods=['GET','POST'])
  62. def real2():
  63.     if request.method == 'POST':
  64.         ss=ard()
  65.         time.sleep(1)
  66.         a=ss.saomiao()
  67.         return redirect(url_for('hello_world'))
  68.     else:
  69.         abort(403)
  71. @app.route('/res1')
  72. def res1():
  73.     a=os.listdir('./static/res1/')
  74.     bu=sorted(a,reverse = True)
  75.     return render_template('result.html',urls=bu)
  77. @app.route('/res2')
  78. def res2():
  79.     a=os.listdir('./static/res2/')
  80.     bu=sorted(a,reverse = True)
  81.     return render_template('result2.html',urls=bu)
  83. if __name__ == '__main__':
  84.     app.run(debug=True,host='0.0.0.0')

HTML部分

result.html

结果显示模块

  1. <!DOCTYPE html>
  2. 光强测试结果
  3. <ul>
  4.     {% for url in urls %}
  5.     <li>{{url}}</li><a href="/static/res1/{{url}}/res1.html">{{url}}</a>
  6.     {% endfor %}
  7. </ul>
  1. <!DOCTYPE html>
  2. 全域扫描结果
  3. <ul>
  4.     {% for url in urls %}
  5.     <li>{{url}}</li><a href="/static/res2/{{url}}/res.html">{{url}}</a>
  6.     {% endfor %}
  7. </ul>

test.html

测试页

  1. <!DOCTYPE html>
  2. <!-- <form>
  3.     First name: <input type="text" name="firstname"><br>
  4.     Last name: <input type="text" name="lastname">
  5. </form>
  7. <form name="input" action="/fweb" method="post">
  8.     Username: <input type="text" name="user">
  9.     <input type="submit" value="Submit">
  10. </form>
  12. <title>My Application</title>
  13. {% with messages = get_flashed_messages() %}
  14.   {% if messages %}
  15.     <ul class=flashes>
  16.     {% for message in messages %}
  17.       <li>{{ message }}</li>
  18.     {% endfor %}
  19.     </ul>
  20.   {% endif %}
  21. {% endwith %}
  22. {% block body %}{% endblock %} -->
  25. <html>
  26. <!-- <head> 
  27. <meta charset="utf-8"> 
  28. <title>菜鸟教程(runoob.com)</title> 
  29. </head> -->
  30. <body>
  32. <form action="/test1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  33. <input type="button" value="开始光强测试">
  34.     </form>
  36. </body>
  37. </html>
  39. <button type="button" action="/fweb" method="post" onclick="alert('你好，世界!')">点我!</button>
  42. <form name="input" action="/test1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  43.   <input type="submit" value="Submit">
  44. </form>
  46. <form name="input" action="/real1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  47.   <input type="submit" value="光源寻找">
  48. </form>
  49. <form name="input" action="/real2" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  50.   <input type="submit" value="全域扫描">
  51. </form>
  52. <a href="/res1">光源寻找结果</a>
  54. <br>
  56. <a href="/res2">全域扫描结果</a>

index.html

主页

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <head>
  4.         <meta charset="utf-8">
  5.         <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6.         <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.         <meta name="description" content="None">
  10.         <link rel="shortcut icon" href="./img/favicon.ico">
  11.         <title>光强传感器</title>
  12.         <link href="./css/bootstrap-custom.min.css" rel="stylesheet">
  13.         <link href="./css/font-awesome-4.5.0.css" rel="stylesheet">
  14.         <link href="./css/base.css" rel="stylesheet">
  15.         <link rel="stylesheet" href="./css/highlight.css">
  16.         <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
  17.         <!--[if lt IE 9]>
  18.             <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
  19.             <script src="https://oss.maxcdn.com/libs/respond.js/1.3.0/respond.min.js"></script>
  20.         <![endif]-->
  22.         <script src="./js/jquery-1.10.2.min.js"></script>
  23.         <script src="./js/bootstrap-3.0.3.min.js"></script>
  24.         <script src="./js/highlight.pack.js"></script>
  25.     </head>
  27.     <body class="homepage">
  29.         <div class="navbar navbar-default navbar-fixed-top" role="navigation">
  30.     <div class="container">
  32.         <!-- Collapsed navigation -->
  33.         <div class="navbar-header">
  34.             <a class="navbar-brand" href=".">光强传感器</a>
  35.         </div>
  37.         <!-- Expanded navigation -->
  38.         <div class="navbar-collapse collapse">
  40.             <ul class="nav navbar-nav navbar-right">
  41.                 <li>
  42.                     <a href="#" data-toggle="modal" data-target="#mkdocs_search_modal">
  43.                         <i class="fa fa-search"></i> Search
  44.                     </a>
  45.                 </li>
  46.             </ul>
  47.         </div>
  48.     </div>
  49. </div>
  51.         <div class="container">
  52.                 <div class="col-md-3"><div class="bs-sidebar hidden-print affix well" role="complementary">
  53.     <ul class="nav bs-sidenav">
  54.         <li class="main active"><a href="#_1">系统控制与结果查询</a></li>
  55.         <li class="main "><a href="#_2">系统设计</a></li>
  56.             <li><a href="#_3">设计目的</a></li>
  57.         <li class="main "><a href="#_4">系统功能</a></li>
  58.         <li class="main "><a href="#_5">主要硬件介绍</a></li>
  59.             <li><a href="#arduino-uno">Arduino uno 开发板：</a></li>
  60.             <li><a href="#3b">树莓派3代B+型</a></li>
  61.             <li><a href="#sg90">SG90舵机</a></li>
  62.             <li><a href="#gy-30">光强模块GY-30</a></li>
  63.         <li class="main "><a href="#_6">硬件设计思路和电路图</a></li>
  64.             <li><a href="#_7">硬件设计思路</a></li>
  65.             <li><a href="#_8">电路图</a></li>
  66.             <li><a href="#_9">探测器整体图</a></li>
  67.         <li class="main "><a href="#_10">软件设计思路</a></li>
  68.             <li><a href="#_11">软件设计</a></li>
  69.         <li class="main "><a href="#_13">系统技术测试</a></li>
  70.         <li class="main "><a href="#_14">软件源代码</a></li>
  71.             <li><a href="#arduino_1">arduino部分</a></li>
  72.             <li><a href="#_15">树莓派部分</a></li>
  73.             <li><a href="#html">HTML部分</a></li>
  74.     </ul>
  75. </div></div>
  76.                 <div class="col-md-9" role="main">
  78. <h1 id="_1">系统控制与结果查询</h1>
  80. <form name="input" action="/real1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  81.   <input type="submit" value="光源寻找">
  82. </form>
  83. <form name="input" action="/real2" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  84.   <input type="submit" value="全域扫描">
  85. </form>
  86. <a href="/res1">光源寻找结果</a>
  88. <br>
  90. <a href="/res2">全域扫描结果</a>
  93. <h1 id="_2">系统设计</h1>
  94. <h2 id="_3">设计目的</h2>
  95. <p>光污染是继废水、废气、废渣和噪声等污染之后的一种新的环境污染源。光污染不仅仅严重影响了人类的身体健康和其他生物的自然生活规律。除此之外，光污染还对科学探测特别是天文观测产生了严重的影响。</p>
  96. <p>新《中华人民共和国环境保护法》（2015年）中第四十二条明确规定，要防治企业事业单位在生产中产生的包括光污染在内的多种污染。由此可见，我国渐渐认识到了光污染的严重危害，保护环境、治理光污染势在必行。</p>
  97. <p>我们利用在单片机课程上学到的知识，用arduino单片机制作一个可以对光污染进行探测和分析的探测仪器，不仅可以帮助人们保护身体健康，践行绿色环保可持续的发展理念，而且可以在科学探测中保障探测结果的准确。</p>
  98. <h1 id="_4">系统功能</h1>
  99. <p>基于arduino的光污染探测分析仪具备以下功能：</p>
  100. <ol>
  101. <li>
  102. <p>对整个空间的光强情况进行扫描，寻找出空间中光强最大的方向，也就是污染源的方向。</p>
  103. </li>
  104. <li>
  105. <p>对于光强探测的结果，既能输出准确的数值，也能进行可视化输出。</p>
  106. </li>
  107. <li>
  108. <p>网络查询功能：用树莓派做一个服务器，搭建一个网页，用户可以在网页上对探测器进行控制，探测器可以把扫描得到的空间中的光强分布以图片的形式发送到网页上，并且可以对光强最大的污染源拍照并且发送到网页上，方便用户查询。</p>
  109. </li>
  110. </ol>
  111. <h1 id="_5">主要硬件介绍</h1>
  112. <h2 id="arduino-uno">Arduino uno 开发板：</h2>
  113. <p>以ATmega328 MCU控制器为基础，具备14路数字输入/输出引脚(其中6路可用于PWM输出)、6路模拟输入、一个16MHz陶瓷谐振器、一个USB接口、一个电源插座、一个ICSP接头和一个复位按钮。它采用Atmega16U2芯片进行USB到串行数据的转换。它包含了组成微控制器的所有结构，同时，只需要一条USB数据线连接至电脑。目前，Arduino Uno已成为Arduino主推的产品。</p>
  114. <p><img alt="1" src="./pic/001.png" /></p>
  115. <h2 id="3b">树莓派3代B+型</h2>
  116. <p>这是树莓派的最新型号，主要参数chaxub如下：</p>
  117. <ul>
  118. <li>
  119. <p>博通BCM2837B0 SoC，集成四核ARM Cortex-A53（ARMv8）64位@ 1.4GHz CPU，集成博通 Videocore-IV GPU</p>
  120. </li>
  121. <li>
  122. <p>内存：1GB LPDDR2 SDRAM</p>
  123. </li>
  124. <li>
  125. <p>有线网络：千兆以太网（通过USB2.0通道，最大吞吐量 300Mbps）</p>
  126. </li>
  127. <li>
  128. <p>无线网络:2.4GHz和5GHz 双频Wi-Fi，支持802.11b/g/n/ac</p>
  129. </li>
  130. <li>
  131. <p>蓝牙：蓝牙4.2&低功耗蓝牙（BLE）</p>
  132. </li>
  133. <li>
  134. <p>存储：Micro-SD</p>
  135. </li>
  136. <li>
  137. <p>其他接口：HDMI，3.5mm模拟音频视频插孔，4x USB 2.0，以太网，摄像机串行接口（CSI），显示器串行接口（DSI），MicroSD卡座，40pin扩展双排插针</p>
  138. </li>
  139. <li>
  140. <p>尺寸：82mmx 56mmx 19.5mm，50克</p>
  141. </li>
  142. </ul>
  143. <p><img alt="./pic/002.png" src="./pic/002.png" /></p>
  144. <h2 id="sg90">SG90舵机</h2>
  145. <ul>
  146. <li>反应转速：0.12~0.13秒/60°；</li>
  147. <li>工作扭矩：1.6KG/CM；</li>
  148. <li>转动角度：180°</li>
  149. </ul>
  150. <p><img alt="./pic/002.png" src="./pic/007.png" /></p>
  151. <h2 id="gy-30">光强模块GY-30</h2>
  152. <p>通过光敏电阻的原理对光强进行探测，光强越大，电流越小。</p>
  153. <p><img alt="./pic/002.png" src="./pic/003.png" /></p>
  154. <h1 id="_6">硬件设计思路和电路图</h1>
  155. <h2 id="_7">硬件设计思路</h2>
  156. <ol>
  157. <li>将两个舵机按照转轴相互垂直的方向粘合起来，再把四个光强传感器组成探头粘在上方的舵机的转臂上。这样使得探头能够具有四个自由度，可以扫描整个空间。</li>
  158. <li>舵机的转速通过arduino的PWM输出引脚输出PWM信号控制。、</li>
  159. <li>在探头上加一个树莓派专用的摄像头，用于对光污染源拍照。将摄像头和树莓派相连，从而可以将拍到的照片通过树莓派传输的网页端。</li>
  160. </ol>
  161. <h2 id="_8">电路图</h2>
  162. <h2 id="_9">探测器整体图</h2>
  163. <p><img alt="./pic/002.png" src="./pic/004.png" /></p>
  164. <h1 id="_10">软件设计思路</h1>
  165. <h2 id="_11">软件设计</h2>
  166. <p>项目主要硬件可以划分为两个部分。arduino部分和raspberry pi部分。两个部分分别是不同的硬件架构。arduino是基于avr的单片机，然而，树莓派是基于arm架构的cpu。
  167. 硬件架构的不同导致主要的软件也被划分两部分，再加上显示在用户端的HTML，本项目的软件部分可以划分为三部分。</p>
  168. <h3 id="arduino">arduino部分</h3>
  169. <p>arduino主要负责硬件的控制与软件的采集。arduino通过串口接受来自树莓派的指令。</p>
  170. <p>当arduino接收到树莓派的执行光污染源寻找指令时。arduino执行相关函数，首先通过pwm信号操纵水平方向舵机与竖直方向舵机进行转动，转动到初始位置。然后读取光强传感器阵列的数据。之后主次扫描过均匀分布的100各点。并从中找到光强最大的点，并记录位置。然后控制舵机旋转至该位置，然后传送信息至arduino。</p>
  171. <p>当arduino接收到进行全角度扫描时，arduino将控制舵机转动至初始位置。然后开始对空间当中逐点扫描，每转到一个空间位置，遂及测量该点的亮度。并实时传回树莓派，直到遍历空间之中的所有点。扫描完毕之后将结束信号回传。</p>
  172. <h3 id="_12">树莓派部分</h3>
  173. <p>树莓派作为整个仪器与用户之间的接口，是非常重要的。树莓派对外作为一个web服务器，负责给用户的浏览器分发内容，通过互联网接受用户指令，并根据不同指令返回用户结果或操纵单片机进行相关动作的执行。</p>
  174. <h4 id="webnginxuwsigflask">web服务端采用nginx+uwsig+flask架构</h4>
  175. <p>Nginx 是一个很强大的轻量级的高性能Web和反向代理服务器。非常适合在树莓派上用于搭建小型网站。</p>
  176. <p>uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。WSGI是一种Web服务器网关接口。它是一个Web服务器（如nginx，uWSGI等服务器）与web应用（如用Flask框架写的程序）通信的一种规范。uwsgi用于nginx与flask之间的通讯。</p>
  177. <p>Flask是一个Python编写的Web 微框架，让我们可以使用Python语言快速实现一个网站或Web服务。flask在本项目之中可以用作动态网页服务器。用户浏览器发出的指令是由flask处理并执行。</p>
  178. <p>本项目之中树莓派与arduino之间的互动是由python语言完成的。在python中导入了pyserial串口通讯模块用于与arduino通讯。还引入了numpy与matplotlib模块用于处理数据并画图。</p>
  179. <h1 id="_13">系统技术测试</h1>
  180. <p>经过测试，光强探测器运行一切正常。探测器的探头可以扫描到探头上方整个空间，并且能够绘制出空间中的光强分布。如下图所示：</p>
  181. <p><img alt="./pic/002.png" src="./pic/005.png" /></p>
  182. <p>经过多次测试，探测器的光源寻找功能也能正常工作。能够用树莓派把拍摄到的照片传到网页上。如下所示：</p>
  183. <p><img alt="./pic/002.png" src="./pic/008.png" /></p>
  184. <p>我们根据探测到的光强的范围，设置了一个光强标准，光强范围为0~1000，数值越大，广强越强。</p>
  185. <h1 id="_14">软件源代码</h1>
  186. <h2 id="arduino_1">arduino部分</h2>
  187. <h3 id="f7h">f7.h</h3>
  188. <pre><code class="C">#include <Servo.h>
  189. struct pw
  190. {
  191.     int x;
  192.     int y;
  193.     float l;
  194.     struct pw * next;
  195. };
  197. struct pw * h = NULL;
  198. int a0;
  199. int a1;
  200. int b0;
  201. int b1;
  202. Servo s0;
  203. Servo s1;
  204. char com;
  205. </code></pre>
  207. <h3 id="f7ino">f7.ino</h3>
  208. <pre><code class="C">#include "f7.h"
  209. void readlight();
  210. void findmaxq();
  211. void saomiao();
  212. void sf();
  213. void showlight();
  214. void setup()
  215. {
  216.     // 初始化舵机和串口
  217.     s0.attach(7);
  218.     s1.attach(8);
  219.     Serial.begin(9600);
  220. }
  221. void loop()
  222. {
  223.     if (Serial.available())
  224.     {
  225.         com=Serial.read();
  227.         switch (com)
  228.         {
  229.             case 's':
  230.                 saomiao();
  231.                 break;
  232.             case 'f':
  233.                 findmaxq();
  234.                 break;
  235.             case 'q':
  236.                 sf();
  237.                 break;
  238.             case 'l':
  239.                 showlight();
  240.                 break;
  241.             default:
  242.                 Serial.println("bad com");
  243.                 break;
  244.         }
  245.     }
  246. }
  247. void readlight()
  248. {
  249.     // 光强获取函数。
  250.     a0=analogRead(A0)-5;
  251.     a1=analogRead(A1)+5;
  252.     b0=analogRead(A2)-5;
  253.     b1=analogRead(A3)+5;
  254. }
  255. void saomiao()
  256. {
  257.     // 光强扫描函数
  258.     float l;
  259.     int i,j;
  261.     for( i = 0; i < 180; i++)
  262.     {
  264.         for( j = 0; j < 180; j++)
  265.         {
  266.             delay(10);
  267.             s0.write(i);
  268.             delay(10);
  269.             s1.write(j);
  270.             delay(5);
  271.             readlight();
  272.             l=(a0+a1+b0+b1);
  273.             Serial.print(l,2);
  274.             Serial.print(',');
  275.         }
  276.         Serial.print('\n');
  277.         delay(10);
  278.     }
  281. }
  283. void findmaxq()
  284. {
  285.     // 空间光强极值获取函数。
  286.     int flog1=0;
  287.     int flog2=0;
  288.     int i=90;
  289.     int j=90;
  290.     s0.write(i);
  291.     s1.write(j);
  292.     for(int ip = 0; ip <= 4096; ip++)
  293.     {
  294.         readlight();
  295.         delay(2);
  297.         if (a0>(a1+3))
  298.         {
  299.             // i++;
  300.             if (i<=179)
  301.             {
  302.                 i++;
  303.             }
  304.             else
  305.             {
  306.                 flog1=1;
  307.             }
  308.         }
  309.         if (a0<(a1-3))
  310.         {
  311.             // i--;
  312.             if (i>=1)
  313.             {
  314.                 i--;
  315.                 Serial.print("*");
  316.             }
  317.             else
  318.             {
  319.                 flog1=1;
  320.             }
  321.         }
  322.         if ((a0<=(a1+3))&&(a0>=(a1-3)))
  323.         {
  324.             flog1=1;
  325.         }
  326.         Serial.print(i);
  327.         Serial.print(',');
  328.         Serial.print(flog1);
  329.         Serial.print(',');
  330.         s0.write(i);
  331.         if (b0>(b1+3))
  332.         {
  333.             // j++;
  334.             if (j<=179)
  335.             {
  336.                 j++;
  337.             }
  338.             else
  339.             {
  340.                 flog2=1;
  341.             }
  342.         }
  343.         if (b0<=(b1-3))
  344.         {
  345.             // i--;
  346.             if (j>=1)
  347.             {
  348.                 j--;
  349.             }
  350.             else
  351.             {
  352.                 flog2=1;
  353.             }
  354.         }
  355.         if (b0<=(b1+3)&&b0>=(b1-3))
  356.         {
  357.             flog2=1;
  358.         }
  359.         Serial.print(flog2);
  360.         Serial.print(',');
  361.         Serial.println(j);
  362.         s1.write(j);
  363.         if (flog1==1&&flog2==1)
  364.         {
  365.             Serial.println('p');
  366.             Serial.print(i);
  367.             Serial.print(',');
  368.             Serial.print(j);
  369.             break;
  370.         }
  371.     }
  372. }
  373. void sf()
  374. {
  375.     // 光强极大值扫描函数
  376.     float l,ml;
  377.     int i,j;
  378.     int mx,my;
  379.     ml=100000;
  380.     mx=0;
  381.     my=0;
  382.     for( i = 0; i <= 180; i=i+10)
  383.     {
  385.         for( j = 0; j < 180; j=j+10)
  386.         {
  387.             delay(10);
  388.             s0.write(i);
  389.             delay(10);
  390.             s1.write(j);
  391.             delay(100);
  392.             readlight();
  393.             l=(a0+a1+b0+b1);
  394.             // Serial.print(l,2);
  395.             // Serial.print(',');
  396.             if (ml>=l)
  397.             {
  398.                 ml=l;
  399.                 mx=i;
  400.                 my=j;
  401.             }
  402.         }
  403.         // Serial.print('\n');
  404.         delay(10);
  405.     }
  406.     delay(1000);
  407.     s0.write(mx);
  408.     s1.write(my);
  409.     delay(20);
  410.     Serial.println('p');
  413. }
  414. void showlight()
  415. {
  416.     float l;
  417.     readlight();
  418.     delay(10);
  419.     l=a0+a1+b0+b1;
  420.     Serial.println(l);
  421.     delay(2);
  422. }
  424. </code></pre>
  426. <h2 id="_15">树莓派部分</h2>
  427. <h3 id="ardlibpy">ardlib.py</h3>
  428. <p>单片机操纵模块</p>
  429. <pre><code class="python">#!/usr/bin/env python3
  430. import serial
  431. import numpy as np
  432. import os
  433. import time
  434. import datetime
  435. import shutil
  436. import matplotlib
  437. matplotlib.use("Pdf")
  438. import matplotlib.pyplot as plt
  440. class ard(object):
  441. #面向对象的编程语言
  442.     def __init__(self):#初始化函数
  443.         self.ser=serial.Serial('/dev/ttyUSB0', 9600)
  444.         time.sleep(1)
  445.         sser=self.ser
  446.         try:
  447.             sser.open()
  448.         except:
  449.             pass
  450.     def saomiao(self):#扫描函数
  451.         nmp=np.zeros([180,180])
  452.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  453.         sser=self.ser
  454.         sser.write('s'.encode())
  455.         sser.flushInput()
  456.         for i in range(0,180):
  457.             time.sleep(1)
  458.             shi = str(sser.readline())
  459.             shi=shi[2:len(shi)-5]
  460.             shi=shi.strip()
  461.             shi=shi.split(',')
  462.             nmp[i,:]=np.array(shi)
  463.             pass
  464.         p=os.path.abspath('.')
  465.         ba=os.popen('mkdir '+p+'/static/res2/'+self.nowTime)
  466.         time.sleep(0.001)
  467.         plt.figure(dpi=500)
  468.         plt.imshow(nmp)
  469.         plt.title('space')
  470.         plt.colorbar()
  471.         plt.savefig('data.jpg')
  472.         b=os.popen('cp data.jpg '+p+'/static/res2/'+self.nowTime)
  473.         shutil.copyfile('./static/res2.html','./static/res2/'+self.nowTime+r'/res.html')
  476.     def qfm(self):#光强最大值寻找函数
  477.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  478.         sser=self.ser
  479.         time.sleep(1)
  480.         sser.write(b'q')
  481.         self.takephoto()
  482.         p=os.path.abspath('.')
  483.         print(p)
  484.         p2=os.path.join(p,'/static/res1/'+self.nowTime+r'/res1.html')
  486.         b=os.popen('mkdir '+p+'/static/res1/'+self.nowTime)
  487.         time.sleep(0.001)
  488.         a=os.popen('touch '+p+p2)
  489.         print(b)
  490.         print(a)
  491.         print(p+p2)
  492.         with open(p+p2,'w') as f:
  493.             f.write('dog\n'+self.nowTime)
  494.             shutil.copyfile('./static/res1.html','./static/res1/'+self.nowTime+r'/res.html')
  495.     def takephoto(self):#拍照函数
  496.         timedog=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
  497.         str = os.popen("echo takephoto"+timedog).read()
  498.         print(str)
  499.         pass
  500.     def test(self):
  501.         print("OK")
  502.         pass
  504.     pass
  506. </code></pre>
  508. <h3 id="testlibpy">testlib.py</h3>
  509. <p>测试模块</p>
  510. <pre><code class="python">mport time
  511. import datetime
  512. import os
  513. import shutil
  515. class testlib(object):
  516.     def __init__(self):
  517.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  518.         pass
  519.     def tes1(self):
  520.         self.nowTime=str(datetime.datetime.now().strftime('%Y%m%d%H%M%S'))
  521.         print("开始执行全域扫描")
  522.         p=os.path.abspath('.')
  523.         print(p)
  524.         p2=os.path.join(p,'/static/res1/'+self.nowTime+r'/res1.html')
  525.         # os.mkdir(os.path.join(p,'/static/res1/'+self.nowTime))
  526.         b=os.popen('mkdir '+p+'/static/res1/'+self.nowTime)
  527.         time.sleep(0.001)
  528.         a=os.popen('touch '+p+p2)
  529.         print(b)
  530.         print(a)
  531.         print(p+p2)
  532.         with open(p+p2,'w') as f:
  533.             f.write('dog\n'+self.nowTime)
  534.             shutil.copyfile('./static/res1.html','./static/res1/'+self.nowTime+r'/res.html')
  536.     def tes2(self):
  537.         print("开始寻找光污染源")
  538.         pass
  539.     def test3(self):
  540.         return self.nowTime
  541.     pass
  543. </code></pre>
  545. <h3 id="fwebpy">fweb.py</h3>
  546. <p>互联网模块</p>
  547. <pre><code class="python">
  548. import numpy as np
  549. from flask import (Flask, abort, flash, redirect, render_template, request,
  550.                    url_for)
  551. import datetime
  552. from ardlib import *
  553. from testlib import *
  554. import json
  555. import os
  557. app = Flask(__name__)
  559. @app.route('/')
  560. def hello_world():
  561.     nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  562.     a=[]
  563.     a.append(nowTime)
  564.     a.append("you are a dog")
  565.     return render_template('test.html',time=a)
  567. @app.route('/fweb',methods=['GET', 'POST'])
  568. def fweb():
  569.     if request.method == 'POST':
  570.         s.tes1()
  571.     else:
  572.         abort(403)
  574.     # s=ard()
  576.     # s.qfm()
  577.     # abort(401)
  578.     return "dog"
  580. @app.route('/test1/',methods=['GET', 'POST'])
  581. def test1():
  582.     if request.method == 'POST':
  583.         print("666")
  584.         s.tes1()
  585.         return redirect(url_for('hello_world'))
  586.     else:
  587.         abort(403)
  589. @app.route('/test2/',methods=['GET', 'POST'])
  590. def test2():
  591.     if request.method == 'POST':
  592.         s.tes2()
  593.     else:
  594.         abort(403)
  595.     pass
  598. @app.route('/real1',methods=['GET','POST'])
  599. def real1():
  600.     if request.method == 'POST':
  601.         ss=ard()
  602.         a=ss.qfm()
  603.         return redirect(url_for('hello_world'))
  604.     else:
  605.         abort(403)
  607. @app.route('/real2',methods=['GET','POST'])
  608. def real2():
  609.     if request.method == 'POST':
  610.         ss=ard()
  611.         time.sleep(1)
  612.         a=ss.saomiao()
  613.         return redirect(url_for('hello_world'))
  614.     else:
  615.         abort(403)
  617. @app.route('/res1')
  618. def res1():
  619.     a=os.listdir('./static/res1/')
  620.     bu=sorted(a,reverse = True)
  621.     return render_template('result.html',urls=bu)
  623. @app.route('/res2')
  624. def res2():
  625.     a=os.listdir('./static/res2/')
  626.     bu=sorted(a,reverse = True)
  627.     return render_template('result2.html',urls=bu)
  629. if __name__ == '__main__':
  630.     app.run(debug=True,host='0.0.0.0')
  631. </code></pre>
  633. <h2 id="html">HTML部分</h2>
  634. <h3 id="resulthtml">result.html</h3>
  635. <p>结果显示模块</p>
  636. <pre><code class="html"><!DOCTYPE html>
  637. 光强测试结果
  638. <ul>
  639.     {% for url in urls %}
  640.     <li>{{url}}</li><a href="/static/res1/{{url}}/res1.html">{{url}}</a>
  641.     {% endfor %}
  642. </ul>
  644. </code></pre>
  646. <pre><code class="html"><!DOCTYPE html>
  647. 全域扫描结果
  648. <ul>
  649.     {% for url in urls %}
  650.     <li>{{url}}</li><a href="/static/res2/{{url}}/res.html">{{url}}</a>
  651.     {% endfor %}
  652. </ul>
  654. </code></pre>
  656. <h3 id="testhtml">test.html</h3>
  657. <p>测试页</p>
  658. <pre><code class="html"><!DOCTYPE html>
  659. <!-- <form>
  660.     First name: <input type="text" name="firstname"><br>
  661.     Last name: <input type="text" name="lastname">
  662. </form>
  664. <form name="input" action="/fweb" method="post">
  665.     Username: <input type="text" name="user">
  666.     <input type="submit" value="Submit">
  667. </form>
  669. <title>My Application</title>
  670. {% with messages = get_flashed_messages() %}
  671.   {% if messages %}
  672.     <ul class=flashes>
  673.     {% for message in messages %}
  674.       <li>{{ message }}</li>
  675.     {% endfor %}
  676.     </ul>
  677.   {% endif %}
  678. {% endwith %}
  679. {% block body %}{% endblock %} -->
  682. <html>
  683. <!-- <head> 
  684. <meta charset="utf-8"> 
  685. <title>菜鸟教程(runoob.com)</title> 
  686. </head> -->
  687. <body>
  689. <form action="/test1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  690. <input type="button" value="开始光强测试">
  691.     </form>
  693. </body>
  694. </html>
  696. <button type="button" action="/fweb" method="post" onclick="alert('你好，世界!')">点我!</button>
  699. <form name="input" action="/test1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  700.   <input type="submit" value="Submit">
  701. </form>
  703. <form name="input" action="/real1" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  704.   <input type="submit" value="光源寻找">
  705. </form>
  706. <form name="input" action="/real2" method="post" onclick="alert('光强测试请求已受理，请稍后查看结果。')">
  707.   <input type="submit" value="全域扫描">
  708. </form>
  709. <a href="/res1">光源寻找结果</a>
  711. <br>
  713. <a href="/res2">全域扫描结果</a>
  715. </code></pre></div>
  716.         </div>
  718.         <footer class="col-md-12">
  719.             <hr>
  720.             <p>Documentation built with <a href="http://www.mkdocs.org/">MkDocs</a>.</p>
  721.         </footer>
  722.         <script>var base_url = '.';</script>
  723.         <script src="./js/base.js"></script>
  724.         <script src="./search/require.js"></script>
  725.         <script src="./search/search.js"></script>
  727.         <div class="modal" id="mkdocs_search_modal" tabindex="-1" role="dialog" aria-labelledby="Search Modal" aria-hidden="true">
  728.     <div class="modal-dialog">
  729.         <div class="modal-content">
  730.             <div class="modal-header">
  731.                 <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">×</span><span class="sr-only">Close</span></button>
  732.                 <h4 class="modal-title" id="exampleModalLabel">Search</h4>
  733.             </div>
  734.             <div class="modal-body">
  735.                 <p>
  736.                     From here you can search these documents. Enter
  737.                     your search terms below.
  738.                 </p>
  739.                 <form role="form">
  740.                     <div class="form-group">
  741.                         <input type="text" class="form-control" placeholder="Search..." id="mkdocs-search-query">
  742.                     </div>
  743.                 </form>
  744.                 <div id="mkdocs-search-results"></div>
  745.             </div>
  746.             <div class="modal-footer">
  747.             </div>
  748.         </div>
  749.     </div>
  750. </div><div class="modal" id="mkdocs_keyboard_modal" tabindex="-1" role="dialog" aria-labelledby="Keyboard Shortcuts Modal" aria-hidden="true">
  751.     <div class="modal-dialog">
  752.         <div class="modal-content">
  753.             <div class="modal-header">
  754.                 <button type="button" class="close" data-dismiss="modal"><span aria-hidden="true">×</span><span class="sr-only">Close</span></button>
  755.                 <h4 class="modal-title" id="exampleModalLabel">Keyboard Shortcuts</h4>
  756.             </div>
  757.             <div class="modal-body">
  758.               <table class="table">
  759.                 <thead>
  760.                   <tr>
  761.                     <th style="width: 20%;">Keys</th>
  762.                     <th>Action</th>
  763.                   </tr>
  764.                 </thead>
  765.                 <tbody>
  766.                   <tr>
  767.                     <td><kbd>?</kbd></td>
  768.                     <td>Open this help</td>
  769.                   </tr>
  770.                   <tr>
  771.                     <td><kbd>←</kbd></td>
  772.                     <td>Previous page</td>
  773.                   </tr>
  774.                   <tr>
  775.                     <td><kbd>→</kbd></td>
  776.                     <td>Next page</td>
  777.                   </tr>
  778.                   <tr>
  779.                     <td><kbd>s</kbd></td>
  780.                     <td>Search</td>
  781.                   </tr>
  782.                 </tbody>
  783.               </table>
  784.             </div>
  785.             <div class="modal-footer">
  786.             </div>
  787.         </div>
  788.     </div>
  789. </div>
  792.     </body>
  793. </html>