protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (CurrentLightRule == null)
{
StopCore();
return;
}
var result = CurrentLightRule.Check(signalInfo);
switch (result)
{
case RuleExecutionResult.Continue:
return;
case RuleExecutionResult.Break:
case RuleExecutionResult.Finish:
////获取下一个项目
//var next = ActivedRules.OfType<ILightRule>().SkipWhile(x => x != CurrentLightRule).Skip(1).FirstOrDefault();
//SetCurrentLightRule(next);
//获取下一个灯光规则
currentLightRuleIndex++;
SetCurrentLightRule(currentLightRuleIndex);
return;
case RuleExecutionResult.FinishExamItem:
break;
}
}
/// <summary>
/// 查找同方向的最近点位
/// </summary>
/// <param name="signalInfo"></param>
/// <returns></returns>
public MapPoint[] Search(CarSignalInfo signalInfo)
{
//无航向角（停车时）不搜索点位
if (MapPoints.Length == 0 || !signalInfo.Gps.AngleDegrees.IsValidAngle() || signalInfo.CarState == CarState.Stop)
{
return(new MapPoint[0]);
}
var gps = signalInfo.Gps;
//
//搜索20米内同方向（相同15角度类）的所有点位
var query = from a in MapPoints
where
a.PointType != MapPointType.Normal &&
GeoHelper.IsBetweenDiffAngle(a.Point.Angle, gps.AngleDegrees, 15) &&
(GeoHelper.GetDistance(a.Point.Longitude, a.Point.Latitude, gps.LongitudeDegrees, gps.LatitudeDegrees) <= 15)
select a;
var items = query.ToArray();
if (items.Any())
{
foreach (var _item in items)
{
Logger.InfoFormat("搜索符合点：{0}-{1}-{2}-{3}", _item.Name, _item.Point.Longitude, _item.Point.Latitude, _item.Point.Angle);
Logger.InfoFormat("当前GPS：{0}-{1}-{2}", signalInfo.Gps.LongitudeDegrees, signalInfo.Gps.LatitudeDegrees, signalInfo.Gps.AngleDegrees);
}
}
return(items);
//return null;
}
private void OnCarSignalReceived(CarSignalReceivedMessage message)
{
try
{
if (message.CarSignal == null || message.CarSignal.Gps == null)
{
return;
}
tempMessage = message;
carSignal = message.CarSignal;
RunOnUiThread(UpdateCarSensorState);
if (CurentItemName.Contains("上车"))
{
RunOnUiThread(() => {
string carhead = message.CarSignal.Sensor.ArrivedHeadstock ? "是" : "否";
string cartail = message.CarSignal.Sensor.ArrivedTailstock ? "是" : "否";
tvExamItem.Text = $"当前项目:{CurentItemName},车头:{carhead},车尾:{cartail}";
});
}
}
catch (Exception ex)
{
//Logger.Error("SanLianCarSignalReceived", ex.Message);
}
}
/// <summary>
/// 检测起步
/// </summary>
private void StartShockCheck(CarSignalInfo signalInfo)
{
if (!Settings.StartShockEnable)
{
return;
}
if (Settings.StartShockValue <= 0 || Settings.StartShockCount <= 0)
{
return;
}
if (!isBrokenStartShock)
{
if (initG && ((Math.Abs(signalInfo.AccelerationX - gx) > Settings.StartShockValue) || Math.Abs(signalInfo.AccelerationY - gy) > Settings.StartShockValue))
{
//Logger.InfoFormat("初始GX值：{0}，当前GX值：{1}。初始GY值：{2}，当前GY值：{3}",gx,signalInfo.AccelerationX,gy,signalInfo.AccelerationY);
cd_cnt += 1;
}
else
{
cd_cnt = 0;
}
if (cd_cnt >= Settings.StartShockCount)
{
isBrokenStartShock = true;
BreakRule(DeductionRuleCodes.RC40209);
}
}
}
/// <summary>
/// 检测手刹是否超时
/// </summary>
/// <param name="signalInfo"></param>
protected void CheckHandbrake(CarSignalInfo signalInfo)
{
//配置0，不检测手刹
if (Settings.PullOverHandbrakeTimeout <= 0)
{
PullOverStepState = PullOverStep.PullHandbrake;
return;
}
if (signalInfo.Sensor.Handbrake)
{
PullOverStepState = PullOverStep.PullHandbrake;
//检测手刹拉起时，是否脚刹有松开
if (!CheckedPulloverHandbrake)
{
CheckedPulloverHandbrake = true;
if (!signalInfo.Sensor.Brake)
{
BreakRule(DeductionRuleCodes.RC40608);
}
}
}
else
{
if (IsPullHandBrakeTimeOut())
{
PullOverStepState = PullOverStep.PullHandbrake;
BreakRule(DeductionRuleCodes.RC40607);
}
}
}
/// <summary>
/// 检查全程档位速度、时间
/// </summary>
/// <param name="signalInfo"></param>
private void CheckGlobalGearAndSpeed(CarSignalInfo signalInfo)
{
if (IsReachedGlobalGearContinuous)
{
return;
}
//无档位要求、或者有档位但速度和时间都小于0
if (Settings.GlobalContinuousGear == Gear.Neutral ||
(Settings.GlobalContinuousSpeed <= 0 && Settings.GlobalContinuousSeconds <= 0))
{
IsReachedGlobalGearContinuous = true;
return;
}
if (signalInfo.Sensor.Gear != Settings.GlobalContinuousGear)
{
StartCheckGlobalGearContinuous = null;
return;
}
//速度和时间都必须达到
if (Settings.GlobalContinuousSpeed > 0 && Settings.GlobalContinuousSeconds > 0)
{
if (signalInfo.SpeedInKmh >= Settings.GlobalContinuousSpeed)
{
if (!StartCheckGlobalGearContinuous.HasValue)
{
StartCheckGlobalGearContinuous = DateTime.Now;
}
}
else
{
StartCheckGlobalGearContinuous = null;
}
}
else if (Settings.GlobalContinuousSpeed > 0)
{
//速度达到，无时间要求
if (signalInfo.SpeedInKmh >= Settings.GlobalContinuousSpeed)
{
IsReachedGlobalGearContinuous = true;
}
}
else if (Settings.GlobalContinuousSeconds > 0)
{
//时间达到，无速度要求
if (!StartCheckGlobalGearContinuous.HasValue)
{
StartCheckGlobalGearContinuous = DateTime.Now;
}
}
if (!IsReachedGlobalGearContinuous &&
StartCheckGlobalGearContinuous.HasValue &&
(DateTime.Now - StartCheckGlobalGearContinuous.Value).TotalSeconds >= Settings.GlobalContinuousSeconds)
{
IsReachedGlobalGearContinuous = true;
}
}
protected virtual bool ValidDistance(CarSignalInfo signalInfo)
{
//if (StartDistance == -1 || StartDistance == 0)
//{
// var currentSignal = CarSignalSet.Query(DateTime.Now - TimeSpan.FromSeconds(12)).FirstOrDefault(s => s.Distance != 0);
// if (currentSignal != null)
// {
// StartDistance = currentSignal.Distance;
// StartAngle = currentSignal.BearingAngle;
// }
// Logger.Debug("ValidDistacnce", StartDistance.ToString());
//}
//if (StartDistance==0||StartDistance==-1)
//{
// MaxElapsedTime = new TimeSpan(0, 0, 10);
// //重新设置时间
// Logger.Debug(Name, "Valid Distance ExamItemBase MaxElapsedTime Reset");
// return true;
//}
//其实我是需要测试是否还有播报项目立即结束
//如果距离小于等于10米则直接重新设置距离默认100米
//如果距离不行就设置时间
//Todo:这个东西需要了解系统底层的一些框架架构呀
//Todo:
if (MaxDistance.HasValue && MaxDistance > 0 && signalInfo.Distance - StartDistance > MaxDistance)
{
Logger.DebugFormat("项目：{0}超过里程：{1}；{2}-{3}", this.Name, MaxDistance, StartDistance, signalInfo.Distance);
return(false);
}
return(true);
}
private Gear ParseGear(CarSignalInfo signalInfo)
{
var ratio = signalInfo.EngineRatio;
if (ratio <= 0)
{
return(Gear.Neutral);
}
if (ratio >= Settings.GearOneMinRatio && ratio <= Settings.GearOneMaxRatio)
{
return(Gear.One);
}
if (ratio >= Settings.GearTwoMinRatio && ratio <= Settings.GearTwoMaxRatio)
{
return(Gear.Two);
}
if (ratio >= Settings.GearThreeMinRatio && ratio <= Settings.GearThreeMaxRatio)
{
return(Gear.Three);
}
if (ratio >= Settings.GearFourMinRatio && ratio <= Settings.GearFourMaxRatio)
{
return(Gear.Four);
}
if (ratio >= Settings.GearFiveMinRatio && ratio <= Settings.GearFiveMaxRatio)
{
return(Gear.Five);
}
return(Gear.Neutral);
}
protected virtual void ProcessHandbrake(CarSignalInfo signalInfo)
{
// signalInfo.Sensor.Handbrake
HandBrakeQueue.Enqueue(signalInfo.Sensor.Handbrake);
if (HandBrakeQueue.Count >= AmoutCount)
{
HandBrakeQueue.Dequeue();
}
//如果手刹没有拉起不管
//手刹没有拉起是false
if (!signalInfo.Sensor.Handbrake)
{
return;
}
//首杀,进行配置延时
//
if (HandBrakeQueue.Count > 10)
{
int delayCount = 1 * 5;
if (HandBrakeQueue.Count < delayCount)
{
delayCount = HandBrakeQueue.Count - 3;
}
signalInfo.Sensor.Handbrake = HandBrakeQueue.Reverse().Take(delayCount).Any(x => x == true);
}
}
protected virtual void ProcessIsValid(CarSignalInfo signalInfo)
{
if (signalInfo.Gps == null)
{
signalInfo.IsGpsValid = false;
Logger.Error("ProcessIsValid:" + string.Join(",", signalInfo.commands));
return;
}
//有卫星数量
signalInfo.IsGpsValid = signalInfo.Gps.FixedSatelliteCount > 0 && signalInfo.Gps.LatitudeDegrees > 0 && signalInfo.Gps.LongitudeDegrees > 0;
//对于异常速度进行处理
if (signalInfo.Sensor.SpeedInKmh >= 0 && signalInfo.Sensor.SpeedInKmh <= Constants.InvalidSpeedLimit)
{
signalInfo.IsSensorValid = true;
return;
}
//对于异常转速比进行处理
//对最近2秒钟的信号进行判断分析，如果持续无效信息则返回
var queryTime = DateTime.Now.AddSeconds(-2);
var allInvalid = CarSignalSet.TakeWhile(x => x.RecordTime > queryTime).All(x => x.Sensor.SpeedInKmh <0 && x.Sensor.SpeedInKmh> Constants.InvalidSpeedLimit);
signalInfo.IsSensorValid = !allInvalid;
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (signalInfo.Sensor.RightIndicatorLight)
{
hasRightIndicator = true;
}
if (signalInfo.Sensor.LeftIndicatorLight)
{
hasLeftIndicator = true;
}
if (signalInfo.Sensor.Brake)
{
braked = true;
}
//if (signalInfo.Sensor.RightIndicatorLight)
//{
// Constants.IsHaveRightLight = true;
//}
base.ExecuteCore(signalInfo);
//如果必须踩刹车
if (CheckBrakeRequired && _hasLoosenBrake && Constants.IsFirstTurnRight == false)
{
CheckBrakeVoice(signalInfo);
}
}
protected virtual void ProcessSafeBelt(CarSignalInfo signalInfo)
{
SafetyBeltQueue.Enqueue(signalInfo.Sensor.SafetyBelt);
if (SafetyBeltQueue.Count >= AmoutCount)
{
SafetyBeltQueue.Dequeue();
}
if (signalInfo.Sensor.SafetyBelt)
{
return;
}
//安全带,进行配置延时
//
if (SafetyBeltQueue.Count > 10)
{
int delayCount = (int)Settings.CommonExamItemsSareBeltTimeOut * 5;
if (SafetyBeltQueue.Count < delayCount)
{
delayCount = SafetyBeltQueue.Count - 3;
}
signalInfo.Sensor.SafetyBelt = SafetyBeltQueue.Reverse().Take(delayCount).Any(x => x == true);
}
}
/// <summary>
/// 执行任务的核心方法
/// </summary>
/// <param name="signalInfo"></param>
protected virtual void ExecuteCore(CarSignalInfo signalInfo)
{
var finishedRules = new List <IRule>();
if (Rules != null)
{
foreach (var rule in Rules)
{
var result = rule.Check(signalInfo);
switch (result)
{
case RuleExecutionResult.Continue:
break;
case RuleExecutionResult.Break:
return;
case RuleExecutionResult.Finish:
finishedRules.Add(rule);
break;
case RuleExecutionResult.FinishExamItem:
this.StopAsync().Wait();
return;
}
}
}
//移除所有完成的规则类；
Rules.RemoveRange(finishedRules);
}
protected virtual void ProcessGearWithPullLine(CarSignalInfo signalInfo)
{
signalInfo.Sensor.IsNeutral = false;
if (!signalInfo.Sensor.PullLineD1 && !signalInfo.Sensor.PullLineD2 && !signalInfo.Sensor.PullLineD3 && !signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.IsNeutral = true;
signalInfo.Sensor.Gear = Gear.Neutral;
}
else if (signalInfo.Sensor.PullLineD1 && signalInfo.Sensor.PullLineD2 && !signalInfo.Sensor.PullLineD3 && !signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.Gear = Gear.One;
}
else if (!signalInfo.Sensor.PullLineD1 && signalInfo.Sensor.PullLineD2 && !signalInfo.Sensor.PullLineD3 && signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.Gear = Gear.Two;
}
else if (signalInfo.Sensor.PullLineD1 && !signalInfo.Sensor.PullLineD2 && !signalInfo.Sensor.PullLineD3 && !signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.Gear = Gear.Three;
}
else if (!signalInfo.Sensor.PullLineD1 && !signalInfo.Sensor.PullLineD2 && !signalInfo.Sensor.PullLineD3 && signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.Gear = Gear.Four;
}
else if (signalInfo.Sensor.PullLineD1 && !signalInfo.Sensor.PullLineD2 && signalInfo.Sensor.PullLineD3 && !signalInfo.Sensor.PullLineD4)
{
signalInfo.Sensor.Gear = Gear.Five;
}
}
private void OnCarSignalReceived(CarSignalReceivedMessage message)
{
try
{
if (message.CarSignal == null || message.CarSignal.Gps == null)
{
return;
}
tempMessage = message;
carSignal = message.CarSignal;
if (carSignal.Distance >= ExamDistance && IsAutoTriggerPullOver && IsTriggerPullOver == false)
{
//启动靠边停车
Module.StartExamItemManualAsync(ExamContext, ExamItemCodes.PullOver, null);
IsTriggerPullOver = true;
return;
}
RunOnUiThread(UpdateCarSensorState);
}
catch (Exception ex)
{
Logger.Error("HuaZhongSensorCarSignalReceived", ex.Message);
}
}
protected virtual void ProcessGyroscope(CarSignalInfo carSignalInfo, string grpoBody)
{
var acc = ParseAcc(grpoBody);
var angle = ParseAngle(grpoBody);
var gyro = ParseGyro(grpoBody);
if (acc != null)
{
carSignalInfo.AccelerationX = acc[0];
carSignalInfo.AccelerationY = acc[1];
carSignalInfo.AccelerationZ = acc[2];
}
if (gyro != null)
{
carSignalInfo.AngleSpeedX = gyro[0];
carSignalInfo.AngleSpeedY = gyro[1];
carSignalInfo.AngleSpeedZ = gyro[2];
}
if (angle != null)
{
carSignalInfo.AngleX = angle[0];
carSignalInfo.AngleY = angle[1];
carSignalInfo.AngleZ = angle[2];
}
}
/// <summary>
/// 执行考试项目
/// </summary>
/// <param name="signalInfo"></param>
public void Execute(CarSignalInfo signalInfo)
{
var result = BeforeExecute(signalInfo);
if (!result)
{
return;
}
CurrentDistance = signalInfo.Distance;
try
{
StaticClass.StaticDistance = signalInfo.Distance;
StaticClass.StaticAngle = signalInfo.BearingAngle;
}
catch (Exception ex)
{
Logger.Error("ExamItemBaseExecute", ex.Message);
}
if (!InitializedExamParms)
{
InitializedExamParms = InitExamParms(signalInfo);
}
ExecuteCore(signalInfo);
if (IsEndStartCore)
{
// Logger.DebugFormat("IsEndStartCore");
AfterExecute(signalInfo);
}
}
public virtual void Execute(CarSignalInfo signalInfo)
{
if (IsRunning)
{
Run(signalInfo);
}
}
/// <summary>
/// 项目执行
/// </summary>
/// <param name="signalInfo"></param>
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (!InitializedExamParms)
{
return;
}
//未在规则定的 距离/时间 完成加减档，由基类完成
//未达到最小时间忽略
//if (GearLowestMilliseconds > 0 && (DateTime.Now - StartTime).TotalMilliseconds < GearLowestMilliseconds)
// return;
if (IsSuccess)
{
//完成操作后也要距离才结束加减档操作
//base.StopCore();
return;
}
//自动挡不评判档位
if (Settings.LicenseC1)
{
IsSuccess = CheckGears();
}
else
{
//自动挡不进行评判，等待超距
IsSuccess = true;
}
}
protected override void CheckBrakeVoice(CarSignalInfo signalInfo)
{
if (signalInfo.Sensor.Brake)
{
hasBraked = true;
}
base.CheckBrakeVoice(signalInfo);
}
/// <summary>
/// 检测除左转外的其他灯
/// </summary>
private void CheckAllLight(CarSignalInfo signalInfo)
{
if (signalInfo.Sensor.OutlineLight || signalInfo.Sensor.LowBeam || signalInfo.Sensor.HighBeam ||
signalInfo.Sensor.FogLight || signalInfo.Sensor.CautionLight || signalInfo.Sensor.RightIndicatorLight)
{
CheckRule(true, DeductionRuleCodes.RC41609);
}
}
protected override bool InitExamParms(CarSignalInfo signalInfo)
{
if (signalInfo.Sensor.Engine)
{
IsStartEngine = true;
}
return(base.InitExamParms(signalInfo));
}
/// <summary>
/// 停车后则语音播报行人已通过，然后结束考试
/// </summary>
/// <param name="signalInfo"></param>
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (signalInfo.CarState == CarState.Stop)
{
Speaker.PlayAudioAsync("行人已通过", SpeechPriority.Normal);
StopCore();
}
}
/// <summary>
/// 处理OBD转向灯， 20170701，
/// </summary>
/// <param name="inputs"></param>
public void ProcessOBDIndicatorLight(int[] inputs, CarSignalInfo carSignalInfo)
{
queueInput.Enqueue(inputs);
if (queueInput.Count > signalRate)
{
queueInput.Dequeue();
}
var tempQueue = queueInput.Reverse().Take(signalRate - 1);
carSignalInfo.ObdSensor.CautionLight = false;
carSignalInfo.ObdSensor.LeftIndicatorLight = false;
carSignalInfo.ObdSensor.RightIndicatorLight = false;
foreach (var intps in tempQueue)
{
var tempsensor = ReadDigitalInput(intps, ObdCautionLightAddress, false);
if (tempsensor)
{
carSignalInfo.ObdSensor.CautionLight = true;
carSignalInfo.ObdSensor.LeftIndicatorLight = false;
carSignalInfo.ObdSensor.RightIndicatorLight = false;
return;
}
}
//左转，右转都有则报警灯
foreach (var intps in tempQueue)
{
var tempsensor = ReadDigitalInput(intps, ObdLeftIndicatorLightAddress, false);
var tempsensor2 = ReadDigitalInput(intps, ObdRightIndicatorLightAddress, false);
if (tempsensor && tempsensor2)
{
carSignalInfo.ObdSensor.CautionLight = true;
carSignalInfo.ObdSensor.LeftIndicatorLight = false;
carSignalInfo.ObdSensor.RightIndicatorLight = false;
return;
}
}
//左转
foreach (var intps in tempQueue)
{
var tempsensor = ReadDigitalInput(intps, ObdLeftIndicatorLightAddress, false);
if (tempsensor)
{
carSignalInfo.ObdSensor.LeftIndicatorLight = true;
return;
}
}
//右转
foreach (var intps in tempQueue)
{
var tempsensor = ReadDigitalInput(intps, ObdRightIndicatorLightAddress, false);
if (tempsensor)
{
carSignalInfo.ObdSensor.RightIndicatorLight = true;
return;
}
}
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
//如果必须踩刹车
base.ExecuteCore(signalInfo);
if (CheckBrakeRequired && _hasLoosenBrake && Constants.IsFirstTurnLeft == false)
{
CheckBrakeVoice(signalInfo);
}
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
//在准备距离不检测
if (signalInfo.Distance - StraightDrivingStartDistance < Settings.StraightDrivingPrepareDistance)
{
return;
}
///停车不检测角度
if (signalInfo.CarState == CarState.Stop)
{
return;
}
//判断是否超过速度限制，20160406
if (Settings.StraightDrivingSpeedMinLimit > 0 && signalInfo.SpeedInKmh < Settings.StraightDrivingSpeedMinLimit)
{
Logger.Error("blow DrivingSpeedMinLimit");
IsUnderSpeedMinLimit = true;
}
if (Settings.StraightDrivingReachSpeed > 0 && signalInfo.SpeedInKmh > Settings.StraightDrivingReachSpeed)
{
IsReachSpeed = true;
}
//
if (Settings.StraightDrivingSpeedMaxLimit > 0 &&
signalInfo.SpeedInKmh > Settings.StraightDrivingSpeedMaxLimit)
{
IsAboveSpeedMaxLimit = true;
}
//
//直线行驶开始时间，开始的时候记录时间
if (!StraightDrivingStartTime.HasValue)
{
if (signalInfo.BearingAngle.IsValidAngle())
{
StraightDrivingStartOffsetAngle = signalInfo.BearingAngle;
StraightDrivingStartTime = DateTime.Now;
}
}
//如果角度无效返回不检测
if (!signalInfo.BearingAngle.IsValidAngle() || !StraightDrivingStartOffsetAngle.IsValidAngle())
{
return;
}
if (!IsBroken_RC40301 && Settings.StraightDrivingMaxOffsetAngle > 0 &&
!GeoHelper.IsBetweenDiffAngle(signalInfo.BearingAngle, StraightDrivingStartOffsetAngle, Settings.StraightDrivingMaxOffsetAngle))
{
IsBroken_RC40301 = true;
//当偏移角度过大时触发规则
BreakRule(DeductionRuleCodes.RC40301);
return;
}
base.ExecuteCore(signalInfo);
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (!IsLoudSpeakerCheck && signalInfo.Sensor.Loudspeaker)
{
IsLoudSpeakerCheck = true;
}
base.ExecuteCore(signalInfo);
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
if (!_hasChecked && ((DateTime.Now - StartTime).TotalSeconds > 11 || signalInfo.SpeedInKmh > 5))
{
_hasChecked = true;
CheckAllLight(signalInfo);
}
base.ExecuteCore(signalInfo);
}
protected override bool InitExamParms(CarSignalInfo signalInfo)
{
//TurnRoundNumber = Context.Properties["Road"].ToString();
StartTime = DateTime.Now;
//if (Settings.RoundaboutVoice)
//Speaker.PlayAudioAsync(RoundaboutVoiceFile, Infrastructure.Speech.SpeechPriority.Highest);
return(base.InitExamParms(signalInfo));
}
protected override void ExecuteCore(CarSignalInfo signalInfo)
{
base.ExecuteCore(signalInfo);
//如果必须踩刹车
if (CheckBrakeRequired && _hasLoosenBrake)
{
CheckBrakeVoice(signalInfo);
}
}
