xuyanghang
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
xiuos/APP_Framework/Applications/main.c

741 lines
25 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2020 AIIT XUOS Lab
* XiUOS is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <stdio.h>
#include <string.h>
#include <user_api.h>
#include <transform.h>
#define SERVER_ADDRESS "47.110.234.29"
#define SERVER_PORT "1883"
#define CLIENT_ID "91330109021"
#define USERNAME "aiit_sysoul"
#define PASSWORD "PoYpY1qg4N1DiW0n7cquC0FGsHZZMD"
#define PUB_TOPIC "/gateway/acrm/91330109021"
#define SALEID "91330109MAC0ALH17X"
#define GATEID "91330109021"
#define TYPE "report"
#define SEQUENCE "502"
#define SOURCE "SUES"
#define AMMETER_NUM 2
#define TRY_TIMES 10
#define READ_TIMEOUT 2000
#define DELAY_TIME 30000
#ifdef ADD_XIZI_FEATURES
extern int FrameworkInit();
extern void ApplicationOtaTaskInit(void);
#ifdef OTA_BY_PLATFORM
extern int OtaTask(void);
#endif
#ifdef APPLICATION_WEBSERVER
extern int webserver(void);
#endif
static void Ec200aPowerSet(void)
{
int pin_fd;
pin_fd = PrivOpen("/dev/pin_dev", O_RDWR);
if (pin_fd < 0) {
printf("open 4G pin error\n");
return;
}
struct PinParam pin_param;
pin_param.cmd = GPIO_CONFIG_MODE;
pin_param.mode = GPIO_CFG_OUTPUT;
pin_param.pin = 144;
struct PrivIoctlCfg ioctl_cfg;
ioctl_cfg.ioctl_driver_type = PIN_TYPE;
ioctl_cfg.args = &pin_param;
PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg);
struct PinStat pin_stat;
pin_stat.pin = 144;
pin_stat.val = GPIO_LOW; //put power key at low-level state
PrivWrite(pin_fd, &pin_stat, 1);
PrivTaskDelay(2500); //wait at least 2s
pin_stat.val = GPIO_HIGH; //put power key at high-level state
PrivWrite(pin_fd, &pin_stat, 1);
PrivClose(pin_fd);
PrivTaskDelay(10000);
}
void calc_complement_value(const char* recv_buff, const int start_pos, float* result) {
// 获取高位和低位的数值
uint8_t high_byte = recv_buff[start_pos];
uint8_t low_byte = recv_buff[start_pos + 1];
// 判断符号位，如果最高位为1，则为负数
if (high_byte & 0x80) {
// 补码表示的负数，先取反再加1
*result = -((unsigned short)(~((high_byte << 8) | low_byte)) + 1);
} else {
// 补码表示的正数
*result = (high_byte << 8) | low_byte;
}
}
int get_current_time(char *recv_buff, char* current_time) {
int year, month, day, hour, minute, second;
int matches = 0;
// 在字符串中查找日期和时间部分，并提取年月日、时分秒
char *time_line = strstr(recv_buff, "+QLTS:");
matches = sscanf(time_line, "+QLTS: \"%d/%d/%d,%d:%d:%d", &year, &month, &day, &hour, &minute, &second);
if (matches != 6) {
return 0;
}
// 将提取的年月日、时分秒组成所需格式的字符串
char formatted_time[20];
snprintf(formatted_time, sizeof(formatted_time), "%04d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second);
strcpy(current_time, formatted_time);
return 1;
}
void* sample_and_send(void* param) {
int uart_fd = PrivOpen("/dev/usart4_dev4", O_RDWR);
if (uart_fd < 0) {
printf("open uart fd error:%d\n", uart_fd);
return NULL;
}
printf("uart and pin fopen success\n");
struct SerialDataCfg uart_cfg;
memset(&uart_cfg, 0, sizeof(struct SerialDataCfg));
uart_cfg.serial_baud_rate = BAUD_RATE_9600;
uart_cfg.serial_data_bits = DATA_BITS_8;
uart_cfg.serial_stop_bits = STOP_BITS_1;
uart_cfg.serial_parity_mode = PARITY_NONE;
uart_cfg.serial_bit_order = BIT_ORDER_LSB;
uart_cfg.serial_invert_mode = NRZ_NORMAL;
uart_cfg.serial_buffer_size = SERIAL_RB_BUFSZ;
// uart_cfg.serial_buffer_size = 1024;
uart_cfg.serial_timeout = 1000;
uart_cfg.is_ext_uart = 0;
struct PrivIoctlCfg ioctl_cfg;
ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
ioctl_cfg.args = (void *)&uart_cfg;
if (0 != PrivIoctl(uart_fd, OPE_INT, &ioctl_cfg)) {
printf("ioctl fd error %d\n", uart_fd);
PrivClose(uart_fd);
return NULL;
}
int quectel_fd = PrivOpen("/dev/usart6_dev6", O_RDWR);
if (quectel_fd < 0) {
printf("open quectel fd error:%d\n", quectel_fd);
return NULL;
}
printf("quectel fopen success\n");
struct SerialDataCfg quectel_cfg;
memset(&quectel_cfg, 0, sizeof(struct SerialDataCfg));
quectel_cfg.serial_baud_rate = BAUD_RATE_115200;
quectel_cfg.serial_data_bits = DATA_BITS_8;
quectel_cfg.serial_stop_bits = STOP_BITS_1;
quectel_cfg.serial_parity_mode = PARITY_NONE;
quectel_cfg.serial_bit_order = BIT_ORDER_LSB;
quectel_cfg.serial_invert_mode = NRZ_NORMAL;
quectel_cfg.serial_buffer_size = SERIAL_RB_BUFSZ;
// quectel_cfg.serial_buffer_size = 2048;
quectel_cfg.serial_timeout = 10000;
quectel_cfg.is_ext_uart = 0;
// quectel_cfg.ext_uart_no = ADAPTER_QUECTEL_DRIVER_EXT_PORT;
// quectel_cfg.port_configure = PORT_CFG_INIT;
struct PrivIoctlCfg quectel_ioctl_cfg;
quectel_ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
quectel_ioctl_cfg.args = &quectel_cfg;
if (0 != PrivIoctl(quectel_fd, OPE_INT, &quectel_ioctl_cfg)) {
printf("ioctl quectel fd error %d\n", quectel_fd);
PrivClose(quectel_fd);
return NULL;
}
/*4G MQTT*/
const char set_mode[] = "AT+QMTCFG=\"recv/mode\",0,0,1\r\n";
const char set_keepalive[] = "AT+QMTCFG=\"keepalive\",0,600\r\n";
const char set_server[] = "AT+QMTOPEN=0,\"" SERVER_ADDRESS "\"," SERVER_PORT "\r\n";
const char set_conn[] = "AT+QMTCONN=0,\"" CLIENT_ID "\",\"" USERNAME "\",\"" PASSWORD "\"\r\n";
const char get_time[] = "AT+QLTS=2\r\n";
char *result = NULL;
char recv_buff[1024] = {0};
int buf_len = 0;
int retry_times = 0;
/*ADL400 ammeter RS485 Instruction*/
uint8_t Instruction1[AMMETER_NUM][8] = {
{0x01, 0x03, 0x00, 0x0A, 0x00, 0x02, 0xE4, 0x09},
{0x02, 0x03, 0x00, 0x0A, 0x00, 0x02, 0xE4, 0x3A},
// {0x03, 0x03, 0x00, 0x0A, 0x00, 0x02, 0xE5, 0xEB},
// {0x04, 0x03, 0x00, 0x0A, 0x00, 0x02, 0xE4, 0x5C},
// {0x05, 0x03, 0x00, 0x0A, 0x00, 0x02, 0xE5, 0x8D}
}; //EPI
uint8_t Instruction2[AMMETER_NUM][8] = {
{0x01, 0x03, 0x00, 0x32, 0x00, 0x02, 0x65, 0xC4},
{0x02, 0x03, 0x00, 0x32, 0x00, 0x02, 0x65, 0xF7},
// {0x03, 0x03, 0x00, 0x32, 0x00, 0x02, 0x64, 0x26},
// {0x04, 0x03, 0x00, 0x32, 0x00, 0x02, 0x65, 0x91},
// {0x05, 0x03, 0x00, 0x32, 0x00, 0x02, 0x64, 0x40}
}; //EQC
uint8_t Instruction3[AMMETER_NUM][8] = {
{0x01, 0x03, 0x00, 0x61, 0x00, 0x1A, 0x95, 0xDF},
{0x02, 0x03, 0x00, 0x61, 0x00, 0x1A, 0x95, 0xEC},
// {0x03, 0x03, 0x00, 0x61, 0x00, 0x1A, 0x94, 0x3D},
// {0x04, 0x03, 0x00, 0x61, 0x00, 0x1A, 0x95, 0x8A},
// {0x05, 0x03, 0x00, 0x61, 0x00, 0x1A, 0x94, 0x5B},
}; //others
int data_size = 0;
int data_recv_size = 0;
int data_len = 0;
int ammeter_order = 0;
uint32_t tick_beg = 0;
uint32_t tick_end = 0;
int read_flag = 1;
/*json format value*/
char send_data[1024] = {0};
char current_time[20] = "unknowed time";
const char saleid[] = SALEID;
const char gateid[] = GATEID;
const char type[] = TYPE;
const char sequence[] = SEQUENCE;
const char source[] = SOURCE;
char id[AMMETER_NUM][8] = {
{"T100101"},
{"T100102"},
// {"T100103"},
// {"T100104"},
// {"T100105"},
};
char status[AMMETER_NUM][2] = {
{"1"},
{"1"},
// {"1"},
// {"1"},
// {"1"},
};
char name[AMMETER_NUM][8] = {
{"T100101"},
{"T100102"},
// {"T100103"},
// {"T100104"},
// {"T100105"},
};
char data_len_str[8] = {0};
resetpower:
Ec200aPowerSet();
retry_times = 0;
resetmode:
printf("set mode\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, set_mode, strlen(set_mode));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[set mode] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, "OK");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("set mode error! offline! reset all!\n");
retry_times = 0;
goto resetpower;
}
retry_times++;
printf("set mode error!\n");
PrivTaskDelay(1000);
goto resetmode;
}
PrivTaskDelay(500);
retry_times = 0;
resetkeepalive:
printf("set keepalive\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, set_keepalive, strlen(set_keepalive));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[set keepalive] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, "OK");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("set keepalive error! offline! reset all!\n");
retry_times = 0;
goto resetpower;
}
retry_times++;
printf("set keepalive error!\n");
PrivTaskDelay(1000);
goto resetkeepalive;
}
PrivTaskDelay(500);
retry_times = 0;
resetserver:
printf("set server\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, set_server, strlen(set_server));
PrivTaskDelay(10000);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[set server] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, "OK");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("set server error! offline! reset all!\n");
retry_times = 0;
goto resetpower;
}
retry_times++;
printf("set server error!\n");
PrivTaskDelay(1000);
goto resetserver;
}
PrivTaskDelay(500);
retry_times = 0;
reconn:
printf("set conn\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, set_conn, strlen(set_conn));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[set conn] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, "OK");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("set conn error! offline! reset all!\n");
retry_times = 0;
goto resetpower;
}
retry_times++;
printf("set conn error!\n");
PrivTaskDelay(1000);
goto reconn;
}
PrivTaskDelay(500);
while (1) {
printf("===========================enter cycle===========================\n");
printf("get EPI\n");
float EPI = 0;
char EPI_str[10] = {0};
data_size = 0;
data_recv_size = 0;
data_len = 9; //EPI
PrivWrite(uart_fd, Instruction1[ammeter_order], sizeof(Instruction1[ammeter_order]));
PrivTaskDelay(20);
memset(recv_buff, 0, sizeof(recv_buff));
tick_beg = PrivGetTickTime();
tick_end = tick_beg;
read_flag = 1;
while (data_size < data_len) {
tick_end = PrivGetTickTime();
if (tick_end - tick_beg >= READ_TIMEOUT) {
read_flag = 0;
break;
}
data_recv_size = PrivRead(uart_fd, recv_buff + data_size, data_len - data_size);
data_size += data_recv_size;
}
if (read_flag == 0) {
continue;
}
for (int i = 0; i < data_len; i++) {
printf("%02X ", recv_buff[i]);
}
printf("\n");
EPI = ((recv_buff[3] << 24) + (recv_buff[4] << 16) + (recv_buff[5] << 8) + recv_buff[6]) * 0.01;
snprintf(EPI_str, sizeof(EPI_str), "%.2f", EPI);
PrivTaskDelay(1000);
printf("get EQC\n");
float EQC = 0;
char EQC_str[10] = {0};
data_size = 0;
data_recv_size = 0;
data_len = 9; //EQC
PrivWrite(uart_fd, Instruction2[ammeter_order], sizeof(Instruction2[ammeter_order]));
PrivTaskDelay(20);
memset(recv_buff, 0, sizeof(recv_buff));
tick_beg = PrivGetTickTime();
tick_end = tick_beg;
read_flag = 1;
while (data_size < data_len) {
tick_end = PrivGetTickTime();
if (tick_end - tick_beg >= READ_TIMEOUT) {
read_flag = 0;
break;
}
data_recv_size = PrivRead(uart_fd, recv_buff + data_size, data_len - data_size);
data_size += data_recv_size;
}
if (read_flag == 0) {
continue;
}
for (int i = 0; i < data_len; i++) {
printf("%02X ", recv_buff[i]);
}
printf("\n");
EQC = ((recv_buff[3] << 24) + (recv_buff[4] << 16) + (recv_buff[5] << 8) + recv_buff[6]) * 0.01;
snprintf(EQC_str, sizeof(EQC_str), "%.2f", EQC);
PrivTaskDelay(1000);
printf("get others\n");
data_size = 0;
data_recv_size = 0;
data_len = 57; //others
PrivWrite(uart_fd, Instruction3[ammeter_order], sizeof(Instruction3[ammeter_order]));
PrivTaskDelay(20);
memset(recv_buff, 0, sizeof(recv_buff));
tick_beg = PrivGetTickTime();
tick_end = tick_beg;
read_flag = 1;
while (data_size < data_len) {
tick_end = PrivGetTickTime();
if (tick_end - tick_beg >= READ_TIMEOUT) {
read_flag = 0;
break;
}
data_recv_size = PrivRead(uart_fd, recv_buff + data_size, data_len - data_size);
data_size += data_recv_size;
}
if (read_flag == 0) {
continue;
}
for (int i = 0; i < data_len; i++) {
printf("%02X ", recv_buff[i]);
}
printf("\n");
/*define data*/
float Ua = 0, Ub = 0, Uc = 0;
float Ia = 0, Ib = 0, Ic = 0;
float Pa = 0, Pb = 0, Pc = 0, P = 0;
float Qa = 0, Qb = 0, Qc = 0, Q = 0;
float Sa = 0, Sb = 0, Sc = 0, S = 0;
float Pfa = 0, Pfb = 0, Pfc = 0, Pf = 0;
float Fr = 0;
float Uab = 0, Ubc = 0, Uca = 0;
char Ua_str[10] = {0}, Ub_str[10] = {0}, Uc_str[10] = {0};
char Ia_str[10] = {0}, Ib_str[10] = {0}, Ic_str[10] = {0};
char Pa_str[10] = {0}, Pb_str[10] = {0}, Pc_str[10], P_str[10] = {0};
char Qa_str[10] = {0}, Qb_str[10] = {0}, Qc_str[10] = {0}, Q_str[10] = {0};
char Sa_str[10] = {0}, Sb_str[10] = {0}, Sc_str[10] = {0}, S_str[10] = {0};
char Pfa_str[10] = {0}, Pfb_str[10] = {0}, Pfc_str[10] = {0}, Pf_str[10] = {0};
char Fr_str[10] = {0};
char Uab_str[10] = {0}, Ubc_str[10] = {0}, Uca_str[10] = {0};
printf("calc number\n");
Ua = ((recv_buff[3] << 8) + recv_buff[4]) * 0.1;
Ub = ((recv_buff[5] << 8) + recv_buff[6]) * 0.1;
Uc = ((recv_buff[7] << 8) + recv_buff[8]) * 0.1;
Ia = ((recv_buff[9] << 8) + recv_buff[10]) * 0.01;
Ib = ((recv_buff[11] << 8) + recv_buff[12]) * 0.01;
Ic = ((recv_buff[13] << 8) + recv_buff[14]) * 0.01;
calc_complement_value(recv_buff, 15, &Pa);
Pa *= 0.001;
calc_complement_value(recv_buff, 17, &Pb);
Pb *= 0.001;
calc_complement_value(recv_buff, 19, &Pc);
Pc *= 0.001;
calc_complement_value(recv_buff, 21, &P);
P *= 0.001;
calc_complement_value(recv_buff, 23, &Qa);
Qa *= 0.001;
calc_complement_value(recv_buff, 25, &Qb);
Qb *= 0.001;
calc_complement_value(recv_buff, 27, &Qc);
Qc *= 0.001;
calc_complement_value(recv_buff, 29, &Q);
Q *= 0.001;
calc_complement_value(recv_buff, 31, &Sa);
Sa *= 0.001;
calc_complement_value(recv_buff, 33, &Sb);
Sb *= 0.001;
calc_complement_value(recv_buff, 35, &Sc);
Sc *= 0.001;
calc_complement_value(recv_buff, 37, &S);
S *= 0.001;
calc_complement_value(recv_buff, 39, &Pfa);
Pfa *= 0.001;
calc_complement_value(recv_buff, 41, &Pfb);
Pfb *= 0.001;
calc_complement_value(recv_buff, 43, &Pfc);
Pfc *= 0.001;
calc_complement_value(recv_buff, 45, &Pf);
Pf *= 0.001;
Fr = ((recv_buff[47] << 8) | recv_buff[48]) * 0.01;
calc_complement_value(recv_buff, 49, &Uab);
Uab *= 0.1;
calc_complement_value(recv_buff, 51, &Ubc);
Ubc *= 0.1;
calc_complement_value(recv_buff, 53, &Uca);
Uca *= 0.1;
printf("number trans to string\n");
snprintf(Ua_str, sizeof(Ua_str), "%.1f", Ua);
snprintf(Ub_str, sizeof(Ub_str), "%.1f", Ub);
snprintf(Uc_str, sizeof(Uc_str), "%.1f", Uc);
snprintf(Ia_str, sizeof(Ia_str), "%.2f", Ia);
snprintf(Ib_str, sizeof(Ib_str), "%.2f", Ib);
snprintf(Ic_str, sizeof(Ic_str), "%.2f", Ic);
snprintf(Pa_str, sizeof(Pa_str), "%.3f", Pa);
snprintf(Pb_str, sizeof(Pb_str), "%.3f", Pb);
snprintf(Pc_str, sizeof(Pc_str), "%.3f", Pc);
snprintf(P_str, sizeof(P_str), "%.3f", P);
snprintf(Qa_str, sizeof(Qa_str), "%.3f", Qa);
snprintf(Qb_str, sizeof(Qb_str), "%.3f", Qb);
snprintf(Qc_str, sizeof(Qc_str), "%.3f", Qc);
snprintf(Q_str, sizeof(Q_str), "%.3f", Q);
snprintf(Sa_str, sizeof(Sa_str), "%.3f", Sa);
snprintf(Sb_str, sizeof(Sb_str), "%.3f", Sb);
snprintf(Sc_str, sizeof(Sc_str), "%.3f", Sc);
snprintf(S_str, sizeof(S_str), "%.3f", S);
snprintf(Pfa_str, sizeof(Pfa_str), "%.3f", Pfa);
snprintf(Pfb_str, sizeof(Pfb_str), "%.3f", Pfb);
snprintf(Pfc_str, sizeof(Pfc_str), "%.3f", Pfc);
snprintf(Pf_str, sizeof(Pf_str), "%.3f", Pf);
snprintf(Fr_str, sizeof(Fr_str), "%.2f", Fr);
snprintf(Uab_str, sizeof(Uab_str), "%.1f", Uab);
snprintf(Ubc_str, sizeof(Ubc_str), "%.1f", Ubc);
snprintf(Uca_str, sizeof(Uca_str), "%.1f", Uca);
retry_times = 0;
regettime:
printf("get time\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, get_time, strlen(get_time));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[get time] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, "OK");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("get time error! offline! reset all!\n");
retry_times = 0;
goto resetpower;
}
retry_times++;
printf("get time error!\n");
PrivTaskDelay(1000);
goto regettime;
}
PrivTaskDelay(500);
int time_flag = get_current_time(recv_buff, current_time);
if (time_flag == 0) {
printf("time format error, reget time!\n");
goto regettime;
}
printf("current_time: %s\n", current_time);
printf("combine strs\n");
memset(send_data, 0, sizeof(send_data));
strcat(send_data, "{\"saleid\":\"");
strcat(send_data, saleid);
strcat(send_data, "\",\"gateid\":\"");
strcat(send_data, gateid);
strcat(send_data, "\",\"type\":\"");
strcat(send_data, type);
strcat(send_data, "\",\"time\":\"");
strcat(send_data, current_time);
strcat(send_data, "\",\"sequence\":\"");
strcat(send_data, sequence);
strcat(send_data, "\",\"source\":\"");
strcat(send_data, source);
strcat(send_data, "\",\"meter\":[");
/*data value*/
strcat(send_data, "{\"id\":\"");
strcat(send_data, id[ammeter_order]);
strcat(send_data, "\",\"status\":\"");
strcat(send_data, status[ammeter_order]);
strcat(send_data, "\",\"name\":\"");
strcat(send_data, name[ammeter_order]);
strcat(send_data, "\",\"values\":{");
strcat(send_data, "\"EPI\":");
strcat(send_data, EPI_str);
strcat(send_data, ",\"EQC\":");
strcat(send_data, EQC_str);
strcat(send_data, ",\"Ua\":");
strcat(send_data, Ua_str);
strcat(send_data, ",\"Ub\":");
strcat(send_data, Ub_str);
strcat(send_data, ",\"Uc\":");
strcat(send_data, Uc_str);
strcat(send_data, ",\"Ia\":");
strcat(send_data, Ia_str);
strcat(send_data, ",\"Ib\":");
strcat(send_data, Ib_str);
strcat(send_data, ",\"Ic\":");
strcat(send_data, Ic_str);
strcat(send_data, ",\"Pa\":");
strcat(send_data, Pa_str);
strcat(send_data, ",\"Pb\":");
strcat(send_data, Pb_str);
strcat(send_data, ",\"Pc\":");
strcat(send_data, Pc_str);
strcat(send_data, ",\"P\":");
strcat(send_data, P_str);
strcat(send_data, ",\"Qa\":");
strcat(send_data, Qa_str);
strcat(send_data, ",\"Qb\":");
strcat(send_data, Qb_str);
strcat(send_data, ",\"Qc\":");
strcat(send_data, Qc_str);
strcat(send_data, ",\"Q\":");
strcat(send_data, Q_str);
strcat(send_data, ",\"Sa\":");
strcat(send_data, Sa_str);
strcat(send_data, ",\"Sb\":");
strcat(send_data, Sb_str);
strcat(send_data, ",\"Sc\":");
strcat(send_data, Sc_str);
strcat(send_data, ",\"S\":");
strcat(send_data, S_str);
strcat(send_data, ",\"Pfa\":");
strcat(send_data, Pfa_str);
strcat(send_data, ",\"Pfb\":");
strcat(send_data, Pfb_str);
strcat(send_data, ",\"Pfc\":");
strcat(send_data, Pfc_str);
strcat(send_data, ",\"Pf\":");
strcat(send_data, Pf_str);
strcat(send_data, ",\"Fr\":");
strcat(send_data, Fr_str);
strcat(send_data, ",\"Uab\":");
strcat(send_data, Uab_str);
strcat(send_data, ",\"Ubc\":");
strcat(send_data, Ubc_str);
strcat(send_data, ",\"Uca\":");
strcat(send_data, Uca_str);
strcat(send_data, "}}");
strcat(send_data, "]}");
/*publish topic*/
retry_times = 0;
char set_reply[64] = "AT+QMTPUBEX=0,0,0,0,\"" PUB_TOPIC "\",";
sprintf(data_len_str, "%d", strlen(send_data));
strcat(set_reply, data_len_str);
strcat(set_reply, "\r\n");
repubtopic:
printf("pub topic\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, set_reply, strlen(set_reply));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[pub topic] Info: Recv from uart: %s\n", recv_buff);
result = NULL;
result = strstr(recv_buff, ">");
if (NULL == result) {
if (retry_times > TRY_TIMES) {
printf("publish topic error! offline! reset all!\n");
goto resetpower;
}
retry_times++;
printf("publish topic error!\n");
PrivTaskDelay(1000);
goto repubtopic;
}
PrivTaskDelay(50);
printf("4G send\n");
memset(recv_buff, 0, sizeof(recv_buff));
PrivWrite(quectel_fd, send_data, strlen(send_data));
PrivTaskDelay(300);
buf_len = PrivRead(quectel_fd, recv_buff, sizeof(recv_buff));
printf("buf_len: %d\n", buf_len);
printf("[send data] Info: Recv from uart: %s\n", recv_buff);
printf("-------------------------end once send-------------------------\n");
ammeter_order = (ammeter_order + 1) % AMMETER_NUM;
PrivTaskDelay(DELAY_TIME / AMMETER_NUM);
}
PrivClose(uart_fd);
PrivClose(quectel_fd);
return NULL;
}
int task_manage(void) {
int ret = 0;
UtaskType test_task;
test_task.prio = 25;
test_task.stack_size = 10240;
test_task.func_entry = sample_and_send;
test_task.func_param = NULL;
strncpy(test_task.name, "test_task", sizeof(test_task.name));
int test_task_pid = UserTaskCreate(test_task);
if (test_task_pid < 0) {
printf("task create error\n");
return -1;
}
ret = UserTaskStartup(test_task_pid);
}
int main(void)
{
printf("\nHello, world!\n");
FrameworkInit();
task_manage();
#ifdef APPLICATION_OTA
ApplicationOtaTaskInit();
#endif
#ifdef OTA_BY_PLATFORM
OtaTask();
#endif
#ifdef APPLICATION_WEBSERVER
webserver();
#endif
return 0;
}
#endif
// int cppmain(void);
Reference in New Issue View Git Blame Copy Permalink