fctom1215
2020-03-15 e021e593c56c3338ddddd35d7817ef6cd2fa504b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
//
// Created by YY on 2020/3/9.
//
 
#include <cstdlib>
#include "../common/apptimer.h"
#include "dummy_light.h"
#include "../native-lib.h"
#include "../jni_log.h"
#include "../test_common/car_sensor.h"
 
#define DEBUG(fmt, args...)     LOGD("<dummy_light> <%s>: " fmt, __func__, ##args)
 
static struct RtkTime currRtkTime;
static struct dummy_light_exam *content;
static int contentNum;
static int currContent;
static int checkCnt;
static bool turn_left_active, flash_beam_active;
 
static void DummyLightCheckActive(union sigval sig);
static void ExamDummyLight(union sigval sig);
 
void StartDummyLightExam(struct dummy_light_exam *ptr, int num, const struct RtkTime* rtkTime)
{
    DEBUG("StartDummyLightExam");
    content = ptr;
    contentNum = num;
    currContent = 0;
    currRtkTime = *rtkTime;
 
    AppTimer_delete(DummyLightCheckActive);
    AppTimer_delete(ExamDummyLight);
    AppTimer_add(ExamDummyLight, D_SEC(2));
}
 
int ExecuteDummyLightExam(const struct RtkTime* rtkTime)
{
    currRtkTime = *rtkTime;
    return (currContent == contentNum)?2:1;
}
 
void DummyLightTTSDone(int id)
{
    DEBUG("DummyLightTTSDone %d", id);
    // 等语音播报完毕后计时
    if (id == 100) {
        AppTimer_add(DummyLightCheckActive, D_SEC(3), id);
    } else if (id == 101) {
        AppTimer_add(DummyLightCheckActive, D_SEC(1), id);
    } else if (id == OVERTAKE) {
        checkCnt = 0;
        turn_left_active = flash_beam_active = false;
        AppTimer_add(DummyLightCheckActive, D_SEC(1), id);
    } else {
        AppTimer_add(DummyLightCheckActive, D_SEC(5), id);
    }
}
 
static void DummyLightCheckActive(union sigval sig)
{
    AppTimer_delete(DummyLightCheckActive);
 
    DEBUG("DummyLightCheckActive %d", sig.sival_int);
 
    switch (sig.sival_int) {
        case DRIVE_AT_NIGHT:
        case TURN_ON_MAIN_BEAM_LAMP:
            if (ReadCarStatus(MAIN_BEAM_LAMP) != MAIN_BEAM_LIGHT) {
                AddExamFault(58, &currRtkTime);
            }
            break;
        case TURN_ON_DIPPED_LAMP:
        case BRIDGE_MEET_CAR:
        case FOLLOW_CAR:
            if (ReadCarStatus(DIPPED_BEAM_LAMP) != DIPPED_BEAM_LIGHT) {
                AddExamFault(58, &currRtkTime);
            }
            break;
        case DRIVE_IN_FOG:
            if (ReadCarStatus(FOG_LAMP) != FOG_LIGHT) {
                AddExamFault(58, &currRtkTime);
            }
            break;
        case THROUGE_CROSSWALK:
        case THROUGE_CURVE:
        case THROUGE_CROSSROADS:
            if (ReadCarStatus(FLASH_BEAM_LAMP) != FLASH_BEAM_LIGHT) {
                AddExamFault(58, &currRtkTime);
            }
            break;
        case OVERTAKE:
            if (++checkCnt < 5) {
                if (!flash_beam_active) {
                    if (ReadCarStatus(TURN_SIGNAL_LAMP) == LEFT_TURN_LIGHT) {
                        turn_left_active = true;
                    }
                }
                if (turn_left_active) {
                    if (ReadCarStatus(FLASH_BEAM_LAMP) == FLASH_BEAM_LIGHT) {
                        flash_beam_active = true;
                    }
                }
                AppTimer_add(DummyLightCheckActive, D_SEC(1), OVERTAKE);
                return;
            } else {
                if (!flash_beam_active || !turn_left_active) {
                    AddExamFault(58, &currRtkTime);
                }
            }
            break;
        case CAR_FAULT:
        case PARK_CAR_TEMP:
            if (ReadCarStatus(TURN_SIGNAL_LAMP) != HAZARD_LIGHTS) {
                AddExamFault(58, &currRtkTime);
            }
            break;
        default:
            break;
    }
 
    AppTimer_add(ExamDummyLight, D_SEC(1));
}
 
static void ExamDummyLight(union sigval sig)
{
    AppTimer_delete(ExamDummyLight);
 
    if (currContent < contentNum) {
        DEBUG("模拟灯光测试 %s", content[currContent].tts);
 
        PlayTTS(content[currContent].tts, content[currContent].item);
        currContent++;
    }
}