深度优先

【VSCode】同步设置-扩展插件

发表于 2018-09-06 分类于常用工具
本文字数： 381 阅读时长 ≈ 1 分钟

第一步：首先安装同步插件： Settings Sync

第二步：进入你的github如图：

** 打开设置选项：**

新建一个token：

如图：

** 记住这个token值**

转到vscode

按shift+alt +u 在弹出窗里输入你的token,然后等下会生成syncSummary.txt文件在窗口中打开这样就算成功了。

syncSummary.txt这个文件里有个gist值或者到用户设置文件中查看gist的值，这个值用来你再另一台电脑上来下载你的设置

下载你的设置方法为：打开vscode——按alt+shift+d 在弹出窗里输入你的gist值，等待片刻便同步成功。

*如果要重置同步设置：按ctrl+p 输入 ‘>sync’ *

** 就可以重新配置你的token来同步了**

转自：https://www.cnblogs.com/ashidamana/p/6761085.html

【前端】Html5获取G-Sensor简单计步器

发表于 2018-09-06 分类于 DIY程序
本文字数： 7.9k 阅读时长 ≈ 7 分钟

<html>
<head>
    <title>DeviceOrientationEvent</title>
    <meta charset="UTF-8" />
    <script src="https://libs.baidu.com/jquery/2.0.0/jquery.min.js"></script>
    <script src="https://img.hcharts.cn/highcharts/highcharts.js"></script>
    <script src="https://img.hcharts.cn/highcharts/modules/exporting.js"></script>
    <script src="https://img.hcharts.cn/highcharts-plugins/highcharts-zh_CN.js"></script>
</head>

