//
|
// Created by YY on 2019/12/27.
|
//
|
|
#include <cstdint>
|
#include <cstdlib>
|
#include <cstring>
|
#include <pthread.h>
|
#include <semaphore.h>
|
#include <cmath>
|
#include "platform.h"
|
#include "../jni_log.h"
|
#include "../common/net.h"
|
#include "../native-lib.h"
|
#include "../common/apptimer.h"
|
#include "parse_net.h"
|
#include "../defs.h"
|
#include "../rtk_module/rtk.h"
|
#include "../mcu/mcu_if.h"
|
#include "../master/comm_if.h"
|
#include "../utils/xconvert.h"
|
#include "../utils/num.h"
|
#include "../driver_test.h"
|
#include "../test_common/car_sensor.h"
|
#include "../test_items2/stop_car.h"
|
#include "../test_items2/operate_gear.h"
|
#include "../test_items2/drive_straight.h"
|
#include "../rtk_module/virtual_rtk.h"
|
|
#define PARSE_BUFF_SIZE 4096
|
|
#define DEBUG(fmt, args...) LOGD("<platform> <%s>: " fmt, __func__, ##args)
|
|
using namespace std;
|
|
struct platformSocket {
|
char domain_name[32];
|
int port;
|
};
|
|
static struct deviceInfo_ {
|
uint16_t province;
|
uint16_t city;
|
uint8_t device_model[21];
|
uint8_t device_sn[17];
|
char imei[17];
|
}deviceInfo;
|
|
struct platformSocketInfo {
|
char domain_name[32];
|
int port;
|
};
|
|
static struct platformStatus_ {
|
uint8_t platformKey[64];
|
int platformKeyLength;
|
uint32_t connected : 1;
|
uint32_t registed : 1;
|
uint32_t login : 1;
|
uint32_t downloadRtk : 1;
|
} platformStatus;
|
|
struct event_t {
|
uint32_t id;
|
int length;
|
void *data;
|
};
|
|
struct default_mcu_rom_t {
|
int more;
|
char verCode[70];
|
uint8_t *rom;
|
int length;
|
} defaultMcuRom;
|
|
static struct event_queue_t {
|
struct event_t event;
|
struct event_queue_t *next;
|
} *eventQueue;
|
|
static bool mAyDevice = false;
|
|
struct platformSocket exceptSocket;
|
static sem_t sem_status_changed;
|
|
static bool requestPlatformSendRtk = false;
|
static CTcpPort *ctp = NULL;
|
|
static pthread_mutex_t events_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static struct gpsBrief gbf;
|
static struct rtkBrief rbf;
|
|
static bool btEnable = false, btConnected = false;
|
static char btAddr[64] = {0};
|
static char *btPin = NULL;
|
|
static void AddEvnet(uint32_t event, const uint8_t *data, int length);
|
static struct event_t * FetchEvent(void);
|
static void RemoveEvent(void);
|
|
static void ReqRtkPlatformConfigTimeout(union sigval sig);
|
|
static void TcpEventCallback(int stat, void *p, void *context);
|
static void TcpDataCallback(void *buffer, int length, void *p, void *context);
|
|
static void ConnectPlatform(const char *domain_name, int port);
|
static void ConnectPlatformLater(union sigval sig);
|
|
static void *StatusListenThread(void *p);
|
static void PlatformChangeEntry(uint32_t events, const uint8_t *data, int length);
|
|
static void RegisterPlatform(void);
|
static void RegisterPlatformTimeout(union sigval sig);
|
|
static void LoginPlatform(void);
|
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)
|
{
|
// DEBUG("AddEvnet 0x%04X length %d", event, length);
|
|
struct event_queue_t *nw = (struct event_queue_t *)malloc(sizeof(struct event_queue_t));
|
nw->next = NULL;
|
|
nw->event.id = event;
|
nw->event.data = NULL;
|
nw->event.length = 0;
|
|
if (data != NULL && length > 0) {
|
nw->event.data = malloc(length);
|
nw->event.length = length;
|
memcpy(nw->event.data, data, length);
|
}
|
|
pthread_mutex_lock(&events_mutex);
|
|
struct event_queue_t *p = eventQueue;
|
|
while (p != NULL && p->next != NULL) p = p->next;
|
|
if (eventQueue == NULL)
|
eventQueue = nw;
|
else
|
p->next = nw;
|
|
pthread_mutex_unlock(&events_mutex);
|
}
|
|
static struct event_t * FetchEvent(void)
|
{
|
struct event_t *evp = NULL;
|
|
pthread_mutex_lock(&events_mutex);
|
struct event_queue_t *p = eventQueue;
|
|
if (p != NULL) {
|
evp = &p->event;
|
}
|
|
pthread_mutex_unlock(&events_mutex);
|
|
return evp;
|
}
|
|
static void RemoveEvent(void)
|
{
|
void *p1 = NULL, *p2 = NULL;
|
|
pthread_mutex_lock(&events_mutex);
|
struct event_queue_t *p = eventQueue;
|
|
if (p != NULL) {
|
eventQueue = p->next;
|
p1 = p;
|
p2 = p->event.data;
|
}
|
pthread_mutex_unlock(&events_mutex);
|
|
if (p2 != NULL)
|
free(p2);
|
if (p1 != NULL)
|
free(p1);
|
}
|
|
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));
|
memset(&defaultMcuRom, 0, sizeof(defaultMcuRom));
|
|
pthread_mutex_init(&events_mutex, NULL);
|
|
eventQueue = NULL;
|
|
memset(&platformStatus, 0, sizeof(platformStatus));
|
|
sem_init(&sem_status_changed, 0, 0);
|
|
PlatformTxInit();
|
|
pthread_t pid;
|
pthread_attr_t attr;
|
pthread_attr_init(&attr);
|
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//detached
|
pthread_create(&pid, &attr, StatusListenThread, NULL);
|
}
|
|
static void ReqRtkPlatformConfigTimeout(union sigval sig)
|
{
|
AppTimer_delete(ReqRtkPlatformConfigTimeout);
|
|
AppTimer_add(ReqRtkPlatformConfigTimeout, D_SEC(2));
|
MA_ReqRtkPlatformConfig();
|
}
|
|
void ConfigPlatform(const rtk_platform_cfg_t *p)
|
{
|
DEBUG("配置RTK平台资讯");
|
|
AppTimer_delete(ReqRtkPlatformConfigTimeout);
|
|
strcpy(exceptSocket.domain_name, p->domain_name);
|
exceptSocket.port = p->port;
|
deviceInfo.province = p->province;
|
deviceInfo.city = p->city;
|
strcpy((char *)deviceInfo.device_model, p->device_model);
|
strcpy((char *)deviceInfo.device_sn, p->device_sn);
|
strcpy(deviceInfo.imei, p->imei);
|
SetPlatformTxPhoneNum(p->phone);
|
|
platformStatus.registed = 0;//p->registered;
|
platformStatus.platformKeyLength = strlen(p->password) / 2;
|
|
if (platformStatus.platformKeyLength > 0) {
|
ConvertString2Hex(platformStatus.platformKey, sizeof(platformStatus.platformKey), p->password);
|
} else {
|
platformStatus.registed = 0;
|
}
|
|
ConnectPlatform(exceptSocket.domain_name, exceptSocket.port);
|
|
// pthread_mutex_lock(&platform_tx_mutex);
|
// if (platform_tcp_fd > 0 && (exceptSocket.port != currSocket.port || strcmp(currSocket.domain_name, exceptSocket.domain_name))) {
|
// DisconnectTCP(platform_tcp_fd);
|
// platform_tcp_fd = -1;
|
// } else if (platform_tcp_fd <= 0) {
|
// ConnectPlatform(exceptSocket.domain_name, exceptSocket.port);
|
// }
|
// pthread_mutex_unlock(&platform_tx_mutex);
|
}
|
|
void PlatformStatusChanged(uint32_t event, const uint8_t *data, int length)
|
{
|
AddEvnet(event, data, length);
|
|
sem_post(&sem_status_changed);
|
}
|
|
static void ConnectPlatform(const char *domain_name, int port)
|
{
|
if (domain_name == NULL || strlen(domain_name) == 0 || port == 0)
|
return;
|
|
DEBUG("连接RTK平台 %s: %d", domain_name, port);
|
|
if (ctp == NULL) {
|
ctp = new CTcpPort();
|
|
ctp->set_event_callback(TcpEventCallback, NULL);
|
ctp->set_data_callback(TcpDataCallback, NULL);
|
}
|
|
if (!ctp->IsOpen()) {
|
ctp->OpenTcpPort(domain_name, port);
|
} else if ((ctp->m_nPort != port || strcmp(ctp->m_sIp.c_str(), domain_name))) {
|
ctp->CloseTcpPort();
|
}
|
}
|
|
static void TcpEventCallback(int stat, void *p, void *context)
|
{
|
CTcpPort *pTcpPort = (CTcpPort *)p;
|
uint8_t buffer[256];
|
|
strcpy((char *)buffer, pTcpPort->m_sIp.c_str());
|
|
buffer[pTcpPort->m_sIp.length() + 1] = HI_UINT16(pTcpPort->m_nPort);
|
buffer[pTcpPort->m_sIp.length() + 2] = LO_UINT16(pTcpPort->m_nPort);
|
|
if (stat == 0) {
|
PlatformStatusChanged(PLATFORM_CONNECT_EVT, buffer, pTcpPort->m_sIp.length() + 3);
|
} else {
|
PlatformStatusChanged(PLATFORM_DISCONNECT_EVT, buffer, pTcpPort->m_sIp.length() + 3);
|
}
|
}
|
|
static void TcpDataCallback(void *buffer, int length, void *p, void *context)
|
{
|
if (length > 0) {
|
Parse(DATA_ACCESS_PLATFORM, (uint8_t *)buffer, length);
|
}
|
}
|
|
static void ConnectPlatformLater(union sigval sig) {
|
AppTimer_delete(ConnectPlatformLater);
|
ConnectPlatform(exceptSocket.domain_name, exceptSocket.port);
|
}
|
|
static void *StatusListenThread(void *p) {
|
while (true) {
|
sem_wait(&sem_status_changed);
|
|
struct event_t *evp = FetchEvent();
|
|
if (evp != NULL) {
|
PlatformChangeEntry(evp->id, (uint8_t *)evp->data, evp->length);
|
}
|
|
RemoveEvent();
|
}
|
}
|
|
static void PlatformChangeEntry(uint32_t events, const uint8_t *data, int length)
|
{
|
switch (events) {
|
case PLATFORM_CONNECT_EVT: {
|
DEBUG("平台连接成功 %s:%d", data, BUILD_UINT16(data[strlen((char *)data) + 2], data[strlen((char *)data) + 1]));
|
MA_RtkPlatformConnect(1, (char *)data, BUILD_UINT16(data[strlen((char *)data) + 2], data[strlen((char *)data) + 1]));
|
|
platformStatus.connected = 1;
|
if (!platformStatus.registed || platformStatus.platformKeyLength == 0) {
|
RegisterPlatform();
|
} else if (!platformStatus.login) {
|
LoginPlatform();
|
}
|
|
MA_SendBlueStatus("name", "00:1B:35:16:20:4A", 3);
|
break;
|
}
|
|
case PLATFORM_DISCONNECT_EVT: {
|
DEBUG("平台断开 %s:%d", data, BUILD_UINT16(data[strlen((char *)data) + 2], data[strlen((char *)data) + 1]));
|
MA_RtkPlatformConnect(0, (char *)data, BUILD_UINT16(data[strlen((char *)data) + 2], data[strlen((char *)data) + 1]));
|
|
AppTimer_delete(ConnectPlatformLater);
|
AppTimer_add(ConnectPlatformLater, D_SEC(2));
|
|
platformStatus.login = 0;
|
platformStatus.connected = 0;
|
|
AppTimer_delete(TriggerHeartbeat);
|
AppTimer_delete(RegisterPlatformTimeout);
|
AppTimer_delete(LoginPlatformTimeout);
|
|
// PlayTTS("基准源断开", NULL);
|
break;
|
}
|
case PLATFORM_REGISTER_EVT: {
|
DEBUG("平台注册结果：%d", data[0]);
|
|
platformStatus.login = 0;
|
if (data[0] == 0) {
|
platformStatus.registed = 1;
|
platformStatus.platformKeyLength = length - 1;
|
memcpy(platformStatus.platformKey, data + 1, length - 1);
|
LoginPlatform();
|
} else {
|
platformStatus.registed = 0;
|
}
|
MA_RtkPlatformRegister(data[0], data + 1, length - 1);
|
break;
|
}
|
case PLATFORM_LOGIN_EVT: {
|
DEBUG("平台登录结果：%d", data[0]);
|
|
if (data[0] == 0) {
|
platformStatus.login = 1;
|
requestPlatformSendRtk = true;
|
AppTimer_delete(TriggerHeartbeat);
|
AppTimer_add(TriggerHeartbeat, D_SEC(30));
|
|
// PlayTTS("基准源建立", NULL);
|
} else {
|
platformStatus.login = 0;
|
}
|
MA_RtkPlatformLogin(data[0]);
|
break;
|
}
|
case GPS_UPDATE_EVT: {
|
const gpsStatus_t *gps = (gpsStatus_t *) data;
|
|
gbf.qf = gps->gps_status;
|
gbf.latitude = gps->latitude;
|
gbf.longitude = gps->longitude;
|
gbf.altitude = gps->altitude;
|
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);
|
if (!strcmp(rbf.utc, gbf.utc)) {
|
rbf.sat_num = gbf.sat_num;
|
rbf.latitude = gbf.latitude;
|
rbf.longitude = gbf.longitude;
|
rbf.altitude = gbf.altitude;
|
rbf.speed = gbf.speed;
|
rbf.trackTure = gbf.trackTure;
|
MA_SendRtkBrief(&rbf);
|
}
|
// MA_SendGpsBrief(&brief);
|
RequestRtkDownload(gps, 1);
|
break;
|
}
|
case RTK_UPDATE_EVT: {
|
uint32_t ost = AppTimer_GetTickCount();
|
uint32_t ost1 = ost;
|
|
const rtk_info *rtk = (rtk_info *) data;
|
|
rbf.qf = rtk->qf;
|
rbf.coord_x = rtk->y;
|
rbf.coord_y = rtk->x;
|
rbf.heading = rtk->heading;
|
rbf.pitch = rtk->pitch;
|
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);
|
if (!strcmp(rbf.utc, gbf.utc)) {
|
rbf.sat_num = gbf.sat_num;
|
rbf.latitude = gbf.latitude;
|
rbf.longitude = gbf.longitude;
|
rbf.altitude = gbf.altitude;
|
rbf.speed = gbf.speed;
|
rbf.trackTure = gbf.trackTure;
|
MA_SendRtkBrief(&rbf);
|
}
|
|
ost1 = AppTimer_GetTickCount() - ost1;
|
|
UpdateRTKInfo(rtk);
|
|
ost = AppTimer_GetTickCount() - ost;
|
|
if (ost > 100)
|
DEBUG("driver_test 评判耗时 %ld %ld", ost1, ost);
|
break;
|
}
|
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
|
// 36-37 speed
|
// 38-39 engine
|
// 40-55 sn
|
struct mcuBrief brief;
|
|
memset(&brief, 0, sizeof(brief));
|
|
int x = 0;
|
while (data[x] != 0 && x < 32) x++;
|
|
ConvertHex2String(brief.version, data, x);
|
brief.selftest = BUILD_UINT16(data[33], data[32]);
|
// brief.gpio = BUILD_UINT16(data[35], data[34]);
|
// brief.speed = BUILD_UINT16(data[37], data[36]);
|
// brief.engine = BUILD_UINT16(data[39], data[38]);
|
// memcpy(brief.sn, data+40, 16);
|
memcpy(brief.sn, data + 34, 16);
|
|
MA_SendMcuBrief(&brief);
|
|
if (defaultMcuRom.more > 0) {
|
char str[64] = {0};
|
|
memcpy(str, data, 32);
|
|
vector<string> ver = split(str, "_");
|
|
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;
|
}
|
case CAN_UPDATE_EVT: {
|
struct canBrief brief;
|
|
brief.gpio = BUILD_UINT16(data[1], data[0]);
|
brief.rpm = BUILD_UINT16(data[3], data[2]);
|
brief.speed = (double) BUILD_UINT16(data[5], data[4]) / 10.0;
|
brief.voltage = (double) BUILD_UINT16(data[7], data[6]) / 10.0;
|
|
MA_SendCanStatus(&brief);
|
break;
|
}
|
case CAR_SENSOR_UPDATE_EVT: {
|
struct carSensorBrief brief;
|
int x = 20;
|
|
brief.odo = BUILD_UINT32(data[3], data[2], data[1], data[0]);
|
brief.trip = BUILD_UINT32(data[7], data[6], data[5], data[4]);
|
brief.tripTime = BUILD_UINT32(data[11], data[10], data[9], data[8]);
|
brief.cellVolt = ((double) BUILD_UINT16(data[13], data[12])) / 10.0;
|
brief.speed = ((double) BUILD_UINT16(data[15], data[14])) / 10.0;
|
brief.engine = BUILD_UINT16(data[17], data[16]);
|
brief.sas = (short) BUILD_UINT16(data[19], data[18]);
|
brief.key = data[x++];
|
brief.gear = data[x++];
|
brief.aps = data[x++];
|
brief.door = data[x++];
|
brief.seatBelt = data[x++];
|
brief.clutch = data[x++];
|
brief.horn = data[x++];
|
brief.wiper = data[x++];
|
brief.handBreak = data[x++];
|
brief.mainBreak = data[x++];
|
brief.leftTurnLamp = data[x++];
|
brief.rightTurnLamp = data[x++];
|
brief.clearanceLamp = data[x++];
|
brief.dippedBeamLamp = data[x++];
|
brief.mainBeamLamp = data[x++];
|
brief.fogLamp = data[x++];
|
brief.assBreak = data[x++];
|
brief.surround1 = data[x++];
|
brief.surround2 = data[x++];
|
brief.surround3 = data[x++];
|
brief.surround4 = data[x++];
|
|
MA_SendCarSensorBrief(&brief);
|
|
car_sensor_t sensor;
|
x = 20;
|
|
sensor.odo = BUILD_UINT32(data[3], data[2], data[1], data[0]);
|
sensor.trip = BUILD_UINT32(data[7], data[6], data[5], data[4]);
|
sensor.tripTime = BUILD_UINT32(data[11], data[10], data[9], data[8]);
|
sensor.cellVolt = (double) (BUILD_UINT16(data[13], data[12])) / 10.0;
|
sensor.speed = BUILD_UINT16(data[15], data[14]);
|
sensor.engine = BUILD_UINT16(data[17], data[16]);
|
sensor.sas = (short) BUILD_UINT16(data[19], data[18]);
|
sensor.key = data[x++];
|
sensor.gear = data[x++];
|
sensor.aps = data[x++];
|
sensor.door = data[x++];
|
sensor.seatBelt = data[x++];
|
sensor.clutch = data[x++];
|
sensor.horn = data[x++];
|
sensor.wiper = data[x++];
|
sensor.handBreak = data[x++];
|
sensor.mainBreak = data[x++];
|
sensor.leftTurnLamp = data[x++];
|
sensor.rightTurnLamp = data[x++];
|
sensor.clearanceLamp = data[x++];
|
sensor.dippedBeamLamp = data[x++];
|
sensor.mainBeamLamp = data[x++];
|
sensor.fogLamp = data[x++];
|
sensor.assBreak = data[x++];
|
sensor.surround1 = data[x++];
|
sensor.surround2 = data[x++];
|
sensor.surround3 = data[x++];
|
sensor.surround4 = data[x++];
|
|
if (sensor.clutch == 1)
|
sensor.gear = 0;
|
|
UpdateSensor(&sensor);
|
break;
|
}
|
case CARD_UPDATE_EVT: {
|
DEBUG("CARD_UPDATE_EVT length %d", length);
|
|
int ret = -1;
|
|
for (int i = 0; i < length; ++i) {
|
if (data[i] != 0) {
|
ret = 0;
|
break;
|
}
|
}
|
|
struct cardBrief brief;
|
|
brief.result = ret;
|
|
ConvertHex2String(brief.card, data, length);
|
|
MA_SendCardBrief(&brief);
|
break;
|
}
|
case PLAY_TTS_DONE_EVT: {
|
tts_back_t *cb = (tts_back_t *) data;
|
if (cb->callback != NULL) {
|
cb->callback(cb->seq);
|
}
|
break;
|
}
|
case MASTER_COMM_EVT: {
|
union {
|
int a;
|
uint8_t b[sizeof(int)];
|
} c;
|
|
c.b[0] = data[0];
|
c.b[1] = data[1];
|
c.b[2] = data[2];
|
c.b[3] = data[3];
|
|
if (length == 4)
|
MA_MainProcMsgEntry(c.a, NULL);
|
else {
|
MA_MainProcMsgEntry(c.a, (char *) data + 4);
|
}
|
break;
|
}
|
case BLUETOOTH_STATUS_EVT: {
|
DEBUG("BLUETOOTH_STATUS_EVT");
|
|
if (!mAyDevice) {
|
uint8_t sta;
|
|
if (length == 128) {
|
MA_SendBlueStatus((char *) data, (char *) data + 64, 3);
|
sta = 3;
|
} else if (length == 64) {
|
MA_SendBlueStatus(NULL, (char *) data, 3);
|
sta = 3;
|
} else {
|
MA_SendBlueStatus(NULL, NULL, data[0]);
|
sta = data[0];
|
}
|
|
if (sta == 3) {
|
// Connected
|
btConnected = true;
|
ParseMcuInit();
|
ConfigRTKModuleLater();
|
|
PlayTTS("蓝牙连接", NULL);
|
} else if (sta == 2) {
|
// Disconnect
|
if (btConnected) {
|
btConnected = false;
|
PlayTTS("蓝牙断开", NULL);
|
}
|
} else if (sta == 1) {
|
// Open
|
btEnable = true;
|
|
if (strlen(btAddr) > 0) {
|
ConnectToBluetooth(btAddr, NULL);
|
}
|
// ConnectToBluetooth("00:1B:35:16:20:4A", NULL);
|
// ConnectToBluetooth("00:1B:35:16:20:4A", "3800");``
|
// ConnectToBluetooth("00:1D:43:9A:E0:79", "1900");
|
// ConnectToBluetooth("DESKTOP-IE9V7U8", "0000");
|
PlayTTS("蓝牙启动", NULL);
|
} else {
|
// Close
|
btEnable = false;
|
btConnected = false;
|
PlayTTS("蓝牙关闭", NULL);
|
}
|
}
|
break;
|
}
|
case BLUETOOTH_DATA_EVT: {
|
if (Virtual2IsConnected()) {
|
|
} else {
|
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;
|
}
|
}
|
|
int WritePlatform(const uint8_t * buf, uint32_t len)
|
{
|
int ret = -1;
|
|
if (ctp != NULL && ctp->IsOpen()) {
|
ret = ctp->WriteTCP(buf, len);
|
}
|
|
return ret;
|
}
|
|
static void RegisterPlatformTimeout(union sigval sig)
|
{
|
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,
|
strlen((char *)deviceInfo.device_model), deviceInfo.device_sn, deviceInfo.imei);
|
}
|
|
static void TriggerHeartbeat(union sigval sig) {
|
AppTimer_delete(TriggerHeartbeat);
|
|
if (platformStatus.login && platformStatus.connected) {
|
SendHeartBeat(DATA_ACCESS_PLATFORM);
|
AppTimer_add(TriggerHeartbeat, D_SEC(30));
|
}
|
}
|
|
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;
|
|
data[0] = BREAK_UINT32(tim, 3);
|
data[1] = BREAK_UINT32(tim, 2);
|
data[2] = BREAK_UINT32(tim, 1);
|
data[3] = BREAK_UINT32(tim, 0);
|
|
AppTimer_delete(LoginPlatformTimeout);
|
AppTimer_add(LoginPlatformTimeout, D_SEC(15));
|
|
|
DESEncrypt(platformStatus.platformKey, platformStatus.platformKeyLength, data, 4, &ciphertext);
|
|
if (ciphertext != NULL) {
|
memcpy(data + 4, ciphertext, 8);
|
SendDeviceLogin(data, sizeof(data));
|
}
|
}
|
|
void DeviceRegisterCallback(uint8_t res, const uint8_t *data, int length)
|
{
|
uint8_t az[16];
|
AppTimer_delete(RegisterPlatformTimeout);
|
|
az[0] = res;
|
if (res == 0) {
|
memcpy(az+1, data, length);
|
PlatformStatusChanged(PLATFORM_REGISTER_EVT, az, length + 1);
|
} else {
|
PlatformStatusChanged(PLATFORM_REGISTER_EVT, az, 1);
|
}
|
}
|
|
void DeviceLoginCallback(uint8_t res)
|
{
|
uint8_t az;
|
AppTimer_delete(LoginPlatformTimeout);
|
|
az = res;
|
|
PlatformStatusChanged(PLATFORM_LOGIN_EVT, &az, 1);
|
}
|
|
void ReceivedRtk(const uint8_t *data, int length)
|
{
|
DEBUG("ReceivedRtk length %d", length);
|
|
AppTimer_delete(RequestRtkNoResp);
|
// 汇报给单片机
|
if (length > 0) {
|
SendRtkToMcu(data, length);
|
}
|
}
|
|
static void RequestRtkNoResp(union sigval sig)
|
{
|
AppTimer_delete(RequestRtkNoResp);
|
requestPlatformSendRtk = true;
|
}
|
|
void RequestRtkDownload(const gpsStatus_t *gps, uint16_t rtk_pkt_interval)
|
{
|
if (requestPlatformSendRtk && gps->gps_status > 0) {
|
DEBUG("请求下载RTK数据");
|
requestPlatformSendRtk = false;
|
|
AppTimer_delete(RequestRtkNoResp);
|
AppTimer_add(RequestRtkNoResp, D_SEC(5));
|
|
uint32_t latitude = (uint32_t)(gps->latitude * 1000000);
|
uint32_t longitude = (uint32_t)(gps->longitude * 1000000);
|
int altitude = (int) fabs(gps->altitude);
|
|
uint8_t bcd_time[6];
|
|
bcd_time[0] = ((gps->YY/10)<<4) + (gps->YY%10);
|
bcd_time[1] = ((gps->MM/10)<<4) + (gps->MM%10);
|
bcd_time[2] = ((gps->DD/10)<<4) + (gps->DD%10);
|
bcd_time[3] = ((gps->hh/10)<<4) + (gps->hh%10);
|
bcd_time[4] = ((gps->mm/10)<<4) + (gps->mm%10);
|
bcd_time[5] = ((gps->ss/10)<<4) + (gps->ss%10);
|
|
SendRTKStart(latitude, longitude, altitude, bcd_time, rtk_pkt_interval);
|
}
|
}
|
|
void StopRtkDownload(void)
|
{
|
SendRTKStop();
|
}
|
|
void LoadDefaultMcuRom(const char *verCode, const uint8_t *rom, int length)
|
{
|
DEBUG("内置单片机rom %s len %ld", verCode, length);
|
strcpy(defaultMcuRom.verCode, verCode);
|
|
if (length > 0 && rom != NULL) {
|
defaultMcuRom.length = length;
|
if (defaultMcuRom.rom != NULL)
|
delete []defaultMcuRom.rom;
|
|
defaultMcuRom.more = 1;
|
defaultMcuRom.rom = new uint8_t[length];
|
memcpy(defaultMcuRom.rom, rom, length);
|
}
|
}
|
|
void SetRemoteBluetooth(const char *name, const char *addr)
|
{
|
strcpy(btAddr, addr);
|
|
if (btConnected) {
|
DisconnectBluetooth();
|
}
|
|
/*string csname = name;
|
if (csname != NULL) {
|
if (csname.find("AKS3A_TEST") != string::npos) {
|
btPin = "1111";
|
} else if (csname.find("AKS3A_") != string::npos && csname.size() >= 8) {
|
int a = stoi(csname.substr(csname.size()-8, 4));
|
int b = stoi(csname.substr(csname.size()-4, 4));
|
}
|
}*/
|
|
if (btEnable) {
|
ConnectToBluetooth(addr, NULL);
|
}
|
}
|
