精华内容
下载资源
问答
  • 智能车环岛浅析(电磁+摄像头)

    万次阅读 多人点赞 2019-06-19 22:09:16
    看到网上对于环岛的介绍微乎其微,想着写点什么,对于一些没有祖传代码和资料的同学起到一点指导和抛砖引玉的作用把,看了一些国一国二的代码,发现跟自己想的方法基本一致,所以个人认为应该能对没有思路的同学有...

    写在前面:

     看到网上对于环岛的介绍微乎其微,想着写点什么,对于一些没有祖传代码和资料的同学起到一点指导和抛砖引玉的作用把,看了一些国一国二的代码,发现跟自己想的方法基本一致,所以个人认为应该能对没有思路的同学有一点启发,当然,比赛最主要的就是锻炼个人能力,条条大路通环岛,希望同学们不要被我的这种方法所局限,自己的思想无论在何时都是要有的,当然,由于本人能力不足等原因,如果有错误欢迎批评指出。

    摄像头入环

    1识别环岛

     

    想着入环岛,那么最基本的肯定要先做到识别,对于环岛的识别,我个人的思想是分为五部分即可,以右环岛为例

     

    1 在第一部分时,你会发现右边赛道宽度突然变宽,而左边赛道正常(可以区分环岛和十字(十字为两边发生突变))

    这时候便可以加一个标志位1,

    2.在第二部分,我们可以看到左边赛道无突变,右边赛道丢线(检测不到黑点),各位应该都有丢线标志位

    这时便有环岛标志位2

    3在第三部分(标志位1和标志位2成立),我们可以看到右边赛道先是逐渐变窄,之后便是逐渐变宽,这时候可以得到标志位3

    并且记录下右赛道刚开始变宽时的行位置

    4.之后你会发现右边赛道再次丢线,最后一个标志位

    5。当然少不了最后的V(赛道宽度发生突变)

    识别其实不难,大家可以根据自己的图像来具体修改,具体识别会有不同,但有思路即可,你会发现3,4,5在一幅图像中,也可以根据这些来进行判断,(当然,今年各位应该都是电磁+摄像头,这样的话环岛识别便更为简单,电磁信号变为双倍,并且摄像头有少许标志位,便可以很简单的判断出环岛,)之后便是最重要的补线了

    补线

    补线便是根据1和2点根据斜率连接,最小二乘法拟合得到相应的中线

    1点 :右边界为直线,上一次左边界-这次左边界>10(这一行赛道宽度-上一行赛道宽度>10) 并记录下该行左边界位置,即为1点

    2点: 前面有提到过,右边界为直线,这一行左边界-上一行左边界>2 记录下此时左右边界位置 右边界为2点 

    3点: 2点的左边界即为3点

    4.如果为左环岛,则右边界为直道。

    赛道边界法:

    如果不用拟合直线,可以考虑以1点作为赛道右边界,然后右边界往前依次递增(右环岛为递减) 直到2点处,也可得到不错的入环效果

    具体方法是假设1点为x行y列 2点为x2行y2列  用y-y1得到列数差,x-x1得到行数差 最后列数差/行数差=每行递减值Y

    然后从1点开始,往前一直到2点行每行右边界依次右移 Y  即可得到得到图像

    举个例子  1点为55行 左边界为20列  (55,20) 2点为30行 右边界为70列(30,70)  那么每行递减值 = (70-20)/(55-30) = 2 这样每行位移2即可   当然还可以有一些其他处理让它更接近圆环

     

    至于最小二乘法拟合直线相信各位都有了解,只要能成功识别1,2两点,拟合补线便是处理问题了

    当然,今年由于限高,可能你的小车看不到2和3点,如果为一下特征,仍然是1点补线,但是从1点到另一边界有赛道的最后一行即可

    2停止补线

    当车辆进入环内后,可以停止补线了,这时候按照正常寻线来跑即可

    需要注意的是,这里的停止补线标志位要写好,因为小车每次入环的速度和位置是不同的,如果停止补线误判的话会有很大问题

    3出环岛补线

    出环岛补线

    当图中的右赛道边界先减小后增大时的,改行的右边界位置即为补线位置

    上一次右边界-这次右边界>10(这一行赛道宽度-上一行赛道宽度>10)   记录右边界位置

    或者出环岛用电磁出环也可

    毕竟环岛入环是要把他作为一个圆环弯道来处理,不管用什么方法、只要你最后得到的补线能够更好的接近圆环弯道,转向就会越精确,只要1,2两点能够很好识别,怎么让他更好的接近圆环处理,更好的方法需要你的聪慧去发现,同时,入环写好了,出环其实思路一样,

    电磁入环

     

    电磁入环是五电感入环

    (电感可以改为8字电感)

    具体方法为:

     

    中间电感一个阀值来识别环岛,识别完成竖直差比和进环,进入后切换水平差比和寻迹,出环时标志位检测用水平电感,延时一定时间或编码器积分清标志即可。

    我们可以这样想,如果是单纯水平电感遇到弯道,会流畅的转向,而在遇到环岛时,我们把竖直电感作为转向环,是不是相当于正常入弯呢    

    简单来说,两个不同差和比即可

    Turn_Offset = (float) (LAD-RAD)/(float)(LAD+RAD+MAD)*100;//经典差和比

    Turn_Offset2 = (float) (L1AD-R1AD)/(float)(L1AD+R1AD+MAD)*100;//竖直电感差和比

    当然左竖直电感与与右竖直电感进行差比和 ,还有这一些处理,比如如何适应大小环,入环如何完美和出环稳定性等

    这些问题还是要处理的(可修改PID参数来调节),    当然希望大家能独立思考下,

    总结:


    基于今年应该都是电磁+摄像头,可以说在赛道元素处理上即难了,又简单了

    难是对于新手小白(博主)来说,要同时学习处理电磁和摄像头,并且多了一些元素,再加上会车,对小白不是很友好

    简单是电磁+摄像头之后,一些赛道元素可以更好的处理 ,比如环岛,如果单摄像头或者单电磁入环不稳定,可以考虑两个加权,达到较稳定状态,就可以跑得不错。

    总的来说可以是,电感阈值 || 摄像头环岛检测 来判断环岛  (有上帝之光摄像头环岛识别不良)  之后电磁入环还是摄像头入环就要个人考虑了

     

    感觉有用的话,点个赞再走呗!

     

     

    展开全文
  • 文章来源:微信公众号”沥青路面“滚筒热风循环式沥青路面养护是通过燃烧器加热热风经热风循环系统对沥青料进行加热,在加热过程中沥青料随滚筒旋转处于动态抄料状态。滚筒抄料沥青料面温度场是滚筒热风流分布状况...
    c7c23eec7c93d2387dac9ff29019eae3.png

    文章来源:微信公众号”沥青路面“

    滚筒热风循环式沥青路面养护车是通过燃烧器加热热风经热风循环系统对沥青料进行加热,在加热过程中沥青料随滚筒旋转处于动态抄料状态。滚筒抄料沥青料面温度场是滚筒热风流分布状况最直接的表现形式,然而,由于滚筒热风循环加热内部具有复杂的物理、化学、动力学过程,很难直接建立准确的沥青料面温度与热风场模型关系。因此,如何反应滚筒在整个加热过程中料面温度场的关系是滚筒热风循环式沥青路面养护车的关键。本文采用SPEC专用控制器和红外热像仪进行采集处理可以很好的改善图像质量;针对单一传感器检测信息难以建立准确的滚筒内沥青料面温度场模型的问题,在多传感器信号分析的基础上对传感器测量值进行动态修正提高动态温度测量精度,尹从而准确测量滚筒内部实际料温。

    滚筒料面红外测温

    传感器数据采集模块将热像仪摄取的红外热图像和多传感器信号采集到EPEC专用控制器中,由图像数据处理模块对图像进行滤波、去噪、分块等处理,并由多传感器动态修正模块对结果进行修正之后,通过温度显示模块显示出滚筒温度。

    热风式滚筒加热的红外图像能够反映沥青料面温度场的分布状况,然而,由于热风式滚筒在旋转抄料时其内部存在粉尘、沥青烟雾、设备热噪声等各类干扰,为得到真实可靠的数据,需对采集的数据进行图像滤波、图像分割和特征提取以获得料面温度场、中心位置和径向温度分布等特征信息,通过对特征信息处理分析可以反应热风式滚筒加热沥青料的温度。

    图像数据滤波

    针对热风式滚筒加热过程的复杂性、结构的特殊性以及红外图像中各种脉冲、高斯噪声的影响,采用中值和均值混合滤波的方法,对热风式滚筒内部的空间和时间尺度两个方面进行滤波。采集的图像质量有了明显的提高。

    热风式滚筒内部料面燃烧器启停时的红外图像,存在一定数量的移动亮斑。通过上述图像滤波处理后获得的红外图像,明显滤除了存在的亮斑。

    图像数据分割

    沥青路面养护车热风式滚筒红外图像中的目标与分布级具有明显的差别,根据热风式滚筒沥青料分布特点,首先通过区域分析法进行图像分割,将不同区域的温度进行划分,同时考虑到单纯区域分析法存在的问题,采用最大类间方差分割法进行阈值计算。

    采用类间方差法表示沥青路面养护车热风式滚筒红外图像背景和口标两部分之间的差别,方差越大说明差别越大,类间方差最大的分割意味着错分概率最小。按照此方法分割图像分割结果和期望得到的图像特征区域是一致的,符合阀值选择策略的思想。

    沥青料面温度场的提取

    热风式滚筒加热沥青路面养护车红外图像能够反映滚筒内部沥青料面温度场分布信息,无法直接提供滚筒内部沥青料面信息,因此我们需要通过专用控制器针对各种不同的信息进行处理得到实际的沥青料一面温度。步骤如下:首先选择沥青料面红外图像上任何条直径上的点作为基准点;然后以沥青料面红外图像的圆点为中心,基准点到圆点的距离为半径,以基准点为起点顺时针和逆时针各做450。统计圆弧上所有点的数据值,累计求和再求平均值;最后完成沥青料面径向分布显示。利用沥青料面温度场在红外图像中的幅值特征和温度对照处理,实现沥青料面温度场的特征信息提取,获得沥青料面径向温度分布信息,为热风式滚筒加热沥青路面养护车料温显示提供了重要依据。

    滚筒料面温度修正

    为增加沥青料温测量的准确度,在红外图像测温和传感器信号分析的基础上,提出了在频域内对传感器测量值进行动态修正的方法。在精确估算时间常数的基础上,对滚筒传感器的输出进行数字差分、信号滤波及频域校正,从而实现了对沥青料温进行动态修正,提高了其测温精度。

    系统中选用PT100热敏电阻器,具有高的负温度系数和高的电阻率。在温度范围为(0<T<630℃),电阻一温度关系可用数学表达式表示为:Rt=R0(1+At+Bt2)式看R0系温度为0℃时的电阻,R0=100Ω。A=3.9684×10-3/℃,B=-5.847×10-7/)℃

    PT100传感器时间常数与热容量耗散系数及自热效应有关,由于在不同条件下PT100传感器的时间常数与其工作条件有关,在不同工况时,其时间常数t也不同。因此滚筒动态测温前必须对其进行标定,在测量热敏电阻器的时问常数时,将热敏电阻器从室温的空气中突然置入抄完料的滚筒中,同时,计算机控制A/D进行采样。然后,按如下步骤进行数据处理,计算t值。首先通过以上温度公式对温度进行计算,并对其进行FFT变换;然后在频域内对其低通滤波,并将滤波后的数据进行FFT反变换,计算得到时间常为100ms。在滚筒燃烧修正后的结果中,开始几点有过冲现象,但很快达到平衡。控制器通过判断一般对小于10的值可舍弃。将PT100电阻温度传感器从室温突然投入燃烧的滚筒沥青料中,热敏电阻实际输出温度值与对热敏电阻实际输出温度180℃值进行动态修正结果的比较。通过专用控制器进行动态修正,一可将PT100温度传感器响应速度提高6~7倍,因此达到了测试结果。

    实验结果与分析

    热风式滚筒加热沥青路面养护车实验采用常温冷料、二段火加热50℃、二段火加热100℃、二段火加热150℃、二段火180℃、一段火加热50℃、一段火加热100℃、一段火加热150℃和一段火180℃料温作为被测目标,通过测试获取不同温度和状态的图像,经过专用控制器测温软件的计算,可得到其温度分布,在本系统中是按照红橙黄绿蓝淀紫的排列顺序,温度依次降低。下面就是我们的温度分布测量结果。

    我们看到滚筒内部彩色温度分布与原图表观视觉非常吻合。通过对滚筒内部测温数据进行分析,其温度分布在10~1100℃之间,这也与一般实际的料温以及火口温度范围是一致的,这种测温方法不仅能够反映滚筒内部温度场的分布,而且其数据也是比较准确的。通过专用控制器计算出的温度分布与实际的温度分布是完全相吻合的,这也是我们采用料面温度修正实现动态范围的目的所在。

    结语

    基于数字图像处理的综合养护车料面温度测量技术是一种新的测温技术,通过对滚筒内部红外图像进行分析得出料面温度;针对滚筒内部燃烧器火焰的亮度非常高,并且亮度梯度变化大,提出了在频域内对传感器测量值进行动态修正,提高动态温度测量精度的方法;并针对单一传感器检测信息、难以建立准确的滚筒内沥青料面温度场模型的问题,基于多传感器信号分析的基础上进行温度修正,通过以上处理可以达到对滚筒内部料面温度的实时测量。

    展开全文
  • 车漆碰掉后,漏出钢板,这种情况是会生锈的。简单而言,车漆就是起到汽车钢材的防锈保护作用。车漆受损,时间长了,容易受潮,导致生锈。打蜡喷漆都是可以补救的。下面,简单说说关于车漆的一些事儿,供你参考。...

    车漆碰掉后,漏出钢板,这种情况是会生锈的。简单而言,车漆就是起到汽车钢材的防锈保护作用。车漆受损,时间长了,容易受潮,导致生锈。打蜡喷漆都是可以补救的。下面,简单说说关于车漆的一些事儿,供你参考。

    3623b04035ae1f3ece627da08e2f5a8c.png

    NO.1

    汽车为何要防锈?

    这是因为大部分的家用轿车主要构架都是钢铁结构,当然有部分豪车是铝制车身,铝制车身就不用考虑防锈了。但市面上95%以上的车型都是钢制结构,车身覆盖件也都是铁皮。

    钢铁价格便宜、强度也不错,但钢铁最怕的就是生锈,别以为生点锈没什么了不起。汽车钢铁构建如果生锈了,它不仅会缩短汽车的寿命,降低汽车价值,严重的还会危及电器零件,甚至影响安全性能。所以,注意车身防锈还是很有必要的。

    NO.2

    车身覆盖件的车漆破损到什么程度会生锈?

    车身覆盖件的车漆如果只是轻微碰擦,没有漏出金属底板,这种情况不容易生锈。只有等到碰擦将车漆全部磨损,漏出了金属底板的时候,这就要引起注意了,需要进行修补防锈了。

    汽车车漆的厚度每家不一样,一般而言,厚漆对金属层的保护更好,除非经历多次严重摩擦,否则不太容易露出金属层,因此更有利于防锈;薄漆则相反,一次擦碰就可能露出金属层,自然也更容易生锈。

    NO.3

    掉漆了怎么办?

    简单来说,就是小点小补,大点大修。像这种掉漆的面积不大的,可以用补漆笔等措施进行修补,没有必要为这么点小破损去维修店补漆。开车嘛,碰碰擦擦是难免的,一般老司机碰到小碰小擦都是自己临时修补下,等全车破损地方多了一起修理,省时省力。

    NO.4

    那简单的修补方法有哪些呢?

    补漆笔。建议新手必备,如果没有锈斑的话,简单清洁表面后就可以用了。如果已经有些许锈斑的话,先用水砂纸蘸水轻轻磨去锈斑,擦净后,用补漆笔进行上色处理。这样的处理虽然没有去美容店处理效果好,但如果是小的或者不醒目处的伤痕,也可以起到美观、防锈的作用。

    牙膏。如果还没买补漆笔的话,可以拿牙膏先应急下,将牙膏轻轻涂抹在抓痕上。一般来说,这可以减少划痕和痕迹,也可以简单地起到隔离和防止生锈的作用,短期内没有问题。尤其是白色的车漆,效果最为明显。下雨或洗车后,不要忘了再粉刷一遍。

    车漆受损的确是蛮糟心的,尤其对于新手来说,更是痛心。不过既然遇到了,也别伤心,有些小伤口,简单处理下即可。希望能够帮助到你。

    展开全文
  • 适合参加智能车竞赛的参赛人员用于学习
  • 智能车Code review】——环岛的判定与补线操作

    千次阅读 多人点赞 2020-08-09 11:45:57
    以右环岛为例: k_left:左线的斜率 rou_of_left:左线的方差 last_rou_of_left:上一帧的左线方差 l_start:左线第一行为黑的所在行 right_turn_down; right_turn_middle; right_turn_up; 左线的下、中、上拐点 ...

    博主联系方式:
    QQ:1540984562
    微信:wxid_nz49532kbh9u22 QQ交流群:892023501

    这里是对于代码的讲解视频,大约一个小时,需要的同学可以看看:B站:meeting_01

    系列文章

    【智能车Code review】—曲率计算、最小二乘法拟合
    【智能车Code review】——坡道图像与控制处理
    【智能车Code review】——拐点的寻找
    【智能车Code review】——小S与中S道路判断
    【智能车Code review】——环岛的判定与补线操作
    智能车复工日记【1】——菜单索引回顾
    智能车复工日记【2】——普通PID、变结构PID、微分先行PID、模糊PID、专家PID
    智能车复工日记【3】:图像处理——基本扫线和基本特征提取和十字补线
    智能车复工日记【4】:关于图像的上下位机的调整问题总结
    智能车复工日记【5】:起跑线的识别与车库入库
    智能车复工日记【6】:有bug的模糊PID记录
    智能车复工日记【7】:关于会车的图像问题
    智能车复工日记【N】:图像处理——环岛debug记录(持续更新)

    【1】效果展示图

    状态1、状态2
    状态1

    状态3
    状态3

    状态4、状态5
    状态4

    状态6
    状态6

    状态7
    状态7
    状态7

    状态8
    状态7或者8
    状态8

    【2】状态机设定需要的参数

    以右环岛为例:

    k_left:左线的斜率
    rou_of_left:左线的方差
    last_rou_of_left:上一帧的左线方差
    l_start:左线第一行为黑的所在行
    right_turn_down;
    right_turn_middle;
    right_turn_up;
    左线的下、中、上拐点
    fiv_width[i]:第i行的赛道宽度
    leftline_duan_dian:左线跳变严重的所在行
    if (j >= 2 && (lefetline[j] - lefetline[j - 1]) <= -20) leftline_duan_dian = j;
    flag_shizi:是否为十字的标志
    huandao_size:当前环岛的大小,一般来说是人工设定的。
    huandao_memory:环岛的状态
    huandao_flag_R_L:左右环岛区分标志

    函数

            void R_mend_rightline_right_island(byte type, byte flag_R_L)
            {
                if (flag_R_L == 2)
                {
                    if (type == 1 || type == 2)//从下拐点开始往上拉,拉到上拐点下五行
                    {
                        byte j = 0;
                        if (right_turn_down[0] >= 5)
                        {
                            advanced_regression(2, right_turn_down[0] - 2, right_turn_down[0], right_turn_middle[0] - 1, right_turn_middle[0]);
                            //regression(2, right_turn_down[0], right_turn_middle[0]);
                            for (j = (byte)right_turn_down[0]; j <= (byte)right_turn_middle[0]; j++)
                            {
                                int jicun = (int)(parameterB * j + parameterA);
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                rightline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                            before_zuohuandao_k = parameterB;
                            before_zuohuandao_b = parameterA;
                        }
                        else
                        {
                            int delta = right_turn_middle[0] - 0;
                            if (delta == 0) delta = 1;
                            float k = (right_turn_middle[1] - rightline[0]) * 1.0f / delta;
                            float b = rightline[0];
                            for (j = (byte)0; j <= (byte)right_turn_middle[0]; j++)
                            {
                                int jicun = ((int)(k * j + b));
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                rightline[j] = (byte)jicun;
                            }
                        }
                    }
                    else if (type == 3)
                    {
                        byte j = 0;
                        int delta = right_turn_middle[0] - 0;
                        if (delta == 0) delta = 1;
                        float k = (right_turn_middle[1] - rightline[0]) * 1.0f / delta;
                        float b = rightline[0];
                        for (j = (byte)0; j <= (byte)right_turn_middle[0]; j++)
                        {
                            int jicun = ((int)(k * j + b));
                            if (jicun >= 185) jicun = 185;
                            else if (jicun <= 0) jicun = 0;
                            rightline[j] = (byte)jicun;
                        }
                        //byte j = 0;
                        advanced_regression(2, right_turn_down[0] - 2, right_turn_down[0], right_turn_middle[0] - 1, right_turn_middle[0]);
                        regression(2, right_turn_middle[0]-7, right_turn_middle[0]-1);
                        //for (j = 0; j <= (byte)right_turn_middle[0]; j++)
                        //{
                        //    int jicun = (int)(before_zuohuandao_k * j + before_zuohuandao_b);
                        //    if (jicun >= 185) jicun = 185;
                        //    else if (jicun <= 0) jicun = 0;
                        //    rightline[j] = (byte)jicun;
                        //    //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                        //}
                    }
                    else if (type == 8)
                    {
                        byte j = 0;
                        //advanced_regression(2, right_turn_down[0] - 2, right_turn_down[0], right_turn_middle[0] - 1, right_turn_middle[0]);
                        if (right_turn_up[0] <= 5 && right_turn_up[0] != 0)
                        {
                            regression(2, r_sec_start, r_sec_start + 3);
                            for (j = 0; j <= (byte)r_sec_start; j++)
                            {
                                int jicun = (int)(parameterB * j + parameterA);
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                rightline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                        }
                        else if (right_turn_up[0] >= 5 && right_turn_up[1] <= 4 && break_hangshu >= right_turn_up[0])
                        {
                            regression(2, right_turn_up[0], break_hangshu);
                            for (j = 0; j <= (byte)right_turn_up[0]; j++)
                            {
                                int jicun = (int)(parameterB * j + parameterA);
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                rightline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                        }
                        else
                        {
                            int delta = right_turn_up[0] - 0;
                            if (delta == 0) delta = 1;
                            float k = (right_turn_up[1] - rightline[0]) * 1.0f / delta;
                            float b = rightline[0];
                            for (j = (byte)0; j <= (byte)right_turn_up[0]; j++)
                            {
                                int jicun = ((int)(k * j + b));
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                rightline[j] = (byte)jicun;
                            }
                            //regression(2, right_turn_up[0], right_turn_up[0] + 2);
                            //for (j = 0; j <= (byte)right_turn_up[0]; j++)
                            //{
                            //    int jicun = (int)(parameterB * j + parameterA);
                            //    if (jicun >= 185) jicun = 185;
                            //    else if (jicun <= 0) jicun = 0;
                            //    rightline[j] = (byte)jicun;
                            //    //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            //}
                        }
    
                    }
                }
            }
            void R_mend_leftline_right_island(byte type, byte flag_R_L)
            {
                if (flag_R_L == 2)
                {
                    // SetText("TYPE:" + type);
                    if (type == 4)
                    {
                        byte j = 0;
                        if (right_turn_up[0] >= 4)
                        {
                            int delta = right_turn_up[0] - 3;
                            if (delta == 0) delta = 1;
                            float k = (right_turn_up[1] - lefetline[3]) * 1.0f / (delta * 1.0f);
                            // setText用户自定义("斜率" + k);
                            float b = lefetline[3] - k * 3;
                            if (right_turn_up[0] <= 24)
                            {
                                right_turn_up[0] = 24;
                            } 
                            for (j = (byte)3; j <= (byte)right_turn_up[0]; j++)
                            {
                                int jicun = ((int)(k * j + b));
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                lefetline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                            //advanced_LeastSquareCalc_Curve(1, 4, 10, (byte)(right_turn_up[0] - 3), (byte)(right_turn_up[0] - 1));
                            //for (j = (byte)3; j <= break_hangshu - 1; j++)
                            //{
                            //    int jicun = ((int)(curve_a * j * j + curve_b));
                            //    if (jicun >= 185) jicun = 185;
                            //    else if (jicun <= 0) jicun = 0;
                            //    lefetline[j] = (byte)jicun;
                            //    //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            //}
                        }
                        else
                        {
    
                        }
                    }
                    else if (type == 5) //重新扫线,从左边往右边扫
                    {
                        byte j = 0;
                        if (right_turn_up[0] >= 4 && (last_memory == 4 || leftline_duan_dian >= 40))
                        {
                             setText用户自定义("拟合直线");
                            int delta = right_turn_up[0] - 3;
                            if (delta == 0) delta = 1;
                            float k = (right_turn_up[1] - lefetline[3]) * 1.0f / (delta * 1.0f);
                            float b = lefetline[3] - k * 3;
                            if (right_turn_up[0] <= 24)
                            {
                                right_turn_up[0] = 24;
                                for (int ss = 0; ss <= 24; ss++)
                                {
                                    rightline[ss] = 0;
                                }
                            }
                            for (j = (byte)3; j <= (byte)right_turn_up[0]; j++)
                            {
                                int jicun = ((int)(k * j + b));
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                lefetline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                            //advanced_LeastSquareCalc_Curve(1, 4, 10, (byte)(right_turn_up[0] - 3), (byte)(right_turn_up[0] - 1));
                            //setText用户自定义("拟合曲线");
                            //for (j = (byte)3; j <= right_turn_up[0]; j++)
                            //{
                            //    int jicun = ((int)(curve_a * j * j + curve_b));
                            //    if (jicun >= 185) jicun = 185;
                            //    else if (jicun <= 0) jicun = 0;
                            //    lefetline[j] = (byte)jicun;
                            //    //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            //}
                        }
                        else if (leftline_duan_dian < 40 || right_turn_up[0]<4)
                        {
                            //advanced_regression(2, right_turn_up[0] - 2, right_turn_down[0], right_turn_middle[0] - 1, right_turn_middle[0]);
                            if (leftline_duan_dian + 5 <= break_hangshu)
                            {
                                regression(1, leftline_duan_dian, break_hangshu);
                                parameterA = lefetline[0];
                                if (parameterB <= -5) parameterB = -5;
                                setText用户自定义("斜率拟合" + parameterB);
                            }
                            else
                            {
                                int delta = break_hangshu - 0;
                                if (delta == 0) delta = 1;
                                parameterB = (rightline[break_hangshu] - lefetline[0])*1.0f / delta;
                                parameterA = lefetline[0];
                                setText用户自定义("斜率计算" + parameterB);
                            }
                            if (leftline_duan_dian <= 24)
                            {
                                leftline_duan_dian = 24;
                                for (int ss = 0; ss <= 24; ss++)
                                {
                                    rightline[ss] = 0;
                                }
                            }
                            for (j = 0; j <= (byte)break_hangshu; j++)
                            {
                                int jicun = (int)(parameterB * j + parameterA);
                                if (jicun >= 185) jicun = 185;
                                else if (jicun <= 0) jicun = 0;
                                lefetline[j] = (byte)jicun;
                                //centerline[j] = (byte)((rightline[j] + lefetline[j]) / 2);
                            }
                        }
                    }
                    else if (type == 6)
                    {
                        byte j = 0;
                        byte youguai_y = 0;
                        byte youguai_x = 0;
                        byte leftguai_y = 0;
                        byte leftguai_x = 0;
                        /***找左下拐点***********/
                        for (j = 2; j <= 60; j++)
                        {
                            if (lefetline[j - 1] - lefetline[j - 2] <= 0 && lefetline[j] - lefetline[j - 1] >= 0 && (lefetline[j + 1] - lefetline[j] > 0)
                                && leftfindflag[j - 2] == 1 && leftfindflag[j - 1] == 1 && leftfindflag[j] == 1)
                            {
                                leftguai_y = (byte)(j - 1);
                                leftguai_x = lefetline[j - 1];
                                break;
                            }
                        }
                        for (j = 8; j <= 60; j++)
                        {
                            //右连接处
                            if (rightline[j] != 0)
                            {
                                youguai_y = j;
                                youguai_x = rightline[j];
                                break;
                            }
                        }
    
                        if (leftguai_y != 0 && leftguai_x != 0 && youguai_y != 4 && youguai_x != 0)
                        {
                            SetText("找到右上拐点");
                            SetText("右上拐点坐标:" + youguai_y + "  " + youguai_x);
                            SetText("找到左下拐点");
                            SetText("左下拐点坐标:" + leftguai_y + "  " + leftguai_x);
                            if (youguai_y >= leftguai_y + 4)
                            {
                                SetText("要减速了");
                                jiansu_flag = 1;
                            }
                            else jiansu_flag = 0;
                            //开始拉线
                            int delta = youguai_y - leftguai_y;
                            if (delta == 0) delta = 1;
                            float k = (youguai_x - leftguai_x) * 1.0f / delta;
                            float b = leftguai_x - k * leftguai_y;
                            if (youguai_y >= leftguai_y)
                            {
                                for (j = (byte)leftguai_y; j <= (byte)youguai_y; j++)
                                {
                                    int jicun = ((int)(k * j + b));
                                    if (jicun >= 185) jicun = 185;
                                    else if (jicun <= 0) jicun = 0;
                                    lefetline[j] = (byte)jicun;
                                }
                            }
                        }
                    }   
                    else if (type == 7 && (long_turn_flag_left <= 55 || rou_of_left >= 5000) && ((flag_blank_out_huandao == 1 && l_start >= 16) || flag_blank_out_huandao == 0))
                    {
                        jiansu_flag = 0;
                        byte j = 0;
                        byte youguai_y = r_sec_start;
                        byte youguai_x = 0;
                        byte leftguai_y = 0;
                        byte leftguai_x = lefetline[0];
                        setText用户自定义("左线最后一行所在列数" + lefetline[break_hangshu]);
                        if (left_turn_down[0] != 0 && left_turn_down[0] <= 40 && left_turn_down[1]>=140)
                        {
                            leftguai_y = (byte)left_turn_down[0];
                            leftguai_x = (byte)left_turn_down[1];
                        }
                        if (r_sec_start >= 10)
                        {
                            youguai_y = r_sec_start;
                        }
                        else
                        {
                            youguai_y = break_hangshu;
                        }
                        if (l_start >= 5) flag_blank_out_huandao = 1;
                        setText用户自定义("l_start" + l_start);
                        SetText("找到右上拐点");
                        SetText("右上拐点坐标:" + youguai_y + "  " + youguai_x);
                        SetText("找到左下拐点");
                        SetText("左下拐点坐标:" + leftguai_y + "  " + leftguai_x);
                        //开始拉线
                        //if (youguai_x <= 1 && youguai_y <= 25)
                        //{
                            youguai_y = break_hangshu;
                            if (lefetline[break_hangshu] <= 55)
                            {
                                youguai_x = lefetline[break_hangshu];
                            } 
                       // }
                        int delta = youguai_y - leftguai_y;
                        if (delta == 0) delta = 1;
                        float k = (youguai_x - leftguai_x) * 1.0f / delta;
                        float b = leftguai_x - k * leftguai_y;
                        for (j = (byte)leftguai_y; j <= (byte)youguai_y; j++)
                        {
                            int jicun = ((int)(k * j + b));
                            if (jicun >= 185) jicun = 185;
                            else if (jicun <= 0) jicun = 0;
                            lefetline[j] = (byte)jicun;
                            //纠正右线
                            if (rightline[j] > lefetline[j]) rightline[j] = lefetline[j];
                        }
                        if (youguai_y <= 27)
                        {
                            for (j = youguai_y; j <= break_hangshu; j++)
                            {
                                rightline[j] = 0;
                                lefetline[j] = 0;
                            }
                        }
                    }
                    else if (type == 8)
                    {
                        flag_blank_out_huandao = 0;
                    }
                }
            }
    
            void juge_left_succesive_and_if_k_limit()
            {
                //可能是环岛的地带                                                                -0.17
                if (podao_flag == 0 && huandao_flag_R_L != 1 && huandao_memory <= 5 && k_left < -0.03 && k_left > -1.5 && flag_find_huan_rightmiddle_point == 1 && rou_of_left <= 380 && last_rou_of_left <= 380 && l_start <= 20)
                {
                    /*******行驶到环岛出口或者在行驶到环岛出口前********/
                    if (huandao_memory <= 3 && flag_rukou2 == 0)
                    {                                                       //    30        
                        if (right_jiao == 1 &&
                            ((right_turn_middle[0] >= 28 && r_start >= 14 && rightline[5] <= 10 && fiv_width[10] >= 130 && fiv_width[15] <= 183 && fiv_width[20] <= 181 && fiv_width[22] <= 180 && rou_of_right >= 1800 && last_rou_of_right >= 1800 && !(right_turn_up[0] <= 30 && right_turn_up[0] >= 3 && left_turn_up[0] <= 30 && left_turn_up[0] >= 3) && fiv_width[40] <= 100)
                            || (rightline[5] <= 10 && r_start >= 14 && break_hangshu - long_turn_flag_left <= 5 && break_hangshu - long_turn_flag_right > 10 && fiv_width[10] >= 161 && fiv_width[15] >= 157 && fiv_width[20] >= 153 && fiv_width[25] >= 127 && fiv_width[40] <= 100 && flag_shizi == 0)
                            || (rightline[5] <= 10 && r_start >= 14 && break_hangshu - long_turn_flag_left <= 5 && break_hangshu - long_turn_flag_right > 10 && fiv_width[10] >= 141 && fiv_width[10] <= 158 && fiv_width[15] >= 137 && fiv_width[15] <= 154 && fiv_width[20] >= 132 && fiv_width[20] <= 149 && fiv_width[25] >= 127 && fiv_width[25] <= 145 && fiv_width[40] <= 100 && flag_shizi == 0)
                            || (rightline[5] <= 10 && r_start >= 14 && break_hangshu - long_turn_flag_left <= 3 && break_hangshu - long_turn_flag_right > 7 && fiv_width[10] >= 133 && fiv_width[10] <= 158 && fiv_width[15] >= 128 && fiv_width[15] <= 154 && fiv_width[20] >= 120 && fiv_width[20] <= 149 && fiv_width[25] >= 113 && fiv_width[25] <= 145 && fiv_width[40] <= 100 && flag_shizi == 0)
                            || (huandao_size == 100 && r_start >= 30 && break_hangshu - long_turn_flag_left <= 2 && break_hangshu - long_turn_flag_right > 8 && fiv_width[10] >= 110 && centerline[0] <= 80 && fiv_width[10] <= 130 && fiv_width[15] >= 105 && fiv_width[15] <= 110 && fiv_width[20] >= 99 && fiv_width[20] <= 115 && fiv_width[25] >= 90 && fiv_width[25] <= 100 && fiv_width[40] <= 100 && flag_shizi == 0)
                            )
                            )
                        {
                            //setText用户自定义("1");
                            huandao_flag = 1;
                            huandao_flag_R_L = 2;
                            // SetText("行驶到环岛出口(没进环岛呢)");
                            huandao_memory = 3;
                            huandao_procedure_variable = 1;
                        }
                        else if (huandao_procedure_variable == 0 && right_turn_down[0] <= 25 && right_turn_down[0] > 0 && ((rou_of_right >= 7000 && last_rou_of_right >= 8000) || (long_turn_flag_left >= 50 && long_turn_flag_right < 20 && last_rou_of_right >= 1000)))
                        {
                            huandao_flag = 1;
                            huandao_flag_R_L = 2;
                            huandao_memory = 2;
                            // SetText("行驶到环岛出口前(没进环岛呢)(近)");       30                    条件放松一点
                            if (/*right_turn_down[0] <= 10 &&*/ (rightline[5] <= 10 && right_turn_middle[0] >= 28 && r_start >= 14 && fiv_width[15] <= 183 && fiv_width[20] <= 183 && fiv_width[22] <= 183 && rou_of_right >= 1800 && last_rou_of_right >= 1800 && !(right_turn_up[0] <= 30 && right_turn_up[0] >= 3 && left_turn_up[0] <= 30 && left_turn_up[0] >= 3) && fiv_width[40] <= 100)
                                || (rightline[5] <= 10 && r_start >= 14 && break_hangshu - long_turn_flag_left <= 5 && break_hangshu - long_turn_flag_right > 10 && fiv_width[10] >= 163 && fiv_width[15] >= 160 && fiv_width[20] >= 157 && fiv_width[25] >= 127 && fiv_width[40] <= 100 && flag_shizi == 0))
                            {
                                // SetText("行驶到环岛出口(没进环岛呢)");
                                huandao_memory = 3;
                                //setText用户自定义("2");
                                huandao_procedure_variable = 1;
                            }
                        }
                        else if (huandao_memory == 2 || huandao_memory == 1)
                        {
                            if (/*right_turn_down[0] <= 10 &&*/ (rightline[5] <= 10 && right_turn_middle[0] >= 28 && r_start >= 14 && fiv_width[15] <= 183 && fiv_width[20] <= 183 && fiv_width[22] <= 183 && rou_of_right >= 1800 && last_rou_of_right >= 1800 && !(right_turn_up[0] <= 30 && right_turn_up[0] >= 3 && left_turn_up[0] <= 30 && left_turn_up[0] >= 3))
                                 || (rightline[5] <= 10 && r_start >= 14 && break_hangshu - long_turn_flag_left <= 5 && break_hangshu - long_turn_flag_right > 10 && fiv_width[10] >= 163 && fiv_width[15] >= 160 && fiv_width[20] >= 157 && fiv_width[25] >= 127 && flag_shizi == 0))
                            {
                                // SetText("行驶到环岛出口(没进环岛呢)");
                                huandao_memory = 3;
                                huandao_procedure_variable = 1;
                            }
                        }
                        else if (huandao_procedure_variable == 0 && right_turn_down[0] > 25 && right_turn_down[0] <= 40 && rou_of_right >= 7000 && last_rou_of_right >= 8000 && long_turn_flag_left >= 50 && break_hangshu <= 66 && long_turn_flag <= 50 && fiv_width[10] > 110 && fiv_width[15] > 105)
                        {
                            huandao_flag = 1;
                            huandao_flag_R_L = 2;
                            huandao_memory = 1;
                            // SetText("行驶到环岛出口前(没进环岛呢)(远)");
                        }
                        else if (huandao_memory <= 4 && right_turn_middle[0] >= 20 /*&& right_turn_middle[0] <= 55*/ && huandao_procedure_variable == 1 && r_start <= 5)
                        {
                            huandao_flag = 1;
                            huandao_flag_R_L = 2;
                            flag_rukou = 1;
                            huandao_memory = 4;
                            // SetText("行驶到环岛入口前(没进环岛呢)");
                        }
                    }
                    else if (huandao_memory <= 4 && right_turn_middle[0] >= 20 && /*right_turn_middle[0] <= 55 &&*/ huandao_procedure_variable == 1 && r_start <= 5)
                    {
                        huandao_flag = 1;
                        flag_rukou = 1;
                        huandao_memory = 4;
                        // SetText("行驶到环岛入口前(没进环岛呢)");
                    }
                    else if (huandao_flag_R_L != 1 && huandao_memory <= 5 && huandao_memory >= 4 && fiv_width[10] >= 140 && fiv_width[15] >= 130 && ((right_turn_up[0] <= 33 && right_turn_up[0] > 0) || (leftline_duan_dian <= 30 && leftline_duan_dian != 0)) && huandao_procedure_variable == 1)
                    {
                        huandao_flag = 1;
                        flag_rukou2 = 1;
                        huandao_memory = 5;
                        // SetText("行驶到环岛入口(没进环岛呢)");                 
                    }
                }
                else if (huandao_flag_R_L != 1 && huandao_memory <= 4 && right_turn_middle[0] >= 20 && right_turn_middle[0] <= 55 && huandao_procedure_variable == 1 && r_start <= 5)
                {
                    huandao_flag = 1;
                    flag_rukou = 1;
                    huandao_memory = 4;
                }
                else if (huandao_flag_R_L != 1 && huandao_memory <= 5 && huandao_memory >= 4 && fiv_width[10] >= 140 && fiv_width[15] >= 130 && ((right_turn_up[0] <= 33 && right_turn_up[0] > 0) || (leftline_duan_dian <= 30 && leftline_duan_dian != 0)) && huandao_procedure_variable == 1)
                {
                    huandao_flag = 1;
                    flag_rukou2 = 1;
                    huandao_memory = 5;
                    //SetText("rightfindflag[1]" + rightfindflag[1]);
                    //SetText("rightfindflag[2]" + rightfindflag[2]);
                    if (huandao_flag_R_L != 1 && huandao_memory == 5 && (( fiv_width[10]<=133 &&fiv_width[15]<=123 && r_start>=20) ||(r_start >= 20 && leftfindflag[5] != 0 && leftfindflag[6] != 0 && leftfindflag[7] != 0 && leftfindflag[8] != 0 && lefetline[leftline_duan_dian] <= 65 && leftline_duan_dian <= 38) || (leftfindflag[5] != 0 && leftfindflag[6] != 0 && leftfindflag[7] != 0 && leftfindflag[8] != 0 && leftline_duan_dian <= 25)))
                    {
                        huandao_flag = 1;
                        huandao_memory = 6;
                        //flag_rukou = 3;
                        // SetText("已经进去了");
                    }
                    //SetText("行驶到环岛入口(没进环岛呢)");
                }
                else if (huandao_flag_R_L != 1 && huandao_memory == 5 && ((fiv_width[10] <= 133 && fiv_width[15] <= 123 && r_start >= 20)||(r_start >= 20 && leftfindflag[5] != 0 && leftfindflag[6] != 0 && leftfindflag[7] != 0 && leftfindflag[8] != 0 && lostleft_times <= 10 && leftline_duan_dian <= 42) || (r_start >= 20 && leftfindflag[5] != 0 && leftfindflag[6] != 0 && leftfindflag[7] != 0 && leftfindflag[8] != 0 && leftline_duan_dian <= 38) || (leftfindflag[5] != 0 && leftfindflag[6] != 0 && leftfindflag[7] != 0 && leftfindflag[8] != 0 && leftline_duan_dian <= 25)))
                {
                    huandao_flag = 1;
                    huandao_memory = 6;
                    //flag_rukou = 3;
                    // SetText("已经进去了");
                }
                else if (huandao_flag_R_L != 1 && huandao_memory == 6 && left_turn_down[0] >= 1 && left_turn_down[0] <= 27 && left_turn_down[1] > 25 && flag_memory_6 >= 4)
                {
                    huandao_flag = 1;
                    huandao_memory = 7;
                    //SetText("出环了");
                }
                else if (huandao_flag_R_L != 1 && huandao_memory == 7 && (My_Abs(right_turn_up[0] - (l_start - 4)) >= 5) && (fiv_width[10] < 182 && fiv_width[15] < 182)
                    &&(((left_turn_down[0] == 0 || left_turn_down[0]>=43) && right_turn_up[0] >= 15 && right_turn_up[0] <= 51 && right_turn_up[1] <= 100 && r_start >= 26 && rou_of_left <= 5000 /*&& rightline[break_hangshu] < 85*/)
                    || ((left_turn_down[0] == 0 || left_turn_down[0] >= 43) && right_turn_up[0] >= 15 && right_turn_up[0] <= 51 && right_turn_up[1] >= 20 && right_turn_up[1] <= 100 && rou_of_left <= 5000 /*&& rightline[break_hangshu] < 85*/)
                    || ((left_turn_down[0] == 0 || left_turn_down[0] >= 43) && long_turn_flag_left >= 40 && k_left >= -1.5 && k_left < 0 && lefetline[0] < 155 && l_first_notget >= 40/*&& rou_of_left <= 5000 && rightline[break_hangshu] < 85*/)
                    || ((left_turn_down[0] == 0 || left_turn_down[0] >= 43) && right_turn_up[0] >= 35 && right_turn_up[0] <= 51 && right_turn_up[1] >= 20 && right_turn_up[1] <= 100 && rou_of_left <= 5000)
                    || ((left_turn_down[0] == 0 || left_turn_down[0] >= 43) && huandao_size ==50 && right_turn_up[0] >= 15 && right_turn_up[0] <= 51 && right_turn_up[1] >= 10 && right_turn_up[1] <= 50 && rou_of_left <= 5000)))
                {
                    huandao_flag = 1;
                    huandao_memory = 8;
                    SetText("第二次到入口了");
                }
                else if (huandao_flag_R_L != 1 && ((fps_out_huan_island >= 10 && huandao_size >= 80) || (huandao_size <= 70)) && huandao_memory >= 8 && (fps_out_huan_island >= fps_set_out_HUAN_Island || (
                    ((right_turn_up[0] < 25 && right_turn_up[0] != 0) || ((right_turn_up[0] >= 50 || right_turn_up[0] == 0) && fiv_width[10] >= 120 && fiv_width[10] <= 135 && fiv_width[15] >= 110 && fiv_width[15] <= 128))
                    || (fiv_width[30] >= 60 && fiv_width[30] <= 103 && fiv_width[25] >= 68 && fiv_width[25] <= 115 && (My_Abs(long_turn_flag_left - long_turn_flag_right) <= 5 || (lostleft_times == 0 && lostright_times == 0))))
                    && ((rightfindflag[15] == 1 && rightfindflag[16] == 1 && rightfindflag[17] == 1 && rightfindflag[18] == 1) || (r_sec_start == 0 && l_sec_start == 0))))
                {
                    huandao_memory = 9;
                    huan_order++;
                    cross_road_times++;
                    //SetText("完全脱离环岛,可以清除标志了");
                    clear_huandao_data();
    
                }
                R_mend_leftline_right_island(huandao_memory, huandao_flag_R_L);
                R_mend_rightline_right_island(huandao_memory, huandao_flag_R_L);
                last_memory = huandao_memory;
                if (huandao_memory == 8 && huandao_flag_R_L != 1)
                {
                    fps_out_huan_island++;
                    setText用户自定义("fps_out_huan_island" + fps_out_huan_island);
                }
                if (huandao_memory >= 1 && huandao_flag_R_L != 1)
                {
                    setText用户自定义("huandaosize" + huandao_size);
                }
                byte j = 0;
                if (huandao_memory <= 5 && huandao_memory != 0)
                {
                    for (j = 0; j < 70; j++)
                    {
                        //LCenter[j] = forecast_centerline[j];
                        centerline[j] = (byte)((lefetline[j] + rightline[j]) / 2);
                        LCenter[j] = centerline[j];
                        L_black[j] = lefetline[j];
                        R_black[j] = rightline[j];
                    }
                }
                else
                {
                    for (j = 0; j < break_hangshu; j++)
                    {
                        //LCenter[j] = forecast_centerline[j];
                        centerline[j] = (byte)((lefetline[j] + rightline[j]) / 2);
                        LCenter[j] = centerline[j];
                        L_black[j] = lefetline[j];
                        R_black[j] = rightline[j];
                    }
                }
                show_condition_of_huan();
            }
    
    展开全文
  • 5电感稳定姿态进环岛写在前面 写在前面 我写了一篇总的博客,分享了我参加了十五届智能车竞赛的经历哦~ 2020第十五届全国大学生智能汽车竞赛——基础四轮组入门看这一篇就够了!
  • 处理传感器漂移位置的方法有哪些? 传感器是一种常用的检测设备,已... 以下博扬智能将为您详细介绍处理传感器漂移的处理方法。    传感器零漂移的原因很多。 例如,对于压力传感器,电桥电路中的组件参数不对...
  • 原标题:山东宁川水处理:电磁阀常见故障与解决方法怎么处理电磁阀的故障电磁阀线圈的额定电压有DC12V、DC24V、AC24V(50/60Hz)、AC110V(50/60Hz)、AC220V(50/60Hz)、AC380V(50/60Hz)。一般在电气设计时要么采用AC220...
  • 原标题:UV漆与TPU智能手表套附着力差解决方法之TPU处理剂TPU塑胶底材具有耐油、耐磨、抗撕裂等特点,同时其拉伸强度高、伸长率大,变形率较低,因此在被广泛的应用于手机护套、智能手表套等3C配件领域。其表面处理...
  • 环岛出现问题: 这时候应该用左上点来进行修补。检查为何没有补线。 关键是四状态和五状态的切换 修改参数为30; 效果有所改善,延时了状态5的到来。 问题2: 接下来的问题: 状态7的问题: 状态7问题修复, ...
  • 智能车竞赛四轮组程序代码,能实现基础巡线,环岛识别,十字路口识别
  • 智能车制作

    2021-08-10 11:29:01
    文章目录前言一、智能车是什么智能车总体概要比赛内容二、为什么要参加智能车1.收获功利的角度看从体验的角度看三、备赛找队友找队友的四个方面:1:意愿2:责任心3:日常表现4:时间PS:最好不要找好朋友组队 前言 ...
  • 电磁滤波算法,支持全国大学生智能汽车竞赛,电磁设计,支持全国大学生智能汽车竞赛
  • 送给大二做智能车的同学们 ——秋名山车神队 电磁竞速组 您们好,刚入手智能车可能不知所措,会浪费很多的时间,不知所措,我把这一年走的弯路告诉大家,让大家开始就有一个目标,快速进入实验室的状态,首先我要...
  • 基于电磁传感器的,主控MCU为K60的电磁四轮智能车完整程序
  • 智能车电磁组完整程序
  • 个人几年前全国大学生飞思卡尔智能车比赛源码。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 同步智能车程序

    2018-02-22 13:39:32
    来源山东省机器人大赛,同步智能机器人程序。智能车用stm32主控,编码器测速,CCD模块检测黑线,保证两辆沿黑线同步运行,且连接杆保持稳定。多次测试,在实验室条件下可正常使用。
  • 本源代码为飞思卡尔智能车竞赛完整程序,具有很强的移植性,参考价值高,非常适合新手参考学习,祝参赛同学取得好的成绩。
  • 恩智浦智能车一些常见的问题

    千次阅读 2019-08-03 16:37:40
    关于我在初次制作智能车遇到的各种问题的一些简单解决方法 智能车系统一般由电源模块、传感器模块、直流电机驱动模块、路径识别模块、通讯及调试模块、单片机模块等组成。 电源模块 传感器模块 直流电机驱动模块 ...
  • 用于处理环岛
  • 我的第一辆智能车—电磁循迹智能车 以下是所用的模块: 舵机,电机,L298N驱动模块,PID算法,OLED,电磁杆,ADC多路采集配置DMA,干簧管,普通GPIO口使用。 1.舵机模块 舵机,三条线路,一条GND,一条VCC,一条给予...
  • 基于mc9s12xs128的智能汽车程序代码,摄像头组
  • PID控制器参数选择的方法很多,例如试凑法、临界比例度法、扩充临界比例度法等。
  • 计算机控制与测试系统实验,通过电磁传感器得到赛道两端的电磁数据,在经过PID控制舵机与电机,区分于图像处理与直立式小车,能过完成弯道、环岛、十字路口等特殊路段,并且完成整个赛道后自动泊车。
  • 飞思卡尔智能车竞赛算法主要是PID算法。
  • 智能车Code review】——拐点的寻找

    千次阅读 多人点赞 2020-08-09 11:44:30
    ROUNDISLAND:环岛拐点 rightfindflag[i]:表示第i行的右线是否被找到,1为找到,0为没有找到 flag_find_huan_rightdown_point :找到环岛右下拐点标志 flag_find_huan_rightmiddle_point:找到环岛右中拐点标志 找拐点...
  • 飞思卡尔智能车资料,是关于智能车的光电组资料,非常好
  • //进出环岛补线 if(ruhuandao_you_flag==1||chalu_buxian_you==1 ) { left_heixian[y]=right_heixian[y]-2*half_width_group[y]; } if(ruhuandao_zuo_flag==1||chalu_buxian_zuo&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 384
精华内容 153
关键字:

智能车环岛