<body>
    <h1>简单的计步器</h1>
    <h2>简单的计步器 --
        <a href="demo1.html">重新开始</a>
    </h2>
    <hr />
    <p>G-Sensor 获取三轴的加速度（考虑重力加速度）实时：</p>
    <p>x轴加速度：
        <span id="xg">0</span> m/s2
    </p>
    <p>y轴加速度：
        <span id="yg">0</span> m/s2
    </p>
    <p>z轴加速度：
        <span id="zg">0</span> m/s2
    </p>
    <hr />
    <h3>手机获取传感器频率：
        <span id="interval">0</span>毫秒
    </h3>
    <p>开始时间：
        <span id="date">0</span>
    </p>
    <h3>当前步数：
        <span id="count1"> 0 </span> 步
    </h3>
    <hr>
    <div id="container" style="min-width:400px;height:400px"></div>
    <hr>
    <script type="text/javascript">
        var data = [];//用来记录数据的
        var arr = [];//记录△
        var status = 0;//是否为开车
        var min = 0.5, max = 1.552188;
        var temp = {
            X: 0, Y: 0, Z: 0
        };
        var point = 0;
        data.push(temp);

        //获取传感器上加速器的数据
        var count = 0;
        function motionHandler(event) {
            //html 的addEventListener 变化频率大概1秒60次 ，现在一秒钟收集一次数据
            // if (count >= 15) {
                document.getElementById("interval").innerHTML = event.interval;
                var accGravity = event.accelerationIncludingGravity;
                document.getElementById("xg").innerHTML = accGravity.x;
                document.getElementById("yg").innerHTML = accGravity.y;
                document.getElementById("zg").innerHTML = accGravity.z;

                onSensorChanged(accGravity.x, accGravity.y, accGravity.z);//记录数据
                count = 0;
            // }
            // count++;
        }
        //存放三轴数据
        var oriValues = [];
        //当前传感器的值
        var gravityNew = 0;

        function onSensorChanged(x, y, z) {
            oriValues[0] = x;
            oriValues[1] = y;
            oriValues[2] = z;
            gravityNew = Math.sqrt(oriValues[0] * oriValues[0] + oriValues[1] * oriValues[1] + oriValues[2] * oriValues[2]);
            point = gravityNew;
            detectorNewStep(gravityNew);
        }

        /*
    * 检测步子，并开始计步
    * 1.传入sersor中的数据
    * 2.如果检测到了波峰，并且符合时间差以及阈值的条件，则判定为1步
    * 3.符合时间差条件，波峰波谷差值大于initialValue，则将该差值纳入阈值的计算中
    * */
        //上次传感器的值
        var gravityOld = 0;
        //上次波峰的时间
        var timeOfLastPeak = 0;
        //此次波峰的时间
        var timeOfThisPeak = 0;
        //波峰波谷时间差
        var TimeInterval = 250;
        //当前的时间
        var timeOfNow = 0;
        //波峰值
        var peakOfWave = 0;
        //初始阈值
        var ThreadValue = 2.0;
        //动态阈值需要动态的数据，这个值用于这些动态数据的阈值
        var InitialValue = 1.3;
        var count1 = 0;
        function detectorNewStep(values) {
            if (gravityOld == 0) {
                gravityOld = values;
            } else {
                if (detectorPeak(values, gravityOld)) {
                    timeOfLastPeak = timeOfThisPeak;
                    timeOfNow = Date.now();
                    // System.currentTimeMillis
                    if (timeOfNow - timeOfLastPeak >= TimeInterval
                        && (peakOfWave - valleyOfWave >= ThreadValue)) {
                        timeOfThisPeak = timeOfNow;
                        /*
                         * 更新界面的处理，不涉及到算法
                         * 一般在通知更新界面之前，增加下面处理，为了处理无效运动：
                         * 1.连续记录10才开始计步
                         * 2.例如记录的9步用户停住超过3秒，则前面的记录失效，下次从头开始
                         * 3.连续记录了9步用户还在运动，之前的数据才有效
                         * */
                        // mStepListeners.countStep();
                        document.getElementById("count1").innerHTML = count1++;
                    }
                    if (timeOfNow - timeOfLastPeak >= TimeInterval
                        && (peakOfWave - valleyOfWave >= InitialValue)) {
                        timeOfThisPeak = timeOfNow;
                        ThreadValue = peakValleyThread(peakOfWave - valleyOfWave);
                    }
                }
            }
            gravityOld = values;
        }
        /*
             * 检测波峰
             * 以下四个条件判断为波峰：
             * 1.目前点为下降的趋势：isDirectionUp为false
             * 2.之前的点为上升的趋势：lastStatus为true
             * 3.到波峰为止，持续上升大于等于2次
             * 4.波峰值大于20
             * 记录波谷值
             * 1.观察波形图，可以发现在出现步子的地方，波谷的下一个就是波峰，有比较明显的特征以及差值
             * 2.所以要记录每次的波谷值，为了和下次的波峰做对比
             *
        */

        //上一点的状态，上升还是下降
        var lastStatus = false;
        //是否上升的标志位
        var isDirectionUp = false;
        //持续上升次数
        var continueUpCount = 0;
        //上一点的持续上升的次数，为了记录波峰的上升次数
        var continueUpFormerCount = 0;
        //波谷值
        var valleyOfWave = 0;
        function detectorPeak(newValue, oldValue) {
            lastStatus = isDirectionUp;
            if (newValue >= oldValue) {
                isDirectionUp = true;
                continueUpCount++;
            } else {
                continueUpFormerCount = continueUpCount;
                continueUpCount = 0;
                isDirectionUp = false;
            }

            if (!isDirectionUp && lastStatus
                && (continueUpFormerCount >= 2 || oldValue >= 20)) {
                peakOfWave = oldValue;
                return true;
            } else if (!lastStatus && isDirectionUp) {
                valleyOfWave = oldValue;
                return false;
            } else {
                return false;
            }
        }

        /*
         * 阈值的计算
         * 1.通过波峰波谷的差值计算阈值
         * 2.记录4个值，存入tempValue[]数组中
         * 3.在将数组传入函数averageValue中计算阈值
         * */
        //用于存放计算阈值的波峰波谷差值
        var ValueNum = 4;
        var tempValue = new Array(ValueNum);
        var tempCount = 0;
        function peakValleyThread(value) {
            var tempThread = ThreadValue;
            if (tempCount < ValueNum) {
                tempValue[tempCount] = value;
                tempCount++;
            } else {
                tempThread = averageValue(tempValue, ValueNum);
                for (var i = 1; i < ValueNum; i++) {
                    tempValue[i - 1] = tempValue[i];
                }
                tempValue[ValueNum - 1] = value;
            }
            return tempThread;
        }

        /*
         * 梯度化阈值
         * 1.计算数组的均值
         * 2.通过均值将阈值梯度化在一个范围里
         * */
        function averageValue(value, n) {
            var ave = 0;
            for (var i = 0; i < n; i++) {
                ave += value[i];
            }
            ave = ave / ValueNum;
            if (ave >= 8)
                ave = 4.3;
            else if (ave >= 7 && ave < 8)
                ave = 3.3;
            else if (ave >= 4 && ave < 7)
                ave = 2.3;
            else if (ave >= 3 && ave < 4)
                ave = 2.0;
            else {
                ave = 1.3;
            }
            return ave;
        }
        if (window.DeviceMotionEvent) {
            window.addEventListener("devicemotion", motionHandler, false);
        } else {
            document.body.innerHTML = "What user agent u r using???";
        }

        //获取时间
        function getNowTime() {
            var date = new Date();
            var Hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours();
            var Minutes = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes();
            var Seconds = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds();
            var time = Hours + ':' + Minutes + ':' + Seconds;
            return time;
        }
        document.getElementById("date").innerHTML = getNowTime();

        Highcharts.setOptions({
            global: {
                useUTC: false
            }
        });
        function activeLastPointToolip(chart) {
            var points = chart.series[0].points;
            chart.tooltip.refresh(points[points.length - 1]);
        }
        $('#container').highcharts({
            chart: {
                type: 'spline',
                animation: Highcharts.svg,
                marginRight: 100,
                events: {
                    load: function () {
                        var series = this.series[0],
                            chart = this;
                        setInterval(function () {
                            var x = (new Date()).getTime(),
                                y = point;
                            series.addPoint([x, y], true, true);
                            activeLastPointToolip(chart)
                        }, 1000);
                    }
                }
            },
            title: {
                text: '实时数据'
            },
            xAxis: {
                type: 'datetime',
                tickPixelInterval: 150
            },
            yAxis: {
                title: {
                    text: '值'
                },
                plotLines: [{
                    value: 0,
                    width: 1,
                    color: '#808080'
                }]
            },
            tooltip: {
                formatter: function () {
                    return '<b>' + this.series.name + '</b><br/>' +
                        Highcharts.dateFormat('%H:%M:%S', this.x) + '<br/>' +
                        Highcharts.numberFormat(this.y, 6);
                }
            },
            legend: {
                enabled: false
            },
            exporting: {
                enabled: false
            },
            series: [{
                name: '每秒的值',
                data: (function () {
                    var data = [],
                        time = (new Date()).getTime(),
                        i;
                    for (i = -100; i <= 0; i += 1) {
                        data.push({
                            x: time + i * 1000,
                            y: 0
                        });
                    }
                    return data;
                }())
            }]
        }, function (c) {
            activeLastPointToolip(c)
        });
    </script>
