| | |
| | | test_items/turn_a90.cpp |
| | | test_items/area_exam.cpp |
| | | |
| | | test_items2/prepare.cpp |
| | | test_items2/common_check.cpp |
| | | test_items2/dummy_light.cpp |
| | | test_items2/road_exam.cpp |
| | |
| | | #ifndef _DEFS_H_ |
| | | #define _DEFS_H_ |
| | | |
| | | #include <stdint.h> |
| | | #include <stdbool.h> |
| | | #include <cstdint> |
| | | #include <cstdbool> |
| | | |
| | | #define ENABLE_DEBUG |
| | | |
| | |
| | | #include "test_common/car_sensor.h" |
| | | #include "test_items2/road_exam.h" |
| | | #include "test_items/area_exam.h" |
| | | #include "test_items2/prepare.h" |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<driver_test> <%s>: " fmt, __func__, ##args) |
| | | |
| | |
| | | static const int DEFAULT_START_CAR_MAX_RMP = 2500; |
| | | static const int DEFAULT_START_CAR_DISTANCE = 10; |
| | | static const double DEFAULT_START_CAR_OPEN_DOOR_DISTANCE = 1.0; |
| | | static const char DEFAULT_PREPARE_TTS[] = "请开始上车准备"; |
| | | static const char DEFAULT_TOUCH_LEFT_FRONT[] = "学员通过左前方"; |
| | | static const char DEFAULT_TOUCH_LEFT_REAR[] = "学员通过左后方"; |
| | | static const char DEFAULT_TOUCH_RIGHT_FRONT[] = "学员通过右前方"; |
| | | static const char DEFAULT_TOUCH_RIGHT_REAR[] = "学员通过右后方"; |
| | | static const char DEFAULT_START_ENGINE[] = "请启动发动机"; |
| | | static const char DEFAULT_START_CAR_BEGIN_TTS[] = "请起步,继续完成考试"; |
| | | static const char DEFAULT_START_CAR_END_TTS[] = "起步完成"; |
| | | static const int CHANGE_LANE_MAX_DISTANCE = 100; |
| | |
| | | examParam.start_car_max_rpm = DEFAULT_START_CAR_MAX_RMP; |
| | | examParam.start_car_limit_distance = DEFAULT_START_CAR_DISTANCE; |
| | | examParam.open_door_drive_allow_distance = DEFAULT_START_CAR_OPEN_DOOR_DISTANCE; |
| | | |
| | | examParam.prepare_tts = DEFAULT_PREPARE_TTS; |
| | | examParam.touch_leftfront_tts = DEFAULT_TOUCH_LEFT_FRONT; |
| | | examParam.touch_leftrear_tts = DEFAULT_TOUCH_LEFT_REAR; |
| | | examParam.touch_rightfront_tts = DEFAULT_TOUCH_RIGHT_FRONT; |
| | | examParam.touch_rightrear_tts = DEFAULT_TOUCH_RIGHT_REAR; |
| | | examParam.start_engine_tts = DEFAULT_START_ENGINE; |
| | | |
| | | examParam.start_car_begin_tts = DEFAULT_START_CAR_BEGIN_TTS; |
| | | examParam.start_car_end_tts = DEFAULT_START_CAR_END_TTS; |
| | | examParam.change_lane_limit_distance = CHANGE_LANE_MAX_DISTANCE; |
| | |
| | | |
| | | RoadMap.examScheme.assign(scheme.begin(), scheme.end()); |
| | | |
| | | DEBUG("得到新的路考地图 项目数量 %d", RoadMap.examScheme.size()); |
| | | DEBUG("得到路考项目方案 项目数量 %d", RoadMap.examScheme.size()); |
| | | } |
| | | |
| | | void SetCarMeasurePoint(double *basePoint, int *axial, int *left_front_tire, |
| | |
| | | { |
| | | DEBUG("获取模拟路考灯光测试项目 N = %d %d", n, ExamStart); |
| | | |
| | | static const int cov[] = {0, |
| | | (DIPPED_BEAM_LAMP<<8)+DIPPED_BEAM_LIGHT, |
| | | (MAIN_BEAM_LAMP<<8)+MAIN_BEAM_LIGHT, |
| | | (CLEARANCE_LAMP<<8)+CLEARANCE_LIGHT, |
| | | (FOG_LAMP<<8)+FOG_LIGHT, |
| | | (TURN_SIGNAL_LAMP<<8)+LEFT_TURN_LIGHT, |
| | | (TURN_SIGNAL_LAMP<<8)+RIGHT_TURN_LIGHT, |
| | | (TURN_SIGNAL_LAMP<<8)+HAZARD_LIGHTS, |
| | | (FLASH_BEAM_LAMP<<8)+FLASH_BEAM_LIGHT}; |
| | | |
| | | if (ExamStart) return; |
| | | |
| | | if (DummyLightContent != NULL) { |
| | | free(DummyLightContent); |
| | | delete []DummyLightContent; |
| | | DummyLightContent = NULL; |
| | | DummyLightContentSize = 0; |
| | | } |
| | | |
| | | DummyLightContent = (struct dummy_light_exam *)malloc(n * sizeof(struct dummy_light_exam)); |
| | | DummyLightContent = new struct dummy_light_exam[n]; |
| | | DummyLightContentSize = n; |
| | | |
| | | for (int i = 0; i < n; i++) { |
| | | DummyLightContent[i] = cfg[i]; |
| | | DummyLightContent[i].item = cfg[i].item; |
| | | DummyLightContent[i].tts = cfg[i].tts; |
| | | DummyLightContent[i].wrongCode = cfg[i].wrongCode; |
| | | // Sensor Name<<8 + Sensor Status |
| | | for (int j = 0; j < cfg[i].process.size(); ++j) { |
| | | DummyLightContent[i].process[j] = cov[cfg[i].process[j]]; |
| | | } |
| | | for (int j = 0; j < cfg[i].solution.size(); ++j) { |
| | | DummyLightContent[i].solution[j] = cov[cfg[i].solution[j]]; |
| | | } |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | static void PrintObdInfo(struct RtkTime *rtkTime, double speed) { |
| | | static struct RtkTime cTime = *rtkTime; |
| | | |
| | |
| | | engineRuning = false; |
| | | if (ExamType == TEST_TYPE_AREA) { |
| | | // 熄火1次,扣10分 |
| | | AddExamFault(5, rtkTime); |
| | | AddExamFault(10210, rtkTime); |
| | | } else { |
| | | AddExamFault(20, rtkTime); |
| | | AddExamFault(30208, rtkTime); |
| | | } |
| | | } |
| | | } else { |
| | |
| | | if (ReadCarStatus(GEAR) != GEAR_N) { |
| | | // 不是空挡点火,不合格 |
| | | if (ExamType == TEST_TYPE_AREA) |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(10105, rtkTime); |
| | | else |
| | | AddExamFault(4, rtkTime); |
| | | AddExamFault(30105, rtkTime); |
| | | } |
| | | AppTimer_delete(EngineStartHold); |
| | | AppTimer_add(EngineStartHold, examParam.hold_start_key_limit_time); |
| | |
| | | |
| | | // 不及时松开启动开关,扣10分 |
| | | if (ExamType == TEST_TYPE_AREA) |
| | | AddExamFault(4, rtkTime); |
| | | AddExamFault(10201, rtkTime); |
| | | } |
| | | |
| | | if (ExamType == TEST_TYPE_ROAD_DUMMY_LIGHT) { |
| | | if (exam_dummy_light == 0) { |
| | | StartDummyLightExam(DummyLightContent, DummyLightContentSize, rtkTime); |
| | | StartPrepare(); |
| | | // StartDummyLightExam(DummyLightContent, DummyLightContentSize, rtkTime); |
| | | exam_dummy_light = 1; |
| | | // 汇报灯光考试开始 |
| | | DEBUG("灯光考试开始"); |
| | | } else if (exam_dummy_light == 1) { |
| | | exam_dummy_light = ExecuteDummyLightExam(rtkTime); |
| | | DEBUG("开始上车准备"); |
| | | } else if (exam_dummy_light == 2) { |
| | | DEBUG("开始灯光考试"); |
| | | StartDummyLightExam(DummyLightContent, DummyLightContentSize, rtkTime); |
| | | exam_dummy_light = 3; |
| | | } else if (exam_dummy_light == 3) { |
| | | if (!ExecuteDummyLightExam(rtkTime)) { |
| | | exam_dummy_light = 4; |
| | | // 汇报灯光考试结束 |
| | | if (exam_dummy_light == 2) { |
| | | DEBUG("灯光考试结束"); |
| | | InitRoadExam(RoadMap); |
| | | } |
| | |
| | | if (ReadCarStatus(SEATBELT) == EJECT_SEATBELT && !reportSeatbeltEject) { |
| | | DEBUG("不系安全带"); |
| | | reportSeatbeltEject = true; |
| | | AddExamFault(1, rtkTime); |
| | | AddExamFault(ExamType == TEST_TYPE_AREA? 10101: 30101, rtkTime); |
| | | } |
| | | } |
| | | |
| | | if (ExamType != TEST_TYPE_AREA) { |
| | | if (exam_dummy_light == 2 || ExamType == TEST_TYPE_ROAD_TRUE_LIGHT || ExamType == TEST_TYPE_ROAD_CALIBRATE) { |
| | | if (exam_dummy_light == 4 || ExamType == TEST_TYPE_ROAD_TRUE_LIGHT || ExamType == TEST_TYPE_ROAD_CALIBRATE) { |
| | | TestRoadGeneral(RoadMap, CarModel, CarModelList, speed, move, rtkTime); |
| | | } |
| | | } else { |
| | |
| | | sprintf(fault.utc, "%04d%02d%02d%02d%02d%02d.%02d", 2000 + rtkTime->YY, |
| | | rtkTime->MM, rtkTime->DD, rtkTime->hh, rtkTime->mm, rtkTime->ss, rtkTime->mss); |
| | | |
| | | if (ExamType != TEST_TYPE_AREA) { |
| | | wrong += 1000; |
| | | } |
| | | // if (ExamType != TEST_TYPE_AREA) { |
| | | // wrong += 1000; |
| | | // } |
| | | |
| | | fault.wrong_id = wrong; |
| | | |
| | | DEBUG("考试发生错误 %d %s", wrong, fault.utc); |
| | | DEBUG("考试发生错误 code = %d %s", wrong, fault.utc); |
| | | |
| | | ExamFaultList.push_back(fault); |
| | | |
| | |
| | | |
| | | } |
| | | } |
| | | |
| | | void SensorXChanged(uint16_t id, int value) |
| | | { |
| | | handlePrepare(id, value); |
| | | handleLigthExam(id, value); |
| | | } |
| | | |
| | | void PrepareOver(int res) |
| | | { |
| | | exam_dummy_light = 2; |
| | | } |
| | |
| | | int start_car_max_rpm; |
| | | int start_car_limit_distance; |
| | | double open_door_drive_allow_distance; |
| | | |
| | | string prepare_tts; |
| | | string touch_leftfront_tts; |
| | | string touch_leftrear_tts; |
| | | string touch_rightfront_tts; |
| | | string touch_rightrear_tts; |
| | | string start_engine_tts; |
| | | |
| | | string start_car_begin_tts; |
| | | string start_car_end_tts; |
| | | |
| | |
| | | |
| | | int CorrectPauseCriteria(int src); |
| | | |
| | | void SensorXChanged(uint16_t id, int value); |
| | | |
| | | #endif //RTKDRIVERTEST_DRIVER_TEST_H |
| | |
| | | #include <vector> |
| | | #include <list> |
| | | #include <semaphore.h> |
| | | #include <unistd.h> |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<comm_if> <%s>: " fmt, __func__, ##args) |
| | | |
| | |
| | | #define ID_SM_CAN_BRIEF 0x0021 |
| | | #define ID_SM_BLUETOOTH_BRIEF 0x0022 |
| | | |
| | | #define ID_SM_RTK_STATUS_BRIEF 0x0023 |
| | | |
| | | #define MA_OUT_GPS_BRIEF 0x0001 |
| | | #define MA_OUT_RTK_BRIEF 0x0002 |
| | | #define MA_OUT_CAR_BRIEF 0x0004 |
| | |
| | | |
| | | if (MessageBuffer.size() > 0) { |
| | | struct msg_2_main_t msg; |
| | | int success; |
| | | |
| | | pthread_mutex_lock(&msg_mutex); |
| | | msg = MessageBuffer.back(); |
| | | MessageBuffer.pop_back(); |
| | | pthread_mutex_unlock(&msg_mutex); |
| | | |
| | | if (msg.value.length() > 0) |
| | | SendMsgToMainProc(msg.cmd, msg.value.c_str()); |
| | | success = SendMsgToMainProc(msg.cmd, msg.value.c_str()); |
| | | else |
| | | SendMsgToMainProc(msg.cmd, NULL); |
| | | success = SendMsgToMainProc(msg.cmd, NULL); |
| | | |
| | | if (success == 0) { |
| | | pthread_mutex_lock(&msg_mutex); |
| | | MessageBuffer.pop_back(); |
| | | pthread_mutex_unlock(&msg_mutex); |
| | | } else { |
| | | // 延迟重发 |
| | | usleep(500000); |
| | | sem_post(&sem_msg_income); |
| | | } |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | switch (cmd) { |
| | | case ID_MS_RTK_PLAT_CFG: { |
| | | DEBUG("平台信息 %s", value); |
| | | if (OnOff == 0) OnOff = MA_OUT_GPS_BRIEF + MA_OUT_RTK_BRIEF + MA_OUT_CAR_BRIEF; |
| | | |
| | | rtk_platform_cfg_t cfg; |
| | |
| | | const Value &s2 = (*itr)["tts"]; |
| | | |
| | | content[n].item = s1.GetInt(); |
| | | strcpy(content[n].tts, s2.GetString()); |
| | | n++; |
| | | content[n].tts = s2.GetString(); |
| | | } |
| | | |
| | | if (itr->HasMember("wrong_code")) { |
| | | const Value &s = (*itr)["wrong_code"]; |
| | | |
| | | content[n].wrongCode = s.GetInt(); |
| | | } |
| | | |
| | | if (itr->HasMember("process")) { |
| | | const Value& s = doc["process"]; |
| | | for(Value::ConstValueIterator itr2 = s.Begin(); itr2 != s.End(); ++itr2) { |
| | | content[n].process.push_back(itr2->GetInt()); |
| | | } |
| | | } |
| | | if (itr->HasMember("solution")) { |
| | | const Value& s = doc["solution"]; |
| | | for(Value::ConstValueIterator itr2 = s.Begin(); itr2 != s.End(); ++itr2) { |
| | | content[n].solution.push_back(itr2->GetInt()); |
| | | } |
| | | } |
| | | n++; |
| | | } |
| | | |
| | | SetDummyLightExam(n, content); |
| | |
| | | |
| | | SendMsgToMainProcIndep(ID_SM_BLUETOOTH_BRIEF, sb.GetString()); |
| | | } |
| | | |
| | | void MA_SendRtkStatus(const char *model, int status) |
| | | { |
| | | StringBuffer sb; |
| | | Writer<StringBuffer> writer(sb); |
| | | |
| | | writer.StartObject(); |
| | | |
| | | writer.Key("model"); |
| | | if (model == NULL || model[0] == 0) { |
| | | writer.String("Unknown"); |
| | | } else { |
| | | writer.String(model); |
| | | } |
| | | |
| | | writer.Key("status"); |
| | | writer.Int(status); |
| | | |
| | | writer.EndObject(); |
| | | |
| | | SendMsgToMainProcIndep(ID_SM_RTK_STATUS_BRIEF, sb.GetString()); |
| | | } |
| | |
| | | void MA_SendCanStatus(const struct canBrief *brief); |
| | | |
| | | void MA_SendBlueStatus(const char *name, const char *addr, int status); |
| | | void MA_SendRtkStatus(const char *type, int status); |
| | | |
| | | #endif //MYAPPLICATION2_COMM_IF_H |
| | |
| | | #include "../rtk_platform/platform.h" |
| | | #include "../rtk_module/parse_gps.h" |
| | | #include "../native-lib.h" |
| | | #include "../rtk_module/virtual_rtk.h" |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<mcu_if> <%s>: " fmt, __func__, ##args) |
| | | |
| | |
| | | WriteMcu(MCU_UART, buffer, x); |
| | | } |
| | | |
| | | void ConfigMCU(void) |
| | | void ConfigMCU(bool ayDevice) |
| | | { |
| | | McuCommModeSel(1); |
| | | if (ayDevice) { |
| | | McuCommModeSel(0); |
| | | |
| | | // TODO |
| | | /* static struct serial_config serialConfig; |
| | | static struct serial_config serialConfig; |
| | | |
| | | strcpy(serialConfig.name, "/dev/ttyHSL1"); |
| | | serialConfig.baud = 115200; |
| | |
| | | pthread_attr_t attr; |
| | | pthread_attr_init(&attr); |
| | | pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//detached |
| | | pthread_create(&pid, &attr, UartThread1, &serialConfig);*/ |
| | | pthread_create(&pid, &attr, UartThread1, &serialConfig); |
| | | } else { |
| | | McuCommModeSel(1); |
| | | } |
| | | } |
| | | |
| | | void SendRtkToMcu(const uint8_t *data, int length) |
| | |
| | | |
| | | memcpy(GnssBuf + GnssBufLen, data, length); |
| | | GnssBufLen += length; |
| | | |
| | | if (GnssBufLen > 0) { |
| | | if (VirtualIsConnected()) { //PC模拟用时 |
| | | static bool first = false; |
| | | |
| | | if (!first) { |
| | | first = true; |
| | | |
| | | uint8_t buff[33] = "emulator"; |
| | | buff[32] = 1; |
| | | PlatformStatusChanged(RTK_STATUS_EVT, buff, 33); |
| | | } |
| | | |
| | | GnssBufLen = 0; |
| | | } else { |
| | | const uint8_t *ptr = parseGPS(GnssBuf, GnssBuf + GnssBufLen); |
| | | if (ptr != GnssBuf) { |
| | | memcpy(GnssBuf, ptr, GnssBufLen - (ptr - GnssBuf)); |
| | |
| | | GnssBufLen = 0; |
| | | } |
| | | } |
| | | } |
| | | break; |
| | | } |
| | | default: |
| | |
| | | #include <cstdint> |
| | | |
| | | void McuCommModeSel(int mode); |
| | | void ConfigMCU(void); |
| | | void ConfigMCU(bool ayDevice); |
| | | void SendRtkToMcu(const uint8_t *data, int length); |
| | | void ParseMcuInit(void); |
| | | void ParseMcu(const uint8_t *data, int length); |
| | |
| | | |
| | | static int ttsSeq = 1; |
| | | |
| | | static void SendBootIndicate(union sigval sig); |
| | | |
| | | static std::map<int, void (*)(int)> TTSCallBack; |
| | | |
| | | int DESEncrypt(const uint8_t *key, int key_length, |
| | |
| | | } |
| | | } |
| | | |
| | | void SendMsgToMainProc(int cmd, const char *value) |
| | | int SendMsgToMainProc(int cmd, const char *value) |
| | | { |
| | | JNIEnv *env; |
| | | bool ready_in_java_env = false; |
| | | int ret; |
| | | |
| | | if (sg_jvm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK) { |
| | | // Attach主线程 |
| | | if (sg_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) { |
| | | LOGE("%s: AttachCurrentThread() failed", __FUNCTION__); |
| | | return; |
| | | return -3; |
| | | } |
| | | } else { |
| | | ready_in_java_env = true; |
| | | } |
| | | |
| | | jclass cls = env->GetObjectClass(sg_obj); |
| | | jmethodID fun = env->GetMethodID(cls, "SendMsgToMainProc", "(ILjava/lang/String;)V"); |
| | | jmethodID fun = env->GetMethodID(cls, "SendMsgToMainProc", "(ILjava/lang/String;)I"); |
| | | |
| | | env->CallVoidMethod(sg_obj, fun, cmd, value != NULL ? env->NewStringUTF(value) : NULL); |
| | | ret = env->CallIntMethod(sg_obj, fun, cmd, value != NULL ? env->NewStringUTF(value) : NULL); |
| | | |
| | | env->DeleteLocalRef(cls); |
| | | |
| | |
| | | LOGE("%s: DetachCurrentThread() failed", __FUNCTION__); |
| | | } |
| | | } |
| | | |
| | | return ret; |
| | | } |
| | | |
| | | static int GetTtsSeq(void) |
| | |
| | | |
| | | extern "C" |
| | | JNIEXPORT void JNICALL |
| | | Java_com_anyun_exam_lib_RemoteService_startNative(JNIEnv *env, jobject thiz) { |
| | | Java_com_anyun_exam_lib_RemoteService_startNative(JNIEnv *env, jobject thiz, jboolean ayDevice) { |
| | | // TODO: implement startNative() |
| | | // 保存全局JVM以便在子线程中使用 |
| | | DEBUG("启动Native"); |
| | |
| | | srand(time(NULL)); |
| | | |
| | | AppTimer_Init(); |
| | | ConfigMCU(); |
| | | ConfigMCU(ayDevice); |
| | | DriverTestInit(); |
| | | ConfigRTKModule(); |
| | | ConfigRTKModule(ayDevice); |
| | | MA_Init(); |
| | | InitPlatform(phone, RTK_PLATFORM_IP, RTK_PLATFORM_PORT); |
| | | AppTimer_add(SendBootIndicate, D_SEC(1)); |
| | | InitPlatform(ayDevice, phone, RTK_PLATFORM_IP, RTK_PLATFORM_PORT); |
| | | |
| | | InitVirtualDevice(VIRTUAL_RTK_IP, VIRTUAL_RTK_PORT); |
| | | |
| | | pthread_mutex_init(&tts_mutex, NULL); |
| | | } |
| | | |
| | | static void SendBootIndicate(union sigval sig) { |
| | | static int n = 0; |
| | | AppTimer_delete(SendBootIndicate); |
| | | MA_NdkStart(); |
| | | |
| | | n++; |
| | | |
| | | if (n < 3) { |
| | | AppTimer_add(SendBootIndicate, D_SEC(1)); |
| | | } |
| | | } |
| | | |
| | | extern "C" |
| | |
| | | |
| | | void TextOsd(int type, const char *text); |
| | | void DrawScreen(const Polygon *map, const Polygon *car); |
| | | void SendMsgToMainProc(int cmd, const char *value); |
| | | int SendMsgToMainProc(int cmd, const char *value); |
| | | int PlayTTS(const char *string, void (*callback)(int)); |
| | | int PlayTTS(std::string &tts, void (*callback)(int)); |
| | | void PlayRing(void); |
| | |
| | | const static char SAVECONFIG[] = "saveconfig\r\n"; |
| | | const static char *PJKITEMS[] = {"gptra", "ptnlpjk"}; |
| | | const static char *GPSITEMS[] = {"gpgga", "gprmc", "gpvtg"}; |
| | | const char CMD_VERSION[] = "log version\r\n"; |
| | | |
| | | static gpsStatus_t gpsStatus; |
| | | static char rtkModel[32] = {0}; |
| | | |
| | | static int (*WriteRtk)(int id, const void *buf, int len); |
| | | |
| | | static rtk_info CurrRTKInfo; |
| | | static bool needSetPjk = false; |
| | | static int lostCnt; |
| | | |
| | | static void CheckPjkParam(void); |
| | | static void CheckPjkParamTimeout(union sigval sig); |
| | | static int WriteBluetooth(int id, const void *buf, int len); |
| | | static void GetModuleVersion(void); |
| | | |
| | | static void VersionTimeout(union sigval sig); |
| | | static void GpsDataTimeout(union sigval sig); |
| | | |
| | | static void *UartThread(void *p); |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | void ConfigRTKModule(void) |
| | | void ConfigRTKModule(bool ayDevice) |
| | | { |
| | | // TODO |
| | | DEBUG("ConfigRTKModule"); |
| | |
| | | memset(&gpsStatus, 0, sizeof(gpsStatus)); |
| | | gpsStatus.hh = -1; |
| | | |
| | | RtkCommModeSel(1); |
| | | if (ayDevice) { |
| | | RtkCommModeSel(0); |
| | | |
| | | /*static struct serial_config serialConfig; |
| | | static struct serial_config serialConfig; |
| | | |
| | | strcpy(serialConfig.name, "/dev/ttyHSL0"); |
| | | serialConfig.baud = 115200; |
| | |
| | | pthread_attr_t attr; |
| | | pthread_attr_init(&attr); |
| | | pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//detached |
| | | pthread_create(&pid, &attr, UartThread, &serialConfig);*/ |
| | | pthread_create(&pid, &attr, UartThread, &serialConfig); |
| | | } else { |
| | | RtkCommModeSel(1); |
| | | // 等待蓝牙连接 |
| | | } |
| | | } |
| | | |
| | | // 蓝牙连接后 |
| | | void ConfigRTKModuleLater(void) |
| | | { |
| | | AppTimer_delete(GpsDataTimeout); |
| | | AppTimer_delete(VersionTimeout); |
| | | AppTimer_delete(CheckPjkParamTimeout); |
| | | AppTimer_add(CheckPjkParamTimeout, D_SEC(1)); |
| | | } |
| | |
| | | void handleRTKRebootComp(const struct nmea *s) |
| | | { |
| | | DEBUG("RTK Reboot complete!!"); |
| | | CheckPjkParam(); |
| | | // CheckPjkParam(); |
| | | GetModuleVersion(); |
| | | } |
| | | |
| | | void handlePJKParam(const struct nmea *s) { |
| | | DEBUG("handlePJKParam"); |
| | | //PJK Parameter: A:6378137.000, 1/F:298.257223563, B0:0.000000deg, L0:120.000000, N0:0.000, E0:500000.000. |
| | | //PJK Parameter: A:6378137.000, 1/F:298.257223563, B0:29.512453deg, L0:106.455336, N0:0.000, E0:0.000. |
| | | // bool setparam = true; |
| | | // |
| | | // const char DP1[] = "A:6378137.000"; |
| | | // const char DP2[] = "1/F:298.257223563"; |
| | | // const char DP3[] = "B0:29.512453deg"; |
| | | // const char DP4[] = "L0:106.455336"; |
| | | // const char DP5[] = "N0:0.000"; |
| | | // const char DP6[] = "E0:0.000"; |
| | | |
| | | AppTimer_delete(CheckPjkParamTimeout); |
| | | |
| | | // for (int i = 0; i < s->nmea_num; ++i) { |
| | | // char out[64] = {0}; |
| | | // |
| | | // memcpy(out, s->nmea_value[i].data, s->nmea_value[i].length); |
| | | // |
| | | // DEBUG("handlePJKParam = %s", out); |
| | | // } |
| | | // |
| | | // if (s->nmea_num != 6) return; |
| | | // |
| | | // if (memcmp(s->nmea_value[0].data, DP1, strlen(DP1))) { |
| | | // setparam = true; |
| | | // } |
| | | // if (memcmp(s->nmea_value[1].data, DP2, strlen(DP2))) { |
| | | // setparam = true; |
| | | // } |
| | | // if (memcmp(s->nmea_value[2].data, DP3, strlen(DP3))) { |
| | | // setparam = true; |
| | | // } |
| | | // if (memcmp(s->nmea_value[3].data, DP4, strlen(DP4))) { |
| | | // setparam = true; |
| | | // } |
| | | // if (memcmp(s->nmea_value[4].data, DP5, strlen(DP5))) { |
| | | // setparam = true; |
| | | // } |
| | | // if (memcmp(s->nmea_value[5].data, DP6, strlen(DP6))) { |
| | | // setparam = true; |
| | | // } |
| | | // |
| | | // if (setparam) { |
| | | // SetAYFactoryParam(5); |
| | | // } |
| | | |
| | | SetAYFactoryParam(5); |
| | | needSetPjk = true; |
| | | |
| | | lostCnt = 0; |
| | | AppTimer_delete(GpsDataTimeout); |
| | | AppTimer_add(GpsDataTimeout, D_SEC(5)); |
| | | |
| | | uint8_t buff[33]; |
| | | |
| | | memcpy(buff, rtkModel, 32); |
| | | buff[32] = 1; |
| | | PlatformStatusChanged(RTK_STATUS_EVT, buff, 33); |
| | | } |
| | | |
| | | void SetAYFactoryParam(int freq) |
| | |
| | | int RxBufLen = 0; |
| | | |
| | | if (res == 0) { |
| | | CheckPjkParam(); |
| | | // CheckPjkParam(); |
| | | GetModuleVersion(); |
| | | } |
| | | |
| | | while (res == 0) { |
| | |
| | | if (RxBufLen > 0) { |
| | | #if 1 |
| | | if (VirtualIsConnected()) { //PC模拟用时 |
| | | static bool first = false; |
| | | |
| | | if (!first) { |
| | | first = true; |
| | | |
| | | uint8_t buff[33] = "emulator"; |
| | | buff[32] = 1; |
| | | PlatformStatusChanged(RTK_STATUS_EVT, buff, 33); |
| | | } |
| | | RxBufLen = 0; |
| | | } else { |
| | | const uint8_t *ptr = parseGPS(RxBuf, RxBuf + RxBufLen); |
| | |
| | | } |
| | | |
| | | void handleUnrecognisedNMEA(const uint8_t *data, uint16_t length) { |
| | | // char buff[4096] = {0}; |
| | | // memcpy(buff, data, MIN(length, 3000)); |
| | | char buff[4096] = {0}; |
| | | memcpy(buff, data, MIN(length, 4000)); |
| | | // DEBUG("handleUnrecognisedNMEA: %s", buff); |
| | | |
| | | if (length >= 100) { |
| | | string cs(buff); |
| | | |
| | | if (cs.find("K708") != string::npos) { |
| | | // 最初的标准基站模块 |
| | | DEBUG("K708 模块"); |
| | | strcpy(rtkModel, "K708"); |
| | | |
| | | AppTimer_delete(VersionTimeout); |
| | | CheckPjkParam(); |
| | | } else if (cs.find("K726") != string::npos) { |
| | | // 移动站模块,也可以用做基站功能 |
| | | DEBUG("K726 模块"); |
| | | strcpy(rtkModel, "K726"); |
| | | |
| | | AppTimer_delete(VersionTimeout); |
| | | CheckPjkParam(); |
| | | } |
| | | } |
| | | } |
| | | |
| | | void handleGPGGA(const struct nmea *s) |
| | | { |
| | | static uint32_t qfCnt = 0; |
| | | |
| | | DEBUG("handleGPGGA num = %d", s->nmea_num); |
| | | // DEBUG("handleGPGGA num = %d", s->nmea_num); |
| | | if (s->nmea_num >= 10) { |
| | | lostCnt = 0; |
| | | AppTimer_delete(GpsDataTimeout); |
| | | AppTimer_add(GpsDataTimeout, D_SEC(5)); |
| | | |
| | | gpsStatus.gps_status = str2int(s->nmea_value[5].data, s->nmea_value[5].length); |
| | | |
| | | int hh = str2int(s->nmea_value[0].data, 2); |
| | |
| | | |
| | | void handleGPRMC(const struct nmea *s) |
| | | { |
| | | DEBUG("handleGPRMC num = %d", s->nmea_num); |
| | | // DEBUG("handleGPRMC num = %d", s->nmea_num); |
| | | |
| | | if (s->nmea_num >= 9) { |
| | | int hh = str2int(s->nmea_value[0].data, 2); |
| | |
| | | } |
| | | |
| | | void handlePJK(const struct nmea *s) { |
| | | DEBUG("handlePJK num = %d", s->nmea_num); |
| | | // DEBUG("handlePJK num = %d", s->nmea_num); |
| | | |
| | | int hh = str2int(s->nmea_value[0].data, 2); |
| | | int mm = str2int(s->nmea_value[0].data + 2, 2); |
| | |
| | | } |
| | | |
| | | void handleGPTRA(const struct nmea *s) { |
| | | DEBUG("handleGPTRA num = %d", s->nmea_num); |
| | | // DEBUG("handleGPTRA num = %d", s->nmea_num); |
| | | |
| | | int hh = str2int(s->nmea_value[0].data, 2); |
| | | int mm = str2int(s->nmea_value[0].data + 2, 2); |
| | |
| | | |
| | | static void CheckPjkParam(void) |
| | | { |
| | | int n = WriteRtk(RTK_MODULE_UART, INQ_PJK_PARAM, strlen(INQ_PJK_PARAM)); |
| | | DEBUG("CN = %d", n); |
| | | WriteRtk(RTK_MODULE_UART, INQ_PJK_PARAM, strlen(INQ_PJK_PARAM)); |
| | | DEBUG("获取PJK参数..."); |
| | | AppTimer_delete(CheckPjkParamTimeout); |
| | | AppTimer_add(CheckPjkParamTimeout, D_SEC(3)); |
| | | } |
| | |
| | | static void CheckPjkParamTimeout(union sigval sig) { |
| | | AppTimer_delete(CheckPjkParamTimeout); |
| | | |
| | | DEBUG("RTK Module failure!!"); |
| | | DEBUG("获取PJK参数超时"); |
| | | |
| | | // PlayTTS("RTK模块无法通讯", NULL); |
| | | uint8_t buff[33]; |
| | | memcpy(buff, rtkModel, 32); |
| | | buff[32] = 0; |
| | | PlatformStatusChanged(RTK_STATUS_EVT, buff, 33); |
| | | |
| | | CheckPjkParam(); |
| | | GetModuleVersion(); |
| | | } |
| | | |
| | | static int WriteBluetooth(int id, const void *buf, int len) |
| | |
| | | SendMcuCommand(0x000B, (uint8_t *)buf, len); |
| | | return len; |
| | | } |
| | | |
| | | static void GetModuleVersion(void) |
| | | { |
| | | AppTimer_delete(VersionTimeout); |
| | | AppTimer_add(VersionTimeout, D_SEC(3)); |
| | | WriteRtk(RTK_MODULE_UART, CMD_VERSION, strlen(CMD_VERSION)); |
| | | |
| | | DEBUG("获取版本..."); |
| | | } |
| | | |
| | | static void VersionTimeout(union sigval sig) |
| | | { |
| | | AppTimer_delete(VersionTimeout); |
| | | DEBUG("版本获取超时"); |
| | | GetModuleVersion(); |
| | | |
| | | uint8_t buff[33]; |
| | | memcpy(buff, rtkModel, 32); |
| | | buff[32] = 0; |
| | | PlatformStatusChanged(RTK_STATUS_EVT, buff, 33); |
| | | } |
| | | |
| | | static void GpsDataTimeout(union sigval sig) |
| | | { |
| | | AppTimer_delete(GpsDataTimeout); |
| | | |
| | | if (++lostCnt >= 3) { |
| | | DEBUG("RTK模块收不到GPS数据"); |
| | | GetModuleVersion(); |
| | | } else { |
| | | AppTimer_add(GpsDataTimeout, D_SEC(5)); |
| | | } |
| | | } |
| | |
| | | }rtk_info; |
| | | |
| | | void RtkCommModeSel(int mode); |
| | | void ConfigRTKModule(void); |
| | | void ConfigRTKModule(bool ayDevice); |
| | | void ConfigRTKModuleLater(void); |
| | | void FactorySettings(void); |
| | | void RebootModule(void); |
| | |
| | | DEBUG("虚拟平台连接成功"); |
| | | virtRtkIsValid = true; |
| | | connectCnt = 0; |
| | | // PlayTTS("模拟器连接", NULL); |
| | | PlayTTS("模拟器连接", NULL); |
| | | } else { |
| | | DEBUG("虚拟平台连接失败"); |
| | | } |
| | |
| | | break; |
| | | } else if (lx > 0) { |
| | | RxBufLen += lx; |
| | | |
| | | const uint8_t *ptr = parseGPS(RxBuf, RxBuf + RxBufLen); |
| | | |
| | | if(ptr != RxBuf) { |
| | | memcpy(RxBuf, ptr, RxBufLen - (ptr - RxBuf)); |
| | | RxBufLen -= ptr - RxBuf; |
| | |
| | | } |
| | | |
| | | if (fd > 0) { |
| | | DEBUG("虚拟平台断开"); |
| | | DisconnectTCP(fd); |
| | | PlayTTS("模拟器断开", NULL); |
| | | } |
| | | virtRtkIsValid = false; |
| | | |
| | |
| | | AppTimer_add(ConnectLater, D_SEC(3)); |
| | | } |
| | | |
| | | // PlayTTS("模拟器断开", NULL); |
| | | DEBUG("虚拟平台线程退出"); |
| | | |
| | | pthread_exit(NULL); |
| | | } |
| | |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<parse_net> <%s>: " fmt, __func__, ##args) |
| | | |
| | | //#define ENABLE_DEBUG_PROTOCOL |
| | | #define ENABLE_DEBUG_PROTOCOL |
| | | |
| | | using namespace std; |
| | | |
| | |
| | | struct event_queue_t *next; |
| | | } *eventQueue; |
| | | |
| | | static bool mAyDevice = false; |
| | | |
| | | struct platformSocket exceptSocket, currSocket; |
| | | static sem_t sem_status_changed; |
| | | |
| | |
| | | static void LoginPlatformTimeout(union sigval sig); |
| | | static void TriggerHeartbeat(union sigval sig); |
| | | static void RequestRtkNoResp(union sigval sig); |
| | | |
| | | |
| | | static void AddEvnet(uint32_t event, const uint8_t *data, int length) |
| | | { |
| | |
| | | free(p1); |
| | | } |
| | | |
| | | void InitPlatform(const uint8_t *phone, const char *domain_name, int port) |
| | | void InitPlatform(bool ayDevice, const uint8_t *phone, const char *domain_name, int port) |
| | | { |
| | | DEBUG("InitPlatform"); |
| | | |
| | | mAyDevice = ayDevice; |
| | | |
| | | memset(&gbf, 0, sizeof(gbf)); |
| | | memset(&rbf, 0, sizeof(rbf)); |
| | |
| | | if (domain_name == NULL || strlen(domain_name) == 0 || port == 0) |
| | | return; |
| | | |
| | | DEBUG("ConnectPlatform %s: %d", domain_name, port); |
| | | DEBUG("连接RTK平台 %s: %d", domain_name, port); |
| | | // TODO |
| | | struct platformSocketInfo *ptr = (struct platformSocketInfo *)malloc(sizeof(struct platformSocketInfo)); |
| | | |
| | |
| | | |
| | | static void PlatformChangeEntry(uint32_t events, const uint8_t *data, int length) |
| | | { |
| | | if (events & PLATFORM_CONNECT_EVT) { |
| | | switch (events) { |
| | | case PLATFORM_CONNECT_EVT: { |
| | | DEBUG("平台连接成功 %s:%d", currSocket.domain_name, currSocket.port); |
| | | MA_RtkPlatformConnect(1, currSocket.domain_name, currSocket.port); |
| | | |
| | |
| | | } else if (!platformStatus.login) { |
| | | LoginPlatform(); |
| | | } |
| | | |
| | | MA_SendBlueStatus("name", "00:1B:35:16:20:4A", 3); |
| | | break; |
| | | } |
| | | |
| | | if (events & PLATFORM_DISCONNECT_EVT) { |
| | | case PLATFORM_DISCONNECT_EVT: { |
| | | DEBUG("平台断开 %s:%d", currSocket.domain_name, currSocket.port); |
| | | MA_RtkPlatformConnect(0, currSocket.domain_name, currSocket.port); |
| | | |
| | |
| | | AppTimer_delete(LoginPlatformTimeout); |
| | | |
| | | // PlayTTS("基准源断开", NULL); |
| | | break; |
| | | } |
| | | if (events & PLATFORM_REGISTER_EVT) { |
| | | DEBUG("PLATFORM_REGISTER_EVT"); |
| | | case PLATFORM_REGISTER_EVT: { |
| | | DEBUG("平台注册结果:%d", data[0]); |
| | | |
| | | platformStatus.login = 0; |
| | | if (data[0] == 0) { |
| | |
| | | platformStatus.registed = 0; |
| | | } |
| | | MA_RtkPlatformRegister(data[0], data + 1, length - 1); |
| | | break; |
| | | } |
| | | if (events & PLATFORM_LOGIN_EVT) { |
| | | DEBUG("PLATFORM_LOGIN_EVT"); |
| | | case PLATFORM_LOGIN_EVT: { |
| | | DEBUG("平台登录结果:%d", data[0]); |
| | | |
| | | if (data[0] == 0) { |
| | | platformStatus.login = 1; |
| | |
| | | platformStatus.login = 0; |
| | | } |
| | | MA_RtkPlatformLogin(data[0]); |
| | | break; |
| | | } |
| | | if (events & GPS_UPDATE_EVT) { |
| | | DEBUG("GPS_UPDATE_EVT length %d", length); |
| | | case GPS_UPDATE_EVT: { |
| | | const gpsStatus_t *gps = (gpsStatus_t *)data; |
| | | |
| | | gbf.qf = gps->gps_status; |
| | |
| | | gbf.speed = gps->speed; |
| | | gbf.sat_num = gps->satNum; |
| | | gbf.trackTure = gps->trackTure; |
| | | sprintf(gbf.utc, "%04d%02d%02d%02d%02d%02d.%02d", 2000 + gps->YY, gps->MM, gps->DD, gps->hh, gps->mm, gps->ss, gps->mss); |
| | | sprintf(gbf.utc, "%04d%02d%02d%02d%02d%02d.%02d", 2000 + gps->YY, gps->MM, gps->DD, |
| | | gps->hh, gps->mm, gps->ss, gps->mss); |
| | | if (!strcmp(rbf.utc, gbf.utc)) { |
| | | rbf.sat_num = gbf.sat_num; |
| | | rbf.latitude = gbf.latitude; |
| | |
| | | } |
| | | // MA_SendGpsBrief(&brief); |
| | | RequestRtkDownload(gps, 1); |
| | | |
| | | DEBUG("GPS_UPDATE_EVT ================"); |
| | | break; |
| | | } |
| | | if (events & RTK_UPDATE_EVT) { |
| | | DEBUG("RTK_UPDATE_EVT length %d", length); |
| | | |
| | | // uint32_t ost = AppTimer_GetTickCount(); |
| | | case RTK_UPDATE_EVT: { |
| | | uint32_t ost = AppTimer_GetTickCount(); |
| | | uint32_t ost1 = ost; |
| | | |
| | | const rtk_info *rtk = (rtk_info *)data; |
| | | |
| | |
| | | rbf.roll = rtk->roll; |
| | | rbf.coord_x_dir = 'N'; |
| | | rbf.coord_y_dir = 'E'; |
| | | sprintf(rbf.utc, "%04d%02d%02d%02d%02d%02d.%02d", 2000 + rtk->YY, rtk->MM, rtk->DD, rtk->hh, rtk->mm, rtk->ss, rtk->dss); |
| | | sprintf(rbf.utc, "%04d%02d%02d%02d%02d%02d.%02d", 2000 + rtk->YY, rtk->MM, rtk->DD, |
| | | rtk->hh, rtk->mm, rtk->ss, rtk->dss); |
| | | if (!strcmp(rbf.utc, gbf.utc)) { |
| | | rbf.sat_num = gbf.sat_num; |
| | | rbf.latitude = gbf.latitude; |
| | |
| | | MA_SendRtkBrief(&rbf); |
| | | } |
| | | |
| | | ost1 = AppTimer_GetTickCount() - ost1; |
| | | |
| | | UpdateRTKInfo(rtk); |
| | | |
| | | // DEBUG("driver_test 评判耗时 %ld", AppTimer_GetTickCount() - ost); |
| | | ost = AppTimer_GetTickCount() - ost; |
| | | |
| | | DEBUG("RTK_UPDATE_EVT ================="); |
| | | if (ost > 100) |
| | | DEBUG("driver_test 评判耗时 %ld %ld", ost1, ost); |
| | | break; |
| | | } |
| | | if (events & MCU_UPDATE_EVT) { |
| | | DEBUG("MCU_UPDATE_EVT length %d", length); |
| | | case RTK_STATUS_EVT: { |
| | | DEBUG("模块信息 %02X %02X %02X %02X %02X %02X", data[0], data[1], data[2], data[3], data[4], data[5]); |
| | | if (length == 33) |
| | | MA_SendRtkStatus((char *)data, data[32]); |
| | | break; |
| | | } |
| | | case MCU_UPDATE_EVT: { |
| | | // 0-31 version |
| | | // 32-33 selftest |
| | | // 34-35 gpio |
| | |
| | | |
| | | vector<string> ver = split(str, "_"); |
| | | |
| | | if (strlen(defaultMcuRom.verCode) > 0 && ver.size() >= 4 && strcmp(defaultMcuRom.verCode, ver[3].c_str()) != 0 && defaultMcuRom.rom != NULL) { |
| | | if (strlen(defaultMcuRom.verCode) > 0 && ver.size() >= 4 && |
| | | strcmp(defaultMcuRom.verCode, ver[3].c_str()) != 0 && |
| | | defaultMcuRom.rom != NULL) { |
| | | UploadDfuFile(defaultMcuRom.rom, defaultMcuRom.length); |
| | | delete []defaultMcuRom.rom; |
| | | defaultMcuRom.rom = NULL; |
| | |
| | | defaultMcuRom.more = 0; |
| | | } |
| | | // UpdateSensor(brief.gpio, brief.speed, brief.engine); |
| | | break; |
| | | } |
| | | if (events & CAN_UPDATE_EVT) { |
| | | case CAN_UPDATE_EVT: { |
| | | struct canBrief brief; |
| | | |
| | | brief.gpio = BUILD_UINT16(data[1], data[0]); |
| | |
| | | brief.voltage = (double) BUILD_UINT16(data[7], data[6]) / 10.0; |
| | | |
| | | MA_SendCanStatus(&brief); |
| | | break; |
| | | } |
| | | if (events & CAR_SENSOR_UPDATE_EVT) { |
| | | case CAR_SENSOR_UPDATE_EVT: { |
| | | struct carSensorBrief brief; |
| | | int x = 20; |
| | | |
| | |
| | | sensor.gear = 0; |
| | | |
| | | UpdateSensor(&sensor); |
| | | break; |
| | | } |
| | | if (events & CARD_UPDATE_EVT) { |
| | | case CARD_UPDATE_EVT: { |
| | | DEBUG("CARD_UPDATE_EVT length %d", length); |
| | | |
| | | int ret = -1; |
| | |
| | | ConvertHex2String(brief.card, data, length); |
| | | |
| | | MA_SendCardBrief(&brief); |
| | | break; |
| | | } |
| | | if (events & PLAY_TTS_DONE_EVT) { |
| | | case PLAY_TTS_DONE_EVT: { |
| | | tts_back_t *cb = (tts_back_t *) data; |
| | | if (cb->callback != NULL) { |
| | | cb->callback(cb->seq); |
| | | } |
| | | break; |
| | | } |
| | | if (events & MASTER_COMM_EVT) { |
| | | case MASTER_COMM_EVT: { |
| | | union { |
| | | int a; |
| | | uint8_t b[sizeof(int)]; |
| | |
| | | else { |
| | | MA_MainProcMsgEntry(c.a, (char *) data + 4); |
| | | } |
| | | break; |
| | | } |
| | | if (events & BLUETOOTH_STATUS_EVT) { |
| | | case BLUETOOTH_STATUS_EVT: { |
| | | DEBUG("BLUETOOTH_STATUS_EVT"); |
| | | |
| | | if (!mAyDevice) { |
| | | uint8_t sta; |
| | | |
| | | if (length == 128) { |
| | |
| | | PlayTTS("蓝牙连接", NULL); |
| | | } else if (sta == 2) { |
| | | // Disconnect |
| | | if (btConnected) { |
| | | btConnected = false; |
| | | PlayTTS("蓝牙断开", NULL); |
| | | } |
| | | } else if (sta == 1) { |
| | | // Open |
| | | btEnable = true; |
| | |
| | | PlayTTS("蓝牙关闭", NULL); |
| | | } |
| | | } |
| | | if (events & BLUETOOTH_DATA_EVT) { |
| | | break; |
| | | } |
| | | case BLUETOOTH_DATA_EVT: { |
| | | ParseMcu(data, length); |
| | | break; |
| | | } |
| | | case SENSOR_CHANGE_EVT: { |
| | | SensorXChanged(BUILD_UINT16(data[1], data[0]), BUILD_UINT32(data[5], data[4], data[3], data[2])); |
| | | break; |
| | | } |
| | | default: |
| | | break; |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | static void RegisterPlatformTimeout(union sigval sig) |
| | | { |
| | | DEBUG("RegisterPlatformTimeout"); |
| | | DEBUG("RTK平台注册超时"); |
| | | AppTimer_delete(RegisterPlatformTimeout); |
| | | RegisterPlatform(); |
| | | } |
| | | |
| | | static void RegisterPlatform(void) |
| | | { |
| | | DEBUG("RTK平台注册..."); |
| | | AppTimer_delete(RegisterPlatformTimeout); |
| | | AppTimer_add(RegisterPlatformTimeout, D_SEC(15)); |
| | | SendDeviceRegister(deviceInfo.province, deviceInfo.city, deviceInfo.device_model, |
| | |
| | | |
| | | static void LoginPlatformTimeout(union sigval sig) |
| | | { |
| | | DEBUG("RTK平台登录超时"); |
| | | AppTimer_delete(LoginPlatformTimeout); |
| | | LoginPlatform(); |
| | | } |
| | | |
| | | static void LoginPlatform(void) |
| | | { |
| | | DEBUG("RTK平台登录..."); |
| | | uint32_t tim = time(NULL); |
| | | uint8_t data[12]; |
| | | uint8_t *ciphertext; |
| | |
| | | AppTimer_delete(LoginPlatformTimeout); |
| | | AppTimer_add(LoginPlatformTimeout, D_SEC(15)); |
| | | |
| | | |
| | | DESEncrypt(platformStatus.platformKey, platformStatus.platformKeyLength, data, 4, &ciphertext); |
| | | |
| | | if (ciphertext != NULL) { |
| | |
| | | |
| | | #include "../rtk_module/rtk.h" |
| | | |
| | | #define PLATFORM_CONNECT_EVT 0x0001 |
| | | #define PLATFORM_DISCONNECT_EVT 0x0002 |
| | | #define PLATFORM_REGISTER_EVT 0x0004 |
| | | #define PLATFORM_LOGIN_EVT 0x0008 |
| | | #define RTK_UPDATE_EVT 0x0010 |
| | | #define GPS_UPDATE_EVT 0x0020 |
| | | #define MCU_UPDATE_EVT 0x0040 |
| | | #define CARD_UPDATE_EVT 0x0080 |
| | | #define PLAY_TTS_DONE_EVT 0x0100 |
| | | #define CAR_SENSOR_UPDATE_EVT 0x0200 |
| | | #define MASTER_COMM_EVT 0x0400 |
| | | #define CAN_UPDATE_EVT 0x0800 |
| | | #define BLUETOOTH_DATA_EVT 0x1000 |
| | | #define BLUETOOTH_STATUS_EVT 0x2000 |
| | | enum { |
| | | PLATFORM_CONNECT_EVT, |
| | | PLATFORM_DISCONNECT_EVT, |
| | | PLATFORM_REGISTER_EVT, |
| | | PLATFORM_LOGIN_EVT, |
| | | RTK_UPDATE_EVT, |
| | | RTK_STATUS_EVT, |
| | | GPS_UPDATE_EVT, |
| | | MCU_UPDATE_EVT, |
| | | CARD_UPDATE_EVT, |
| | | PLAY_TTS_DONE_EVT, |
| | | CAR_SENSOR_UPDATE_EVT, |
| | | MASTER_COMM_EVT, |
| | | CAN_UPDATE_EVT, |
| | | BLUETOOTH_DATA_EVT, |
| | | BLUETOOTH_STATUS_EVT, |
| | | SENSOR_CHANGE_EVT |
| | | }; |
| | | |
| | | typedef struct { |
| | | char domain_name[32]; |
| | |
| | | int rtk_interval; |
| | | } rtk_platform_cfg_t; |
| | | |
| | | void InitPlatform(const uint8_t *phone, const char *domain_name, int port); |
| | | void InitPlatform(bool ayDevice, const uint8_t *phone, const char *domain_name, int port); |
| | | void ConfigPlatform(const rtk_platform_cfg_t *p); |
| | | |
| | | void PlatformStatusChanged(uint32_t event, const uint8_t *data, int length); |
| | |
| | | #include "../defs.h" |
| | | #include "../common/apptimer.h" |
| | | #include "../jni_log.h" |
| | | #include "../rtk_platform/platform.h" |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<car_sensor> <%s>: " fmt, __func__, ##args) |
| | | |
| | |
| | | pthread_mutex_lock(&status_rw_mutex); |
| | | CarStatus[id] = value; |
| | | pthread_mutex_unlock(&status_rw_mutex); |
| | | |
| | | if (id != OBD_SPEED && id != ENGINE_RPM) { |
| | | uint8_t buffer[6]; |
| | | |
| | | buffer[0] = HI_UINT16(id); |
| | | buffer[1] = LO_UINT16(id); |
| | | buffer[2] = BREAK_UINT32(value, 3); |
| | | buffer[3] = BREAK_UINT32(value, 2); |
| | | buffer[4] = BREAK_UINT32(value, 1); |
| | | buffer[5] = BREAK_UINT32(value, 0); |
| | | |
| | | PlatformStatusChanged(SENSOR_CHANGE_EVT, buffer, 6); |
| | | } |
| | | } |
| | | |
| | | static void LRLightTimeout(union sigval sig) |
| | |
| | | static void SensorChanged(int id, int value) |
| | | { |
| | | // DEBUG("状态改变 %d = %d", id, value); |
| | | |
| | | switch (id) { |
| | | case SENSOR_LEFT_TURN_SIGNAL: { |
| | | left_turn_signal = value; |
| | |
| | | // break; |
| | | // } |
| | | default: |
| | | break; |
| | | return; |
| | | } |
| | | } |
| | | |
| | |
| | | if (!crashRedLine) { |
| | | crashRedLine = true; |
| | | // 车轮压边线,不合格 |
| | | AddExamFault(27, rtkTime); |
| | | AddExamFault(20601, rtkTime); |
| | | DEBUG("车轮压边线"); |
| | | if (who == 1) { |
| | | PlayTTS("压左曲线", NULL); |
| | |
| | | |
| | | if (tp - stopTimepoint >= CorrectPauseCriteria(examParam.curve_pause_criteria) && !reportStopCarTimeout) { |
| | | // 停车超2秒,不合格 |
| | | AddExamFault(28, rtkTime); |
| | | AddExamFault(20602, rtkTime); |
| | | DEBUG("中途停车"); |
| | | reportStopCarTimeout = true; |
| | | } |
| | |
| | | if ((parkStatus[0] != 1 || parkStatus[1] != 1) && !reportParkFail && reverseCar) { |
| | | // 倒库不入,不合格 |
| | | reportParkFail = true; |
| | | AddExamFault(8, rtkTime); |
| | | AddExamFault(20103, rtkTime); |
| | | DEBUG("倒库不入"); |
| | | } |
| | | goto TEST_END; |
| | |
| | | if (!occurCrashRedLine && reverseCar) { |
| | | occurCrashRedLine = true; |
| | | // 车身出线,不合格 |
| | | AddExamFault(7, rtkTime); |
| | | AddExamFault(10116, rtkTime); |
| | | DEBUG("车轮压线"); |
| | | if (who == 1) { |
| | | PlayTTS("压左库位线", NULL); |
| | |
| | | } else if (parkCount == 1) { |
| | | if (carray[0] == crossCtrlLine) { |
| | | // 不按规定线路,顺序形式,不合格 |
| | | AddExamFault(6, rtkTime); |
| | | AddExamFault(20101, rtkTime); |
| | | DEBUG("不按规定线路,顺序形式"); |
| | | } |
| | | carray[1] = crossCtrlLine; |
| | | } else if (parkCount == 2) { |
| | | if (carray[0] != crossCtrlLine) { |
| | | // 不按规定线路,顺序形式,不合格 |
| | | AddExamFault(6, rtkTime); |
| | | AddExamFault(20101, rtkTime); |
| | | DEBUG("不按规定线路,顺序形式"); |
| | | } else { |
| | | // 离开测试区,停止计时 |
| | |
| | | // 完成超时,不合格 |
| | | if (!reportExamTimeout) { |
| | | reportExamTimeout = true; |
| | | AddExamFault(10, rtkTime); |
| | | AddExamFault(20105, rtkTime); |
| | | DEBUG("项目超时"); |
| | | } |
| | | } |
| | |
| | | // 同方向再启动,继续判断是否停车超时 |
| | | if (tp - stopTimepoint >= CorrectPauseCriteria(examParam.park_bottom_pause_criteria) && reverseCar) { |
| | | // 停车超2秒,每次扣5分 |
| | | AddExamFault(11, rtkTime); |
| | | AddExamFault(20106, rtkTime); |
| | | DEBUG("中途停车"); |
| | | } |
| | | } else if (moveDirect == -1) { |
| | |
| | | if (darray[parkCount] == 0) { |
| | | if (!crossCtrlLineSw) { |
| | | // 倒车前,前轮未驶过控制线 |
| | | AddExamFault(9, rtkTime); |
| | | AddExamFault(20104, rtkTime); |
| | | DEBUG("倒车前,前轮未驶过控制线"); |
| | | } |
| | | darray[parkCount] = 1; |
| | |
| | | if (parkStatus[parkCount] != 1) { |
| | | // 倒库不入,不合格 |
| | | reportParkFail = true; |
| | | AddExamFault(8, rtkTime); |
| | | AddExamFault(20103, rtkTime); |
| | | DEBUG("倒库不入"); |
| | | } |
| | | } |
| | |
| | | // 切换为倒车 |
| | | if (!crossCtrlLineSw) { |
| | | // 倒车前,前轮未驶过控制线 |
| | | AddExamFault(9, rtkTime); |
| | | AddExamFault(20104, rtkTime); |
| | | DEBUG("倒车前,前轮未驶过控制线"); |
| | | } |
| | | darray[parkCount] = 1; |
| | |
| | | if (CrashRedLine1(map, car)) { |
| | | if (!occurCrashRedLine1 && occurMoveBack) { |
| | | // 车轮压边线,每次扣10分 |
| | | AddExamFault(23, rtkTime); |
| | | AddExamFault(20403, rtkTime); |
| | | DEBUG("车轮压边线"); |
| | | occurCrashRedLine1 = true; |
| | | } |
| | |
| | | if (CrashRedLine2(map, car)) { |
| | | if (!occurCrashRedLine2 && occurMoveBack) { |
| | | // 车身压库位线,每次扣10分 |
| | | AddExamFault(24, rtkTime); |
| | | AddExamFault(20404, rtkTime); |
| | | DEBUG("车身压库位线"); |
| | | occurCrashRedLine2 = true; |
| | | } |
| | |
| | | if (ExitParkArea(map, car) || ExitParkArea2(map, car)) { |
| | | if (!parkSuccess && occurMoveBack && !reportParkFail) { |
| | | // 直接驶离测试区,认为移库不入 |
| | | AddExamFault(21, rtkTime); |
| | | AddExamFault(10103, rtkTime); |
| | | reportParkFail = true; |
| | | DEBUG("直接驶离测试区,移库不入"); |
| | | DEBUG("直接驶离测试区,不按考试员指令驾驶"); |
| | | } |
| | | testing = false; |
| | | goto TEST_END; |
| | |
| | | |
| | | if (!reportExamTimeout && tp - moveBackTimePoint >= examParam.park_edge_limit_time) { |
| | | // 超时90秒,不合格 |
| | | AddExamFault(22, rtkTime); |
| | | AddExamFault(20402, rtkTime); |
| | | reportExamTimeout = true; |
| | | DEBUG("移库90秒超时"); |
| | | } |
| | |
| | | // 同方向再启动,继续判断是否停车超时 |
| | | if (tp - stopTimepoint >= CorrectPauseCriteria(examParam.park_edge_pause_criteria) && occurMoveBack) { |
| | | // 停车超2秒,每次扣5分 |
| | | AddExamFault(26, rtkTime); |
| | | AddExamFault(20406, rtkTime); |
| | | DEBUG("停车超时"); |
| | | } |
| | | } else { |
| | |
| | | |
| | | if (!parkSuccess && !reportParkFail) { |
| | | // 停止后,车身出线,不合格 |
| | | AddExamFault(21, rtkTime); |
| | | AddExamFault(20401, rtkTime); |
| | | reportParkFail = true; |
| | | DEBUG("移库不入"); |
| | | } |
| | |
| | | // 在这里检查转向灯状态 |
| | | if (ReadCarStatus(TURN_SIGNAL_LAMP) != LEFT_TURN_LIGHT) { |
| | | // 不开转向灯,扣10分 |
| | | AddExamFault(25, rtkTime); |
| | | AddExamFault(20405, rtkTime); |
| | | DEBUG("未开启转向灯"); |
| | | } |
| | | } |
| | |
| | | if (CrashRedLine(map, car)) { |
| | | // 车轮压线,不合格 |
| | | if (!occurCrashRedLine) { |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(10116, rtkTime); |
| | | DEBUG("车轮压线"); |
| | | } |
| | | occurCrashRedLine = true; |
| | |
| | | } else if (stopCar && !handBreakActive) { |
| | | // 检查是否拉住手刹 |
| | | handBreakActive = true; |
| | | AddExamFault(19, rtkTime); |
| | | AddExamFault(20306, rtkTime); |
| | | DEBUG("没拉手刹"); |
| | | } |
| | | prevMoveDirect = moveDirect; |
| | |
| | | |
| | | if (dis1 > examParam.ramp_stoppoint_red_distance) { |
| | | // 距离停止线前后超出50厘米 |
| | | AddExamFault(12, rtkTime); |
| | | AddExamFault(20301, rtkTime); |
| | | DEBUG("距离停止线前后超出50厘米,不合格"); |
| | | } else if (fabs(dis1) > EPSILON) { |
| | | // 前保险没有位于停止带内,但没有超出50厘米,扣10分 |
| | | AddExamFault(17, rtkTime); |
| | | AddExamFault(20304, rtkTime); |
| | | DEBUG("前保险没有位于停止带内,但没有超出50厘米"); |
| | | } |
| | | |
| | | if (dis2 > examParam.ramp_edge_red_distance) { |
| | | // 距离边线超出50厘米,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(20302, rtkTime); |
| | | DEBUG("距离边线超出50厘米"); |
| | | } else if (dis2 > examParam.ramp_edge_yellow_distance) { |
| | | // 距离边线超出30厘米,扣10分 |
| | | AddExamFault(18, rtkTime); |
| | | AddExamFault(20305, rtkTime); |
| | | DEBUG("距离边线超出30厘米"); |
| | | } |
| | | } |
| | |
| | | |
| | | if (slideDistance > examParam.ramp_slide_red_distance && !slideLongDistance && !reportSlideFault) { |
| | | // 后滑超过30厘米, 不合格 |
| | | AddExamFault(16, rtkTime); |
| | | AddExamFault(10106, rtkTime); |
| | | DEBUG("后滑超过30厘米"); |
| | | slideLongDistance = true; |
| | | reportSlideFault = true; |
| | |
| | | DistanceOf(stopPoint, car->carXY[car->axial[AXIAL_FRONT]]) < 0.1)) { |
| | | if (TimeMakeComposite(rtkTime->hh, rtkTime->mm, rtkTime->ss, rtkTime->mss*10) - stopCarTime > examParam.ramp_start_car_limit_time) { |
| | | // 起步时间超过30秒,不合格 |
| | | AddExamFault(15, rtkTime); |
| | | AddExamFault(20303, rtkTime); |
| | | DEBUG("起步时间超过30秒"); |
| | | reportStartTimeout = true; |
| | | } |
| | |
| | | if (slideNormalDistance && !slideLongDistance && !reportSlideFault) { |
| | | reportSlideFault = true; |
| | | // 后滑超过10厘米,但没超过30厘米 |
| | | AddExamFault(20, rtkTime); |
| | | AddExamFault(10204, rtkTime); |
| | | DEBUG("后滑超过10厘米,但没超过30厘米"); |
| | | } |
| | | } |
| | |
| | | if (!crashRedLine) { |
| | | crashRedLine = true; |
| | | // 碾压道路边缘,不合格 |
| | | AddExamFault(29, rtkTime); |
| | | AddExamFault(20701, rtkTime); |
| | | DEBUG("碾压道路边缘"); |
| | | } |
| | | } else { |
| | |
| | | |
| | | if (tp - stopTimepoint >= CorrectPauseCriteria(examParam.turn_a90_pause_criteria) && !reportStopCarTimeout) { |
| | | // 停车超2秒,每次扣5分 |
| | | AddExamFault(31, rtkTime); |
| | | AddExamFault(20703, rtkTime); |
| | | DEBUG("中途停车"); |
| | | reportStopCarTimeout = true; |
| | | } |
| | |
| | | if ((turn_direct == 'R' && ReadCarStatus(TURN_SIGNAL_LAMP) != RIGHT_TURN_LIGHT) || |
| | | (turn_direct == 'L' && ReadCarStatus(TURN_SIGNAL_LAMP) != LEFT_TURN_LIGHT)) { |
| | | DEBUG("转向灯未开启"); |
| | | AddExamFault(30, rtkTime); |
| | | AddExamFault(20702, rtkTime); |
| | | } |
| | | } |
| | | turnLeftFinished = true; |
| | |
| | | if (sensor.value != LEFT_TURN_LIGHT) { |
| | | DEBUG("变调未打灯!!"); |
| | | // 没打灯,不合格 |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(30121, rtkTime); |
| | | } else if (TimeGetDiff(rtkTime, &sensor.time) < D_SEC(3)) { |
| | | DEBUG("转向灯时间不足"); |
| | | // 不足3秒,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(30122, rtkTime); |
| | | } |
| | | } |
| | | } |
| | |
| | | if (sensor.name == HAND_BREAK && sensor.value == BREAK_ACTIVE) { |
| | | DEBUG("Handbreak active move over 10m"); |
| | | // 手刹拉起状态下,行驶了10米以上,不合格 |
| | | AddExamFault(25, rtkTime); |
| | | AddExamFault(40205, rtkTime); |
| | | } else if (handBreakActive) { |
| | | // 手刹拉起状态下,行驶了1米以上,扣10分 |
| | | DEBUG("Handbreak active move over 1M"); |
| | | AddExamFault(26, rtkTime); |
| | | AddExamFault(40206, rtkTime); |
| | | } |
| | | |
| | | PlayTTS(examParam.start_car_end_tts, NULL); |
| | |
| | | if (sensor.name == DOOR && sensor.value == DOOR_OPEN) { |
| | | // 车门未完全关闭,不合格 |
| | | DEBUG("车门未关闭"); |
| | | AddExamFault(23, rtkTime); |
| | | AddExamFault(40202, rtkTime); |
| | | } |
| | | |
| | | sensor = ReadCarSensorValue(HAND_BREAK); |
| | |
| | | if (ReadCarStatus(ENGINE_RPM) > examParam.start_car_max_rpm && !checkEngineRPM) { |
| | | // 转速超标,不合格 |
| | | DEBUG("转速超标"); |
| | | AddExamFault(29, rtkTime); |
| | | AddExamFault(40210, rtkTime); |
| | | checkEngineRPM = true; |
| | | } |
| | | |
| | |
| | | if (ReadOdo() - maxMoveDistance > examParam.change_lane_limit_distance) { |
| | | // 超车未完成 |
| | | DEBUG("变道固定距离内未完成 当前里程 %f", ReadOdo()); |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(30103, rtkTime); |
| | | return false; |
| | | } |
| | | |
| | |
| | | if (fabs(offset2 - offsetBase) > examParam.straight_max_offset) { |
| | | DEBUG("直线偏移大于30厘米 offset2 = %f", fabs(offset2 - offsetBase)); |
| | | // 偏移大于30厘米,不合格 |
| | | AddExamFault(30, rtkTime); |
| | | AddExamFault(40301, rtkTime); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<road_exam dummy_light> <%s>: " fmt, __func__, ##args) |
| | | |
| | | enum { |
| | | TTS_NOT_START, |
| | | TTS_DOING, |
| | | TTS_DONE, |
| | | WAIT_OPERATE, |
| | | CHECK_OPERATE |
| | | }; |
| | | |
| | | static struct RtkTime currRtkTime; |
| | | static struct dummy_light_exam *content; |
| | | static int contentNum; |
| | | |
| | | static int checkCnt; |
| | | static bool turn_left_active, flash_beam_active; |
| | | static int question; |
| | | |
| | | static int examTtsSeq = 0; |
| | | static vector<int> process; |
| | | |
| | | static bool testing; |
| | | |
| | | static void DummyLightCheckActive(union sigval sig); |
| | | static void ExamDummyLight(union sigval sig); |
| | | static void CheckSolution(union sigval sig); |
| | | static void ExamDummyLight(void); |
| | | |
| | | void StartDummyLightExam(struct dummy_light_exam *ptr, int num, const struct RtkTime* rtkTime) |
| | | { |
| | | DEBUG("StartDummyLightExam"); |
| | | content = ptr; |
| | | contentNum = num; |
| | | question = 0; |
| | | |
| | | if (content != NULL && num > 0) { |
| | | DEBUG("启动灯光"); |
| | | currRtkTime = *rtkTime; |
| | | |
| | | for (int i = 0; i < contentNum; ++i) { |
| | | content[i].itemStatus = TTS_NOT_START; |
| | | |
| | | DEBUG("灯光项目 <%d> item %d, TTS %s", i, content[i].item, content[i].tts); |
| | | DEBUG("灯光项目 <%d> item %d, TTS %s", i, content[i].item, content[i].tts.c_str()); |
| | | } |
| | | testing = true; |
| | | |
| | | AppTimer_delete(DummyLightCheckActive); |
| | | AppTimer_delete(ExamDummyLight); |
| | | AppTimer_add(ExamDummyLight, D_SEC(2)); |
| | | AppTimer_delete(CheckSolution); |
| | | ExamDummyLight(); |
| | | } else { |
| | | testing = false; |
| | | } |
| | | } |
| | | |
| | | int ExecuteDummyLightExam(const struct RtkTime* rtkTime) |
| | | bool ExecuteDummyLightExam(const struct RtkTime* rtkTime) |
| | | { |
| | | currRtkTime = *rtkTime; |
| | | return (testing)?1:2; |
| | | return testing; |
| | | } |
| | | |
| | | void DummyLightTTSDone(int id) |
| | | { |
| | | // 等语音播报完毕后计时 |
| | | if (id == examTtsSeq && testing) { |
| | | if (testing) { |
| | | vector<int>().swap(process); |
| | | |
| | | for (int i = 0; i < contentNum; ++i) { |
| | | if (content[i].itemStatus == TTS_DOING) { |
| | | DEBUG("DummyLightTTSDone item %d", content[i].item); |
| | | content[i].itemStatus = TTS_DONE; |
| | | break; |
| | | // 预读取有中间操作步骤的灯光 |
| | | for (int i = 0; i < content[question].process.size(); ++i) { |
| | | if (ReadCarStatus((content[question].process[i]>>8) & 0xFF) == content[question].process[i] & 0xFF) { |
| | | process.push_back(content[question].process[i]); |
| | | } |
| | | } |
| | | |
| | | AppTimer_add(ExamDummyLight, 100); |
| | | AppTimer_delete(CheckSolution); |
| | | AppTimer_add(CheckSolution, D_SEC(5)); |
| | | } |
| | | } |
| | | |
| | | void TerminateDummyLightExam(void) |
| | | { |
| | | testing = false; |
| | | AppTimer_delete(DummyLightCheckActive); |
| | | AppTimer_delete(ExamDummyLight); |
| | | AppTimer_delete(CheckSolution); |
| | | } |
| | | |
| | | static void DummyLightCheckActive(union sigval sig) |
| | | void handleLigthExam(uint16_t id, int value) |
| | | { |
| | | int active = sig.sival_int; |
| | | AppTimer_delete(DummyLightCheckActive); |
| | | DEBUG("DummyLightCheckActive item = %d", active); |
| | | |
| | | switch (active) { |
| | | 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 (++checkCnt < 5) { |
| | | if (ReadCarStatus(FLASH_BEAM_LAMP) == FLASH_BEAM_LIGHT) { |
| | | flash_beam_active = true; |
| | | } |
| | | AppTimer_add(DummyLightCheckActive, D_SEC(1), active); |
| | | return; |
| | | } else { |
| | | if (!flash_beam_active) { |
| | | AddExamFault(58, &currRtkTime); |
| | | if (testing) { |
| | | for (int i = 0; i < content[question].process.size(); ++i) { |
| | | if (id == ((content[question].process[i] >> 8) & 0xFF) && value == (content[question].process[i] & 0xFF)) { |
| | | if (process.size() == 0 || process.back() != content[question].process[i]) { |
| | | process.push_back(content[question].process[i]); |
| | | } |
| | | } |
| | | 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; |
| | | } |
| | | |
| | | for (int i = 0; i < contentNum; ++i) { |
| | | if (content[i].item == active) { |
| | | content[i].itemStatus = CHECK_OPERATE; |
| | | break; |
| | | } |
| | | } |
| | | |
| | | AppTimer_add(ExamDummyLight, 500); |
| | | } |
| | | |
| | | static void ExamDummyLight(union sigval sig) |
| | | static void CheckSolution(union sigval sig) |
| | | { |
| | | int i = 0; |
| | | AppTimer_delete(ExamDummyLight); |
| | | int question = sig.sival_int; |
| | | |
| | | for (; i < contentNum; ++i) { |
| | | switch (content[i].itemStatus) { |
| | | case TTS_NOT_START: |
| | | DEBUG("提示语言 %d: %s", content[i].item, content[i].tts); |
| | | content[i].itemStatus = TTS_DOING; |
| | | examTtsSeq = PlayTTS(content[i].tts, DummyLightTTSDone); |
| | | // 等待TTS播放完毕 |
| | | return; |
| | | case TTS_DOING: |
| | | return; |
| | | case TTS_DONE: |
| | | content[i].itemStatus = WAIT_OPERATE; |
| | | AppTimer_delete(CheckSolution); |
| | | |
| | | AppTimer_delete(DummyLightCheckActive); |
| | | if (content[question].process.size() > 0) { |
| | | if (content[question].process.size() != process.size()) { |
| | | AddExamFault(content[question].wrongCode, &currRtkTime); |
| | | goto NEXT_LIGHT; |
| | | } else { |
| | | // 操作顺序也要满足 |
| | | for (int i = 0; i < content[question].process.size(); ++i) { |
| | | if (process[i] != content[question].process[i]) { |
| | | AddExamFault(content[question].wrongCode, &currRtkTime); |
| | | goto NEXT_LIGHT; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | DEBUG("提示语言完毕 %d", content[i].item); |
| | | |
| | | if (content[i].item == OVERTAKE) { |
| | | checkCnt = 0; |
| | | turn_left_active = flash_beam_active = false; |
| | | AppTimer_add(DummyLightCheckActive, D_SEC(1), content[i].item); |
| | | } else if (content[i].item == THROUGE_CROSSWALK || content[i].item == THROUGE_CURVE || content[i].item == THROUGE_CROSSROADS) { |
| | | checkCnt = 0; |
| | | flash_beam_active = false; |
| | | AppTimer_add(DummyLightCheckActive, D_SEC(1), content[i].item); |
| | | } else if (content[i].item >= 100) |
| | | AppTimer_add(DummyLightCheckActive, D_SEC(3), content[i].item); |
| | | else |
| | | AppTimer_add(DummyLightCheckActive, D_SEC(5), content[i].item); |
| | | return; |
| | | case WAIT_OPERATE: |
| | | return; |
| | | case CHECK_OPERATE: |
| | | default: |
| | | for (int i = 0; i < content[question].solution.size(); ++i) { |
| | | if (ReadCarStatus((content[question].solution[i]>>8)&0xFF) != content[question].solution[i] & 0xFF) { |
| | | AddExamFault(content[question].wrongCode, &currRtkTime); |
| | | break; |
| | | } |
| | | } |
| | | |
| | | if (i >= contentNum) { |
| | | NEXT_LIGHT: |
| | | question++; |
| | | ExamDummyLight(); |
| | | } |
| | | |
| | | static void ExamDummyLight(void) |
| | | { |
| | | if (testing && question < contentNum) { |
| | | PlayTTS(content[question].tts, DummyLightTTSDone); |
| | | } else { |
| | | testing = false; |
| | | } |
| | | } |
| | |
| | | #define MYAPPLICATION2_DUMMY_LIGHT_H |
| | | |
| | | #include "../driver_test.h" |
| | | #include <vector> |
| | | #include <string> |
| | | |
| | | enum { |
| | | TURN_ON_DIPPED_LAMP = 1, |
| | |
| | | |
| | | struct dummy_light_exam { |
| | | int item; |
| | | int itemStatus; |
| | | char tts[512]; |
| | | int wrongCode; |
| | | std::vector<int> process; |
| | | std::vector<int> solution; |
| | | std::string tts; |
| | | }; |
| | | |
| | | void StartDummyLightExam(struct dummy_light_exam *ptr, int num, const struct RtkTime* rtkTime); |
| | | int ExecuteDummyLightExam(const struct RtkTime* rtkTime); |
| | | bool ExecuteDummyLightExam(const struct RtkTime* rtkTime); |
| | | void DummyLightTTSDone(int id); |
| | | void TerminateDummyLightExam(void); |
| | | void handleLigthExam(uint16_t id, int value); |
| | | |
| | | #endif //MYAPPLICATION2_DUMMY_LIGHT_H |
| | |
| | | } else if (sensor.value != expectGear) { |
| | | // 未按指令操作挡位,不合格 |
| | | DEBUG("首次换挡错误 GEAR %d 希望 %d", sensor.value, expectGear); |
| | | AddExamFault(31, rtkTime); |
| | | AddExamFault(40401, rtkTime); |
| | | return false; |
| | | } else { |
| | | // 在此挡位行驶一定距离,再执行下一个 |
| | |
| | | } else if (sensor.value != expectGear) { |
| | | // 未按指令操作挡位,不合格 |
| | | DEBUG("二次换挡错误 GEAR %d 希望 %d", sensor.value, expectGear); |
| | | AddExamFault(31, rtkTime); |
| | | AddExamFault(40401, rtkTime); |
| | | return false; |
| | | } else { |
| | | // 在此挡位行驶一定距离,再执行下一个 |
| | |
| | | if (ReadOdo() - maxMoveDistance > 120) { |
| | | // 未按指令操作挡位,不合格 |
| | | DEBUG("未按指令操作挡位,超时"); |
| | | AddExamFault(31, rtkTime); |
| | | AddExamFault(40401, rtkTime); |
| | | return false; |
| | | } |
| | | |
| | |
| | | originalLane = currLane; |
| | | } else { |
| | | DEBUG("右侧超车"); |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(30103, rtkTime); |
| | | return false; |
| | | } |
| | | } else if (setup == 2) { |
| | |
| | | return false; |
| | | } else { |
| | | DEBUG("超车违规变道"); |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(30103, rtkTime); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | if (ReadOdo() - maxMoveDistance > examParam.overtake_limit_distance) { |
| | | // 超车未完成 |
| | | DEBUG("超车固定距离内未完成 当前里程 %f", ReadOdo()); |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(30103, rtkTime); |
| | | return false; |
| | | } |
| | | |
New file |
| | |
| | | // |
| | | // Created by YY on 2020/12/16. |
| | | // |
| | | |
| | | #include "prepare.h" |
| | | #include "../native-lib.h" |
| | | #include "../driver_test.h" |
| | | #include "../test_common/car_sensor.h" |
| | | #include "../common/apptimer.h" |
| | | #include "../jni_log.h" |
| | | |
| | | #define DEBUG(fmt, args...) LOGD("<prepare> <%s>: " fmt, __func__, ##args) |
| | | |
| | | static int touch[4]; |
| | | static int hint_cnt; |
| | | static bool exec = false; |
| | | |
| | | static void TtsBack(int seq); |
| | | static void PrepareTimeout(union sigval sig); |
| | | static void PrepareTimeout2(union sigval sig); |
| | | void StartPrepare(void) |
| | | { |
| | | exec = true; |
| | | hint_cnt = 0; |
| | | memset(touch, 0, sizeof(touch)); |
| | | PlayTTS(examParam.prepare_tts, TtsBack); |
| | | DEBUG("开始上车准备"); |
| | | } |
| | | |
| | | void handlePrepare(uint16_t sensor_id, int value) |
| | | { |
| | | if (!exec) |
| | | return; |
| | | if (sensor_id == SEATBELT) { |
| | | if (value == INSERT_SEATBELT) { |
| | | AppTimer_delete(PrepareTimeout); |
| | | // 检查绕车传感器情况 |
| | | if (touch[0] + touch[1] + touch[2] + touch[3] != 4) { |
| | | exec = false; |
| | | PrepareOver(-1); |
| | | } else { |
| | | exec = false; |
| | | PrepareOver(0); |
| | | } |
| | | } else { |
| | | // 安全带解开 |
| | | AppTimer_delete(PrepareTimeout2); |
| | | } |
| | | } |
| | | |
| | | if (sensor_id == SURROUND_CAR_1 && value == SURROUND_CAR_ACTIVE && touch[0] != 1) { |
| | | touch[0] = 1; |
| | | PlayTTS(examParam.touch_leftfront_tts, NULL); |
| | | DEBUG("触摸传感器1"); |
| | | } |
| | | if (sensor_id == SURROUND_CAR_2 && value == SURROUND_CAR_ACTIVE && touch[1] != 1) { |
| | | touch[1] = 1; |
| | | PlayTTS(examParam.touch_leftrear_tts, NULL); |
| | | DEBUG("触摸传感器2"); |
| | | } |
| | | if (sensor_id == SURROUND_CAR_3 && value == SURROUND_CAR_ACTIVE && touch[2] != 1) { |
| | | touch[2] = 1; |
| | | PlayTTS(examParam.touch_rightrear_tts, NULL); |
| | | DEBUG("触摸传感器3"); |
| | | } |
| | | if (sensor_id == SURROUND_CAR_4 && value == SURROUND_CAR_ACTIVE && touch[3] != 1) { |
| | | touch[3] = 1; |
| | | PlayTTS(examParam.touch_rightfront_tts, NULL); |
| | | DEBUG("触摸传感器4"); |
| | | } |
| | | } |
| | | |
| | | static void TtsBack(int seq) |
| | | { |
| | | if (hint_cnt == 0) { |
| | | if (ReadCarStatus(SEATBELT) == INSERT_SEATBELT) { |
| | | // 再次提示 |
| | | AppTimer_add(PrepareTimeout2, D_SEC(10)); |
| | | DEBUG("设置再次提醒"); |
| | | } |
| | | AppTimer_add(PrepareTimeout, D_MIN(2)); |
| | | DEBUG("设置2分钟超时"); |
| | | } |
| | | hint_cnt++; |
| | | } |
| | | |
| | | static void PrepareTimeout(union sigval sig) |
| | | { |
| | | DEBUG("上车准备超时"); |
| | | AppTimer_delete(PrepareTimeout); |
| | | exec = false; |
| | | PrepareOver(-2); |
| | | } |
| | | |
| | | static void PrepareTimeout2(union sigval sig) |
| | | { |
| | | AppTimer_delete(PrepareTimeout2); |
| | | |
| | | PlayTTS(examParam.prepare_tts, TtsBack); |
| | | } |
New file |
| | |
| | | // |
| | | // Created by YY on 2020/12/16. |
| | | // |
| | | |
| | | #ifndef MYAPPLICATION2_PREPARE_H |
| | | #define MYAPPLICATION2_PREPARE_H |
| | | |
| | | #include <cstdint> |
| | | |
| | | void StartPrepare(void); |
| | | void handlePrepare(uint16_t sensor_id, int value); |
| | | void PrepareOver(int res); |
| | | |
| | | #endif //MYAPPLICATION2_PREPARE_H |
| | |
| | | if (newLineType >= 100) { |
| | | newLineType -= 100; |
| | | DEBUG("非法跨越分道线"); |
| | | AddExamFault(11, rtkTime); |
| | | AddExamFault(30119, rtkTime); |
| | | } |
| | | if (newLineType == LINE_SOLID && CrashLineType != LINE_SOLID) { |
| | | // 车辆行驶中骑轧车道中心实线或者车道边缘实线,不合格 |
| | | DEBUG("撞道路边缘线"); |
| | | AddExamFault(11, rtkTime); |
| | | AddExamFault(30119, rtkTime); |
| | | } |
| | | if (newLineType == LINE_BOUNDARY && CrashLineType != LINE_BOUNDARY) { |
| | | // 车辆越界,逃跑了,不合格 |
| | | DEBUG("车辆越界"); |
| | | AddExamFault(3, rtkTime); |
| | | AddExamFault(30103, rtkTime); |
| | | } |
| | | |
| | | if (newLineType == LINE_DOTTED || newLineType == LINE_HALF_SOLID_LEFT || newLineType == LINE_HALF_SOLID_RIGHT) { |
| | |
| | | DEBUG("长时间压虚线"); |
| | | checkCrashGreenTimeout = 2; |
| | | // 长时间骑轧车道分界线行驶,不合格 |
| | | AddExamFault(12, rtkTime); |
| | | AddExamFault(30120, rtkTime); |
| | | } |
| | | } |
| | | } else { |
| | |
| | | if (turnSignalStatus.value != LEFT_TURN_LIGHT) { |
| | | DEBUG("变调未打灯!!"); |
| | | // 没打灯,不合格 |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(30121, rtkTime); |
| | | } else if (TimeGetDiff(&crashGreenStartTime, &turnSignalStatus.time) < |
| | | examParam.turn_signal_min_advance) { |
| | | DEBUG("转向灯时间不足 %02d-%02d-%02d %02d:%02d:%02d.%03d -> %02d-%02d-%02d %02d:%02d:%02d.%03d", |
| | |
| | | turnSignalStatus.time.mm, turnSignalStatus.time.ss, turnSignalStatus.time.mss * 10); |
| | | |
| | | // 不足3秒,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(30122, rtkTime); |
| | | } |
| | | } else { |
| | | if (turnSignalStatus.value != RIGHT_TURN_LIGHT) { |
| | | DEBUG("变调未打灯!!"); |
| | | // 没打灯,不合格 |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(30121, rtkTime); |
| | | } else if (TimeGetDiff(&crashGreenStartTime, &turnSignalStatus.time) < |
| | | examParam.turn_signal_min_advance) { |
| | | DEBUG("转向灯时间不足 %02d-%02d-%02d %02d:%02d:%02d.%03d -> %02d-%02d-%02d %02d:%02d:%02d.%03d", |
| | |
| | | turnSignalStatus.time.YY, turnSignalStatus.time.MM, turnSignalStatus.time.DD, turnSignalStatus.time.hh, |
| | | turnSignalStatus.time.mm, turnSignalStatus.time.ss, turnSignalStatus.time.mss * 10); |
| | | // 不足3秒,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(30122, rtkTime); |
| | | } |
| | | } |
| | | |
| | | if (((ChangeLane.gain < 0 && gain < 0) || (ChangeLane.gain > 0 && gain > 0)) && TimeGetDiff(rtkTime, &ChangeLane.time) < examParam.continuous_change_lane_min_time) { |
| | | DEBUG("连续变道"); |
| | | AddExamFault(15, rtkTime); |
| | | AddExamFault(30125, rtkTime); |
| | | } |
| | | ChangeLane.gain = gain; |
| | | ChangeLane.time = *rtkTime; |
| | |
| | | occurOverSpeed = true; |
| | | // 超速,不合格 |
| | | DEBUG("超速 %f", ConvertMs2KMh(speed)); |
| | | AddExamFault(10, rtkTime); |
| | | AddExamFault(30118, rtkTime); |
| | | } |
| | | } else if (ConvertMs2KMh(speed) < examParam.road_max_speed - 5) { |
| | | occurOverSpeed = false; |
| | |
| | | if (!occurSecondBreak) { |
| | | DEBUG("副刹车动作了"); |
| | | occurSecondBreak = true; |
| | | AddExamFault(17, rtkTime); |
| | | AddExamFault(30132, rtkTime); |
| | | } |
| | | } else { |
| | | occurSecondBreak = false; |
| | |
| | | if (currGear != GEAR_N && prevGear == GEAR_N) { |
| | | // 一次换挡 |
| | | if (gearChange == currGear && TimeGetDiff(rtkTime, &gearChangeTimePoint) < D_SEC(5)) { |
| | | AddExamFault(7, rtkTime); |
| | | AddExamFault(30113, rtkTime); |
| | | } |
| | | |
| | | gearChange = currGear; |
| | |
| | | TimeGetDiff(rtkTime, &gearNSlideTimePoint) > examParam.gear_n_allow_time) { |
| | | // 空档滑行超5秒,不合格 |
| | | DEBUG("挡位滑行,超过5秒"); |
| | | AddExamFault(8, rtkTime); |
| | | AddExamFault(30114, rtkTime); |
| | | GearNSlideStatus = 2; |
| | | } |
| | | } else if (GearNSlideStatus != 0) { |
| | |
| | | if (gearErrorTime > examParam.gear_speed_error_cumulative_time) { |
| | | // 累计15秒,挡位-车速不匹配,不合格 |
| | | DEBUG("挡位错误超过15秒"); |
| | | AddExamFault(6, rtkTime); |
| | | AddExamFault(30112, rtkTime); |
| | | gearErrorTime = 0; |
| | | } |
| | | |
| | |
| | | |
| | | if (slideNormalDistance) { |
| | | // 后滑,扣10分 |
| | | AddExamFault(18, rtkTime); |
| | | AddExamFault(30202, rtkTime); |
| | | DEBUG("后滑超过10厘米, 但不超过30厘米"); |
| | | } |
| | | |
| | |
| | | if (TimeGetDiff(rtkTime, &stopTimepoint) >= CorrectPauseCriteria(examParam.road_pause_criteria) && !StopCarOnRedArea && |
| | | StopOnRedArea(RoadMap, car)) { |
| | | // 停车超2秒,停在红区,不合格 |
| | | AddExamFault(16, rtkTime); |
| | | AddExamFault(30128, rtkTime); |
| | | DEBUG("禁停区停车"); |
| | | StopCarOnRedArea = true; |
| | | } |
| | |
| | | |
| | | if (slideDistance > examParam.road_slide_red_distance && !slideLongDistance) { |
| | | // 后滑超过30厘米, 不合格 |
| | | AddExamFault(5, rtkTime); |
| | | AddExamFault(30107, rtkTime); |
| | | DEBUG("后滑超过30厘米"); |
| | | slideLongDistance = true; |
| | | slideNormalDistance = false; |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | ExitTarget(RoadMap, car, CarModelList, rtkTime); |
| | | |
| | | if (RoadMap.calibrate == 0) { |
| | |
| | | if (!GetErrorLaneRpt(currExamMapIndex, stop_line_index)) { |
| | | DEBUG("不按规定车道标向行驶 %d: %d 期望 = %d guide = %d", currExamMapIndex, |
| | | stop_line_index, act, Lane.guide); |
| | | AddExamFault(9, rtkTime); |
| | | AddExamFault(30117, rtkTime); |
| | | SetErrorLaneRpt(currExamMapIndex, stop_line_index, true); |
| | | } |
| | | } |
| | |
| | | |
| | | road_end_point_t ep = NearbyRoadEndPoint(currExamMapIndex, RoadMap, car); |
| | | // 提示路口怎么走 |
| | | if (forward == 1) { |
| | | HintCrossing(RoadMap, ep.road_index, ep.stop_line_index, ep.distance); |
| | | } |
| | | |
| | | double freeSepDis = SeparateLength(RoadMap, Lane, car); |
| | | |
| | |
| | | freeRunExceptDistance = 60.0; |
| | | } else if (RoadExamStatus == ROAD_EXAM_ITEM_CAR_STOP) { |
| | | // 考试结束 |
| | | MA_SendExamStatus(1, 1); |
| | | MA_SendExamStatus(0, 0); |
| | | PlayTTS("考试结束", NULL); |
| | | } else { |
| | | freeRunExceptDistance = 2;//250.0; |
| | | } |
| | |
| | | if (turnSignalStatus.value != LEFT_TURN_LIGHT) { |
| | | DEBUG("变调未打灯!!"); |
| | | // 没打灯,不合格 |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(30121, rtkTime); |
| | | } else if (TimeGetDiff(&beginTurnTime, &turnSignalStatus.time) < |
| | | examParam.turn_signal_min_advance) { |
| | | DEBUG("转向灯时间不足"); |
| | | // 不足3秒,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(30122, rtkTime); |
| | | } |
| | | } else { |
| | | if (turnSignalStatus.value != RIGHT_TURN_LIGHT) { |
| | | DEBUG("变调未打灯!!"); |
| | | // 没打灯,不合格 |
| | | AddExamFault(13, rtkTime); |
| | | AddExamFault(30121, rtkTime); |
| | | } else if (TimeGetDiff(&beginTurnTime, &turnSignalStatus.time) < |
| | | examParam.turn_signal_min_advance) { |
| | | DEBUG("转向灯时间不足"); |
| | | // 不足3秒,不合格 |
| | | AddExamFault(14, rtkTime); |
| | | AddExamFault(30122, rtkTime); |
| | | } |
| | | } |
| | | } else if (turnTimeCnt > D_SEC(10)) { |
| | |
| | | } |
| | | } |
| | | |
| | | // DEBUG("检查触发点 道 %d 路 %d", RoadMap.examScheme[0].triggerLines[0].road, RoadMap.roads[index].id); |
| | | |
| | | for (int j = 0; j < RoadMap.examScheme[0].triggerLines.size(); ++j) { |
| | | if (RoadMap.examScheme[0].triggerLines[j].road == RoadMap.roads[index].id) { |
| | | |
| | |
| | | |
| | | TriggerDetect.insert(pair<int, trigger_detect_t>(j, up)); |
| | | |
| | | DEBUG("观察子<%d> 加入 %f", j, MAX(dist1, dist2)); |
| | | DEBUG("观察子<%d> road_id %d 加入 (%f,%f)", j, RoadMap.roads[index].id, RoadMap.examScheme[0].triggerLines[j].points[0].X, RoadMap.examScheme[0].triggerLines[j].points[0].Y); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | if (roadIndex < 0) { |
| | | DEBUG("停车距离超标,靠边停车结束"); |
| | | AddExamFault(33, rtkTime); |
| | | AddExamFault(40602, rtkTime); |
| | | return false; |
| | | } |
| | | |
| | |
| | | DistanceOf(p2, car->carXY[ car->right_rear_tire[TIRE_OUTSIDE] ]) > examParam.stop_car_edge_red_distance) { |
| | | DEBUG("停车超出路边0.5米"); |
| | | // 停车距离超过50厘米,不合格 |
| | | AddExamFault(36, rtkTime); |
| | | AddExamFault(40606, rtkTime); |
| | | return false; |
| | | } else if (DistanceOf(p1, car->carXY[ car->right_front_tire[TIRE_OUTSIDE] ]) > examParam.stop_car_edge_yellow_distance || |
| | | DistanceOf(p2, car->carXY[ car->right_rear_tire[TIRE_OUTSIDE] ]) > examParam.stop_car_edge_yellow_distance) { |
| | | DEBUG("停车超出路边0.3米"); |
| | | // 停车距离超过30厘米,扣10分 |
| | | AddExamFault(37, rtkTime); |
| | | AddExamFault(40607, rtkTime); |
| | | } |
| | | |
| | | time = *rtkTime; |
| | | setup = 4; |
| | | } |
| | | } else if (setup == 4) { |
| | |
| | | if (!BreakHandbreakReleaseSametime && brk.value == BREAK_INACTIVE && hbrk.value == BREAK_INACTIVE) { |
| | | // 拉手刹前,松脚刹,扣10分 |
| | | DEBUG("拉手刹前,松脚刹"); |
| | | AddExamFault(39, rtkTime); |
| | | AddExamFault(40609, rtkTime); |
| | | BreakHandbreakReleaseSametime = true; |
| | | } |
| | | |
| | |
| | | if (rpm.value > ENGINE_MIN_ROTATE) { |
| | | // 下车前,不熄火,扣5分 |
| | | DEBUG("下车前,不熄火"); |
| | | AddExamFault(40, rtkTime); |
| | | AddExamFault(40610, rtkTime); |
| | | } |
| | | if (hbrk.value == BREAK_INACTIVE) { |
| | | // 开门前,未拉手刹, 扣10分 |
| | | DEBUG("开门前,未拉手刹"); |
| | | AddExamFault(38, rtkTime); |
| | | AddExamFault(40608, rtkTime); |
| | | } |
| | | time = *rtkTime; |
| | | OpenDoor = true; |
| | |
| | | if (TimeGetDiff(rtkTime, &time) > examParam.stop_car_open_door_allow_time) { |
| | | // 开门时间超过15秒,不合格 |
| | | DEBUG("开门时间超过15秒"); |
| | | AddExamFault(35, rtkTime); |
| | | AddExamFault(40605, rtkTime); |
| | | return false; |
| | | } |
| | | } else { |
| | | if (TimeGetDiff(rtkTime, &time) > D_SEC(30)) { |
| | | DEBUG("完成停车超时"); |
| | | PlayTTS(examParam.stop_car_end_tts, NULL); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | if (ReadOdo() - beginOdo > examParam.stop_car_limit_distance) { |
| | | // 150米内未停车,不合格 |
| | | DEBUG("停车距离超标,靠边停车结束"); |
| | | AddExamFault(33, rtkTime); |
| | | AddExamFault(40602, rtkTime); |
| | | return false; |
| | | } |
| | | |
| | |
| | | SetTargetReduceRec(TargetReduceRec2, key, rec | OVER_SPEED); |
| | | |
| | | DEBUG("通过学校区域超速 %f kmh", ConvertMs2KMh(speed)); |
| | | AddExamFault(49, rtkTime); |
| | | AddExamFault(41101, rtkTime); |
| | | } |
| | | } else if (distance1 < -1e-3 && distance2 < -1e-3) { |
| | | if (rec != NOT_ENTER) { |
| | |
| | | DEBUG("不按规定减速"); |
| | | |
| | | if (ExamSchemeCrossing(RoadMap, road, x) == ROAD_ACTIVE_FORWARD) { |
| | | AddExamFault(41, rtkTime); |
| | | AddExamFault(40701, rtkTime); |
| | | } else if (ExamSchemeCrossing(RoadMap, road, x) == |
| | | ROAD_ACTIVE_TURN_LEFT) { |
| | | AddExamFault(43, rtkTime); |
| | | AddExamFault(40801, rtkTime); |
| | | } else if (ExamSchemeCrossing(RoadMap, road, x) == |
| | | ROAD_ACTIVE_TURN_RIGHT) { |
| | | AddExamFault(46, rtkTime); |
| | | AddExamFault(40901, rtkTime); |
| | | } |
| | | } |
| | | if (!(it->second & STOP_CAR) && RoadMap.roads[road].stopLine[x].stopFlag) { |
| | | // 不停车瞭望,不合格 |
| | | DEBUG("不停车瞭望"); |
| | | if (ExamSchemeCrossing(RoadMap, road, x) == ROAD_ACTIVE_FORWARD) { |
| | | AddExamFault(42, rtkTime); |
| | | AddExamFault(40701, rtkTime); |
| | | } else if (ExamSchemeCrossing(RoadMap, road, x) == |
| | | ROAD_ACTIVE_TURN_LEFT) { |
| | | AddExamFault(44, rtkTime); |
| | | AddExamFault(40801, rtkTime); |
| | | } else if (ExamSchemeCrossing(RoadMap, road, x) == |
| | | ROAD_ACTIVE_TURN_RIGHT) { |
| | | AddExamFault(47, rtkTime); |
| | | AddExamFault(40901, rtkTime); |
| | | } |
| | | } |
| | | } |
| | |
| | | if (RoadMap.specialAreas[x].type == ZEBRA_CROSSING && |
| | | !(it->second & REDUCE_SPEED)) { |
| | | DEBUG("人行道 不按规定减速"); |
| | | AddExamFault(48, rtkTime); |
| | | AddExamFault(41001, rtkTime); |
| | | } |
| | | if (RoadMap.specialAreas[x].type == BUS_STATION_AREA && |
| | | !(it->second & REDUCE_SPEED)) { |
| | | DEBUG("公交站 不按规定减速"); |
| | | AddExamFault(50, rtkTime); |
| | | AddExamFault(41201, rtkTime); |
| | | } |
| | | RemoveTargetReduceRec(TargetReduceRec2, it->first); |
| | | goto RECHECK2; |
| | |
| | | package com.anyun.exam.lib; |
| | | |
| | | import android.Manifest; |
| | | import android.content.Context; |
| | | import android.content.Intent; |
| | | import android.content.pm.PackageInfo; |
| | | import android.content.pm.PackageManager; |
| | | import android.content.pm.Signature; |
| | | import android.net.Uri; |
| | | import android.os.Build; |
| | | import android.provider.Settings; |
| | | import android.util.Log; |
| | | |
| | | import java.io.ByteArrayOutputStream; |
| | |
| | | import java.security.NoSuchAlgorithmException; |
| | | import java.util.List; |
| | | import java.util.Locale; |
| | | |
| | | import androidx.annotation.NonNull; |
| | | import androidx.core.app.ActivityCompat; |
| | | import androidx.core.content.FileProvider; |
| | | |
| | | public class InstallUtil { |
| | | public static final String TAG = InstallUtil.class.getCanonicalName(); |
| | |
| | | try { |
| | | Log.d(TAG, "升级app 文件存在 当前ver " + getVerCode() + " 当前Name " + getVerName() + " 目标ver " + getVersionCodeFromApk(context, file.getAbsolutePath()) + " 目标name " + getVersionNameFromApk(context, file.getAbsolutePath())); |
| | | |
| | | // Signature[] sig = getSignature(); |
| | | // Signature[] sig2 = getSignature(file.getAbsolutePath()); |
| | | Signature[] sig = getSignature(); |
| | | Signature[] sig2 = getSignature(file.getAbsolutePath()); |
| | | |
| | | /*if ( getFingerprint(sig[0], "SHA-1").equals(getFingerprint(sig2[0], "SHA-1")))*/ { |
| | | if ( getVerCode() <= getVersionCodeFromApk(context, file.getAbsolutePath()) ) { |
| | | if ( getFingerprint(sig[0], "SHA-1").equals(getFingerprint(sig2[0], "SHA-1"))) { |
| | | if ( getVerCode() < getVersionCodeFromApk(context, file.getAbsolutePath()) || |
| | | (getVerCode() == getVersionCodeFromApk(context, file.getAbsolutePath()) && |
| | | !getVerName().equals(getVersionNameFromApk(context, file.getAbsolutePath())))) { |
| | | Log.d(TAG, "安装文件 " + file.getAbsolutePath()); |
| | | String result = execCommand("pm", "install", "-i", getPackageName(), "--user", "0", "-r", "-d", file.getAbsolutePath()); |
| | | Log.d(TAG, "安装结果 " + result); |
| | | } else { |
| | | file.delete(); |
| | | } |
| | | } /*else { |
| | | } else { |
| | | file.delete(); |
| | | }*/ |
| | | } |
| | | } catch (Exception e) { |
| | | Log.e(TAG, "安装发生错误 " + e.getMessage()); |
| | | } |
| | | } |
| | | } |
| | | |
| | | public void InstallAppNormal(Context context, String path) { |
| | | File file = new File(path); |
| | | Log.d(TAG, "ManualInstall " + path); |
| | | |
| | | if (file.exists() && file.isFile()) { |
| | | Signature[] sig = getSignature(); |
| | | Signature[] sig2 = getSignature(file.getAbsolutePath()); |
| | | |
| | | if (getFingerprint(sig[0], "SHA-1").equals(getFingerprint(sig2[0], "SHA-1")) && |
| | | (getVerCode() < getVersionCodeFromApk(context, file.getAbsolutePath()) || |
| | | (getVerCode() == getVersionCodeFromApk(context, file.getAbsolutePath()) && |
| | | !getVerName().equals(getVersionNameFromApk(context, file.getAbsolutePath()))))) { |
| | | |
| | | Intent intent = new Intent(Intent.ACTION_VIEW); |
| | | Uri data; |
| | | String type = "application/vnd.android.package-archive"; |
| | | if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) { |
| | | data = Uri.fromFile(file); |
| | | } else { |
| | | intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION); |
| | | String authority = context.getPackageName() + ".fileProvider"; |
| | | data = FileProvider.getUriForFile(context, authority, file); |
| | | } |
| | | intent.setDataAndType(data, type); |
| | | intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| | | context.startActivity(intent); |
| | | } else { |
| | | Log.d(TAG, "File illegal"); |
| | | } |
| | | } else { |
| | | Log.d(TAG, "File not exist"); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | return result; |
| | | } |
| | | |
| | | /* |
| | | private void checkIsAndroidO() { |
| | | if (Build.VERSION.SDK_INT >= 26) { |
| | | if (context.getPackageManager().canRequestPackageInstalls()) { |
| | | mMainPresenter.installApk(); |
| | | } else { |
| | | //请求安装未知应用来源的权限 |
| | | ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.REQUEST_INSTALL_PACKAGES},INSTALL_PACKAGES_REQUEST_CODE); |
| | | } |
| | | } else { |
| | | mMainPresenter.installApk(); |
| | | } |
| | | } |
| | | |
| | | @Override |
| | | public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { |
| | | super.onRequestPermissionsResult(requestCode, permissions, grantResults); |
| | | switch (requestCode) { |
| | | case INSTALL_PACKAGES_REQUEST_CODE: |
| | | if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { |
| | | mMainPresenter.installApk(); |
| | | } else { |
| | | // 引导用户手动开启安装权限 |
| | | Intent intent = new Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES); |
| | | startActivityForResult(intent, GET_UNKNOWN_APP_SOURCES); |
| | | } |
| | | break; |
| | | default: |
| | | break; |
| | | |
| | | } |
| | | }*/ |
| | | } |
| | |
| | | import android.media.RingtoneManager; |
| | | import android.net.Uri; |
| | | import android.os.Build; |
| | | import android.os.Environment; |
| | | import android.os.Handler; |
| | | import android.os.IBinder; |
| | | import android.os.Message; |
| | |
| | | import androidx.core.app.ActivityCompat; |
| | | import androidx.core.content.ContextCompat; |
| | | |
| | | import java.io.File; |
| | | import java.io.IOException; |
| | | import java.io.InputStream; |
| | | import java.io.UnsupportedEncodingException; |
| | |
| | | */ |
| | | public class RemoteService extends Service { |
| | | private static final String TAG = "RemoteService"; |
| | | |
| | | public static final boolean mAyDevice = true; |
| | | |
| | | /**服务是否销毁标志*/ |
| | | private AtomicBoolean mIsServiceDestroyed = new AtomicBoolean(false); |
| | | private RemoteCallbackList<IListenerInterface> mListenerList = new RemoteCallbackList(); |
| | |
| | | // PlayRing(this, ringUri); |
| | | LimitMaxMinVolume(); |
| | | |
| | | Log.d(TAG, "基带版本 " + getBaseband_Ver()); |
| | | |
| | | String ver = getBaseband_Ver(); |
| | | |
| | | if (mAyDevice == false) { |
| | | mBluetooth = Bluetooth.getInstance(getApplicationContext(), mHandler); |
| | | mBluetooth.OpenBluetooth(); |
| | | // Initialize the BluetoothChatService to perform mBluetooth connections |
| | | mChatService = new BluetoothChatService(this, mHandler); |
| | | } |
| | | |
| | | Log.d(TAG, "基带版本 " + getBaseband_Ver()); |
| | | |
| | | String ver = getBaseband_Ver(); |
| | | |
| | | new Thread(new TestCls()).start(); |
| | | } |
| | | |
| | | class TestCls implements Runnable { |
| | | @Override |
| | | public void run() { |
| | | try { |
| | | Thread.sleep(5000); |
| | | } catch (InterruptedException e) { |
| | | |
| | | } |
| | | |
| | | upgrade.ManualUpgrade(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "/Download/aks3b.apk"); |
| | | } |
| | | } |
| | | |
| | | class AutoUpdateMcuThread implements Runnable { |
| | |
| | | class StartNative implements Runnable { |
| | | @Override |
| | | public void run() { |
| | | startNative(); |
| | | startNative(mAyDevice); |
| | | } |
| | | } |
| | | |
| | |
| | | Process.killProcess(Process.myPid()); |
| | | } |
| | | |
| | | private void onMessageArrived(int cmd, String json) { |
| | | |
| | | private int onMessageArrived(int cmd, String json) { |
| | | Log.d(TAG, "SendMsgToMainProc cmd = " + String.format("%04X", cmd) + " json = " + json); |
| | | int N = mListenerList.getRegisteredCallbackCount(); |
| | | int ret = -1; |
| | | |
| | | synchronized(this) { |
| | | mListenerList.beginBroadcast(); |
| | |
| | | if (mListener != null) { |
| | | try { |
| | | mListener.onMessageArrived(cmd, json); |
| | | ret = 0; |
| | | } catch (RemoteException e) { |
| | | e.printStackTrace(); |
| | | } |
| | | }else{ |
| | | |
| | | } |
| | | } |
| | | mListenerList.finishBroadcast(); |
| | | } |
| | | return ret; |
| | | } |
| | | |
| | | public void SendMsgToMainProc(int cmd, String value) { |
| | | public int SendMsgToMainProc(int cmd, String value) { |
| | | if (!mIsServiceDestroyed.get()){ |
| | | onMessageArrived(cmd, value); |
| | | return onMessageArrived(cmd, value); |
| | | } |
| | | return -2; |
| | | } |
| | | |
| | | public String javaDESEncrypt(String plaintext, String key) { |
| | |
| | | System.loadLibrary("native-lib"); |
| | | } |
| | | |
| | | public native void startNative(); |
| | | public native void startNative(boolean ayDevice); |
| | | public native void MainProcMsgEntry(int cmd, String value); |
| | | public native void MainProcBinMsgEntry(int cmd, byte []data, int length); |
| | | public native void UpgradeMcu(String vercode, byte []rom); |
| | |
| | | synchronized (Upgrade.class) { |
| | | if (instance == null) { |
| | | instance = new Upgrade(context); |
| | | instance.context = context; |
| | | } |
| | | } |
| | | } |
| | |
| | | handlerCheckNewVersion.postDelayed(runnableCheckNewVersion, 100); |
| | | } |
| | | |
| | | public void ManualUpgrade(String path) { |
| | | installUtil.InstallAppNormal(context, path); |
| | | } |
| | | |
| | | class DMCB implements DownloadManagerCallback { |
| | | @Override |
| | | public void DownloadComplete(String title, String path) { |
| | |
| | | Signature[] sig2 = installUtil.getSignature(path); |
| | | |
| | | if (sig != null && sig2 != null && installUtil.getFingerprint(sig[0], "SHA-1").equals(installUtil.getFingerprint(sig2[0], "SHA-1"))) { |
| | | if (RemoteService.mAyDevice) { |
| | | installUtil.InstallApp(path); |
| | | } else { |
| | | installUtil.InstallAppNormal(context, path); |
| | | } |
| | | } |
| | | } |
| | | } |