</body>

</html>

不便解释！

【DIY】Html5获取G-Sensor数据判断运行状态

发表于 2018-09-06 分类于 DIY程序
本文字数： 9.5k 阅读时长 ≈ 9 分钟

<html>

<head>
    <title>DeviceOrientationEvent</title>
    <meta charset="UTF-8" />
    <script src="https://libs.baidu.com/jquery/2.0.0/jquery.min.js"></script>
    <script src="https://img.hcharts.cn/highcharts/highcharts.js"></script>
    <script src="https://img.hcharts.cn/highcharts/modules/exporting.js"></script>
    <script src="https://img.hcharts.cn/highcharts-plugins/highcharts-zh_CN.js"></script>
</head>

<body>
    <h1>G-Sensor带GPS</h1>
    <h2>判断手机运动状态 --
        <a href="demoGPS.html">重新开始</a>
        <input type="button" value="获取GPS" οnclick="GetGPSInfo()">
    </h2>
    <p id="x"></p>
    <hr />
    <p>G-Sensor 获取三轴的加速度（考虑重力加速度）实时：</p>
    <p>x轴加速度：
        <span id="xg">0</span> m/s2
    </p>
    <p>y轴加速度：
        <span id="yg">0</span> m/s2
    </p>
    <p>z轴加速度：
        <span id="zg">0</span> m/s2
    </p>
    <hr />
    <h3>手机获取传感器频率：
        <span id="interval">0</span>毫秒
    </h3>
    <h3>
        <span> 0.5 ~~ 1.552188</span>
    </h3>
    <p>开始时间：
        <span id="date">0</span>
    </p>
    <div id="content">
        <p>是否在开车：
            <span id="drive">没开车</span>
        </p>
    </div>
    <hr>
    <div id="container" style="min-width:400px;height:400px"></div>
    <hr>
    <h3>手机获取GPS传感器精度(米)：
        <span id="accuracy">-1</span>
    </h3>
    <p>GPS的数据：</p>
    <ul class="GPSText">
    </ul>
    <hr>
    <p>采集到的数据(9秒内的中位数)：</p>
    <ul class="arr4">
    </ul>
    
    <script type="text/javascript">

        //记录△：每个周期记录的G-Sensor数据计算后的值
        var arr = [];

        //是否为开车,status==2判断为开车
        var status = 0;
        var statusStopCount = 0;

        //james的神秘数字
        var min = 0.5, max = 2.552188,walking=3.0;

        //用来暂存上次传感器记录的数据
        var temp = {
            X: 0, Y: 0, Z: 0
        };
        var flag = 1;
        var point = 0, pointMedian = 0, pointAvg = 0;//实时值,中位数,平均值

        var loadingData = [];//初始化Highcharts的值
        //获取传感器上加速器的数据
        var count = 0, t = 0;

        //1、监听设备的传感器
        if (window.DeviceMotionEvent) {
            window.addEventListener("devicemotion", motionHandler, false);
        } else {
            document.body.innerHTML = "What user agent u r using???";
        }

        //2、获取传感器上G-Sensor的数据
        function motionHandler(event) {
            //html 的addEventListener 变化频率大概1秒60次 ，现在一秒钟收集一次数据，由于计算需要时间改成52
            if (count >= 52) {
                document.getElementById("interval").innerHTML = event.interval;
                var accGravity = event.accelerationIncludingGravity;
                document.getElementById("xg").innerHTML = accGravity.x;
                document.getElementById("yg").innerHTML = accGravity.y;
                document.getElementById("zg").innerHTML = accGravity.z;

                LogingData(accGravity.x, accGravity.y, accGravity.z);//记录数据
                count = 0;
            }
            count++;
            t++;
        }

        //3、记录数据-处理算法的
        function LogingData(x, y, z) {

            var _x = x - temp.X;
            var _y = y - temp.Y;
            var _z = z - temp.Z;

            temp = {
                X: x, Y: y, Z: z
            };

            var value = Math.sqrt((_x * _x) + (_y * _y) + (_z * _z));
            point = value;
            arr.push(value);

            if (arr.length == 9) {
                pointAvg = 0;
                for (var i = 0; i < arr.length; i++) {
                    pointAvg += arr[i];
                }
                arr = arr.sort();
                pointMedian = arr[4];
                pointAvg = pointAvg / arr.length;

                $('.arr4').append('<li>' + getNowTime() + '---' + arr[4] + '</li>');

                //判断是否连续撞上,平均值和中值同时满足条件James定的值
                if ((arr[4] > min && arr[4] < max) ) { //&& (pointAvg > min && pointAvg < max)
                    status = status + 1;
                } else {
                    status = 0;
                }

                //判断是否为走路,平均值和中位数同时大于walking及判断为步行
                if ((arr[4] > walking) && (pointAvg > walking)) {
                    statusStopCount = statusStopCount + 1;
                } else {
                    statusStopCount = 0;
                }

                // //连续两次撞上判断为开车
                if (status >= 2 && flag > 0) {
                    document.getElementById("drive").innerHTML = 'Sensor判断为开车-开GPS';
                    $("body").css("background-color", "#4A8AF4");

                    //开GPS
                    GpsStart(flag);
                }

                if (statusStopCount >= 2) {
                    document.getElementById("drive").innerHTML = 'Sensor判断为没开车-关GPS';
                    $("body").css("background-color", "#FFFFFF");

                    //关GPS
                    //GpsStop(flag);
                }
                arr = [];
            }
        }

        //获取时间
        function getNowTime() {
            var date = new Date();
            var Hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours();
            var Minutes = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes();
            var Seconds = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds();
            var time = Hours + ':' + Minutes + ':' + Seconds;
            return time;
        }
        document.getElementById("date").innerHTML = getNowTime();

        // --------------------------------------------------开启GPS-判断是否开启 Trip-------------------------------------------------
        function getLocation() {
            var options = {
                enableHighAccuracy: true,
                maximumAge: 0
            }
            if (navigator.geolocation) {
                //浏览器支持geolocation
                navigator.geolocation.getCurrentPosition(onSuccess, onError, options);
            } else {
                //浏览器不支持geolocation
                alert('浏览器不支持geolocation');
            }
        }
        var GPSSpeed = [];//存放GPS的速度，十秒钟的五个值
        var GPSSpeedAVG = 0;//存放十秒钟的平均速度

        //成功时
        function onSuccess(position) {
            GPSSpeed.push(Math.abs(position.coords.speed));
            if (GPSSpeed.length >= 10) {
                for (var i = GPSSpeed.length - 10; i < GPSSpeed.length; i++) {
                    GPSSpeedAVG += GPSSpeed[i];
                }
                GPSSpeedAVG /= GPSSpeed.length;
                $('.GPSText').append('<li>' + getNowTime() + '- 速度：' + GPSSpeedAVG + '--' + position.coords.longitude +'-|-'+ position.coords.latitude + '</li>');
                document.getElementById("accuracy").innerHTML =  position.coords.accuracy+'-|-'+position.coords.altitudeAccuracy;
                if (GPSSpeedAVG > 2.5) {
                    $("body").css("background-color", "#BCEA1C");
                    document.getElementById("drive").innerHTML = 'GPS判断为开车';
                } else {
                    $("body").css("background-color", "#F20DD8");
                    document.getElementById("drive").innerHTML = 'GPS判断为没开车';
                }
                GPSSpeedAVG = 0;
            }
        }

        //失败时
        function onError(error) {
            switch (error.code) {
                case 1:
                    alert("-");
                    break;
                case 2:
                    alert("暂时获取不到位置信息");
                    break;
                case 3:
                    alert("获取信息超时");
                    break;
                case 4:
                    alert("未知错误");
                    break;
            }
        }

        function GpsStart() {
            if (flag > 0) {
                flag = 0;
                var GpsCount = 0;
                var timer1 = setInterval(
                    function () {
                        getLocation();
                        GpsCount++;
                        if (GpsCount >= 6 * 10) {
                            flag = 1;
                            document.getElementById("drive").innerHTML = '没开车-关闭GPS';
                            $("body").css("background-color", "#FFFFFF");
                            GPSSpeed = [];//清空数组
                            window.clearTimeout(timer1);//去掉定时器 
                        }
                    }, 1000);
            }
        }

        // -------------------HighCharts 数据展示--------------------------------------------------------------------------------

        //初始化数据
        function getHighCharts(k) {
            loadingData = [];
            var time = (new Date()).getTime();
            for (var i = -100 / k; i <= 0; i += 1) {
                loadingData.push({
                    x: time + i * 1000 * k,
                    y: 0
                });
            }
            return loadingData;
        }

        Highcharts.setOptions({
            global: {
                useUTC: false
            }
        });

        function activeLastPointToolip(chart) {
            var points = chart.series[0].points;
            chart.tooltip.refresh(points[points.length - 1]);
        }

        //highcharts数据的显示
        $('#container').highcharts({
            chart: {
                type: 'spline',
                animation: Highcharts.svg,
                marginRight: 100,
                events: {
                    //数据的实时刷新
                    load: function () {
                        var series = this.series[0],
                            seriesMedian = this.series[1],
                            seriesAvg = this.series[2],
                            chart = this;

                        setInterval(function () {
                            var x = (new Date()).getTime();
                            series.addPoint([x, point], true, true);
                            activeLastPointToolip(chart)
                        }, 1000);

                        setInterval(function () {
                            var x = (new Date()).getTime();
                            seriesMedian.addPoint([x, pointMedian], true, true);
                            seriesAvg.addPoint([x, pointAvg], true, true);
                            activeLastPointToolip(chart)
                        }, 9000);
                    }
                }
            },
            title: {
                text: '实时数据'
            },
            xAxis: {
                type: 'datetime',
                tickPixelInterval: 150
            },
            yAxis: {
                title: {
                    text: '值'
                },
                plotLines: [{
                    value: 0,
                    width: 1,
                    color: '#808080'
                }]
            },
            tooltip: {
                formatter: function () {
                    return '<b>' + this.series.name + '</b><br/>' +
                        Highcharts.dateFormat('%H:%M:%S', this.x) + '<br/>' +
                        Highcharts.numberFormat(this.y, 6);
                }
            },
            legend: {
                reversed: true,
            },
            exporting: {
                enabled: false
            },
            series: [{
                name: '每秒的值',
                data: getHighCharts(1)
            }, {
                name: '9秒的中位数',
                data: getHighCharts(9)
            }, {
                name: '9秒的平均值',
                data: getHighCharts(9)
            }]
        }, function (c) {
            activeLastPointToolip(c)
        });
    </script>
</body>

</html>