PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix all board compile for v3.0

Browse Source 
fix all board compile for v3.0
This commit is contained in:
supowang
2021-08-11 16:30:15 +08:00
parent 1f694e2156
commit 8253a953bd
615 changed files with 96466 additions and 80894 deletions
Download Patch File Download Diff File Expand all files Collapse all files

594
devices/rhf76_lora/RHF76.c Normal file
View File

@@ -0,0 +1,594 @@
#include "RHF76.h"
#include "tos_hal.h"
static const char RHF76_LOWPOWER_SET[] = {
0xFF,0xFF,0xFF,0xFF,'A','T','+','L','O','W','P','O','W','E','R','=','a','u','t','o','o','f','f','\r','\n'
};
static int rhf76_exit_low_power(void)
{
int try = 0;
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, "+LOWPOWER: AUTOOFF");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, RHF76_LOWPOWER_SET);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_reset(void)
{
int try = 0;
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, "+RESET: OK");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, RHF76_ATCMD_RESET);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_id(lora_id_type_t id_type, char *id)
{
char cmd[64] = {0};
int try = 0;
at_echo_t echo;
switch(id_type) {
case LORA_ID_TYPE_DEVADDR:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_ID_DEVADDR, id);
break;
case LORA_ID_TYPE_DEVEUI:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_ID_DEVEUI, id);
break;
case LORA_ID_TYPE_APPEUI:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_ID_DEVAPPEUI, id);
break;
default:
return -1;
}
tos_at_echo_create(&echo, NULL, 0, "+ID: ");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 1000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_key(lora_key_type_t key_type, char *key)
{
char cmd[64] = {0};
int try = 0;
at_echo_t echo;
switch (key_type) {
case LORA_KEY_TYPE_APPKEY:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_KEY_TYPE_APPKEY, key);
break;
case LORA_KEY_TYPE_APPSKEY:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_KEY_TYPE_APPSKEY, key);
break;
case LORA_KEY_TYPE_NWKSKEY:
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SET_KEY_TYPE_NWKSKEY, key);
break;
default:
return -1;
}
tos_at_echo_create(&echo, NULL, 0, "+KEY:");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 1000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_class(lora_class_t lora_class)
{
char *cmd = NULL, *reply = NULL;
int try = 0;
at_echo_t echo;
switch (lora_class) {
case LORA_CLASS_A:
cmd = RHF76_ATCMD_SET_CLASS_A;
reply = RHF76_ATCMD_REPLY_CLASS_A;
break;
case LORA_CLASS_B:
cmd = RHF76_ATCMD_SET_CLASS_B;
reply = RHF76_ATCMD_REPLY_CLASS_B;
break;
case LORA_CLASS_C:
cmd = RHF76_ATCMD_SET_CLASS_C;
reply = RHF76_ATCMD_REPLY_CLASS_C;
break;
default:
return -1;
}
tos_at_echo_create(&echo, NULL, 0, reply);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 1000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_band(void)
{
int try = 0;
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, RHF76_ATCMD_REPLY_BAND_CN470);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, RHF76_ATCMD_SET_BAND_CN470);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_chanel(void)
{
int try = 0;
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, "+CH: NUM");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, RHF76_ATCMD_SET_CHANNEL);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_set_repeat(uint8_t num)
{
int try = 0;
at_echo_t echo;
char cmd[14] = {0};
char expect[10] = {'\0'};
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_SET_REPT, num);
snprintf(expect, sizeof(expect), "+REPT: %d", num);
tos_at_echo_create(&echo, NULL, 0, expect);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_set_data_rate(uint8_t num)
{
if(num>15) return -1; // num should between [0, 15]
int try = 0;
at_echo_t echo;
char cmd[14] = {0};
char expect[10] = {'\0'};
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_SET_DATA_RATE, num);
snprintf(expect, sizeof(expect), " DR%d", num);
tos_at_echo_fuzzy_matching_create(&echo, NULL, 0, expect);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_set_delay(char *param)
{
int try = 0;
at_echo_t echo;
char cmd[20] = {0};
char expect[20] = {'\0'};
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_SET_DELAY, param);
snprintf(expect, sizeof(expect), "+DELAY %s", param);
tos_at_echo_create(&echo, NULL, 0, expect);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, cmd);
if(strstr(param,"?")!=NULL) return 0;
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_at_cmd_exe(char *cmd)
{
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, NULL);
tos_at_cmd_exec(&echo, 8000, cmd);
return 0;
}
static int rhf76_set_adr_off(void)
{
int try = 0;
at_echo_t echo;
tos_at_echo_create(&echo, NULL, 0, "+ADR: OFF");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 3000, RHF76_ATCMD_SET_ADR_OFF);
if (echo.status == AT_ECHO_STATUS_OK|| echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_set_mode(lora_mode_t mode)
{
char *cmd = NULL, *reply = NULL;
int try = 0;
at_echo_t echo;
switch (mode) {
case LORA_MODE_LWOTAA:
cmd = RHF76_ATCMD_SET_MODE_LWOTAA;
reply = RHF76_ATCMD_REPLY_MODE_LWOTAA;
break;
case LORA_MODE_LWABP:
cmd = RHF76_ATCMD_SET_MODE_LWABP;
reply = RHF76_ATCMD_REPLY_MODE_LWABP;
break;
default:
return -1;
}
tos_at_echo_create(&echo, NULL, 0, reply);
while (try++ < 10) {
tos_at_cmd_exec(&echo, 2500, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_join_otaa(const char *deveui, const char *appkey)
{
int try = 0;
at_echo_t echo;
if (rhf76_set_mode(LORA_MODE_LWOTAA) != 0) {
printf("rhf76 set mode FAILED\n");
return -1;
}
if (rhf76_set_id(LORA_ID_TYPE_DEVEUI, (char *)deveui) != 0) {
printf("rhf76 set deveui FAILED\n");
return -1;
}
if (rhf76_set_key(LORA_KEY_TYPE_APPKEY, (char *)appkey) != 0) {
printf("rhf76 set appkey FAILED\n");
return -1;
}
tos_stopwatch_delay_ms(2000);
tos_at_echo_create(&echo, NULL, 0, "+JOIN: Network joined");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 14000, RHF76_ATCMD_JOIN);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
int rhf76_join_abp(const char *deveui, const char *devaddr, const char *nwkskey, const char *appskey)
{
int try = 0;
at_echo_t echo;
if (rhf76_set_mode(LORA_MODE_LWABP) != 0) {
printf("rhf76 set mode FAILED\n");
return -1;
}
if (rhf76_set_id(LORA_ID_TYPE_DEVEUI, (char *)deveui) != 0) {
printf("rhf76 set deveui FAILED\n");
return -1;
}
if (rhf76_set_id(LORA_ID_TYPE_DEVADDR, (char *)devaddr) != 0) {
printf("rhf76 set devaddr FAILED\n");
return -1;
}
if (rhf76_set_key(LORA_KEY_TYPE_NWKSKEY, (char *)nwkskey) != 0) {
printf("rhf76 set nwkskey FAILED\n");
return -1;
}
if (rhf76_set_key(LORA_KEY_TYPE_APPSKEY, (char *)appskey) != 0) {
printf("rhf76 set appskey FAILED\n");
return -1;
}
tos_stopwatch_delay_ms(2000);
tos_at_echo_create(&echo, NULL, 0, "+JOIN: Network joined");
while (try++ < 10) {
tos_at_cmd_exec(&echo, 14000, RHF76_ATCMD_JOIN);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return 0;
}
}
return -1;
}
static int rhf76_init(void)
{
printf("Init RHF76 LoRa ...\n" );
tos_stopwatch_delay_ms(1000);
if (rhf76_exit_low_power() != 0) {
printf("rhf76 reset FAILED\n");
return -1;
}
if (rhf76_reset() != 0) {
printf("rhf76 reset FAILED\n");
return -1;
}
if (rhf76_set_class(LORA_CLASS_A) != 0) {
printf("rhf76 set class FAILED\n");
return -1;
}
if (rhf76_set_band() != 0) {
printf("rhf76 set band FAILED\n");
return -1;
}
if (rhf76_set_chanel() != 0) {
printf("rhf76 set chanel FAILED\n");
return -1;
}
if (rhf76_set_adr_off() != 0) {
printf("rhf76 set adr FAILED\n");
return -1;
}
if(rhf76_set_repeat(1)!=0){
printf("rhf76 set repeat times for unconfirmed message FAILED\n");
return -1;
}
tos_stopwatch_delay_ms(2000);
printf("Init RHF76 LoRa done\n");
/*----------------------------------------------------*/
/*--- the following code is only used for debuging ---*/
/*----------------------------------------------------*/
/*<-- query/set UART Timeout (~TX timeout) -->*/
// rhf76_at_cmd_exe("AT+UART=TIMEOUT, 300\r\n");
// rhf76_at_cmd_exe("AT+UART=TIMEOUT\r\n");
/*<-- query current band config -->*/
// rhf76_at_cmd_exe("AT+DR=SCHEME\r\n");
// rhf76_at_cmd_exe("AT+LW=CDR\r\n");
/*<-- query current data rate and the corresponding max payload size -->*/
rhf76_set_data_rate(0);
// rhf76_at_cmd_exe("at+dr=0\r\n");
// rhf76_at_cmd_exe("AT+DR\r\n");
// rhf76_at_cmd_exe("AT+LW=LEN\r\n");
/*<-- query RX1\RX2\JRX1\JRX2 delay config -->*/
// rhf76_set_delay("?");
/*<-- query RF config -->*/
// rhf76_at_cmd_exe("AT+MODE=TEST\r\n");
// rhf76_at_cmd_exe("AT+TEST=?\r\n");
return 0;
}
__STATIC__ uint8_t __ascii2hex(char in) {
if (('0' <= in) && (in <= '9')) {
return in - '0';
}
if (('A' <= in) && (in <= 'F')) {
return in - 'A' + 10;
}
if (('a' <= in) && (in <= 'f')) {
return in - 'a' + 10;
}
return (uint8_t)-1;
}
__STATIC__ void __asciistr2hex(char *in, uint8_t *out, int len) {
int i = 0;
for (i = 0; i < len; i += 2) {
out[i / 2] = (__ascii2hex(in[i]) << 4) + __ascii2hex(in[i + 1]);
}
}
__STATIC__ char incoming_data_buffer[128];
__STATIC__ uint8_t hex_stream[128];
__STATIC__ void rhf76_incoming_data_process(void)
{
int ret;
uint8_t data;
/*
+CMSG: PORT: 8; RX: "12345678"
RX: prefix
"12345678": data content
*/
while (1) {
ret = tos_at_uart_read(&data, 1);
if (data == '"') {
break;
}
}
ret = 0;
memset(incoming_data_buffer, 0x00, sizeof(incoming_data_buffer));
while (1) {
tos_at_uart_read(&data, 1);
if (data == '"') {
break;
}
if(ret<128)
{
incoming_data_buffer[ret++] = data;
}
else
{
printf(" ERR:incomming data is big ,please give more space for incoming_data_buffer\n");
}
}
printf("rhf76_incoming_data_process %d: %s\n", ret, incoming_data_buffer);
__asciistr2hex(incoming_data_buffer, hex_stream, strlen(incoming_data_buffer));
extern lora_module_t lora_module_rhf76;
if (lora_module_rhf76.recv_callback) {
lora_module_rhf76.recv_callback(hex_stream, strlen(incoming_data_buffer) / 2);
}
}
at_event_t rhf76_at_event[] = {
{ "+CMSGHEX: PORT:", rhf76_incoming_data_process },
{ "+MSGHEX: PORT:", rhf76_incoming_data_process }
};
static char __num2hex(uint8_t num)
{
if (num <= 0x9) {
return num + '0';
}
if ((0xA <= num) && (num <= 0xF)) {
return num - 0xA + 'A';
}
return (char)-1;
}
static void __hex2str(uint8_t *in, char *out, int len)
{
int i = 0;
for (i = 0; i < len; ++i) {
out[i * 2] = __num2hex(in[i] >> 4);
out[i * 2 + 1] = __num2hex(in[i] & 0x0F);
}
out[2 * len] = '\0';
}
static int rhf76_send(const void *buf, size_t len)
{
char *str_buf = NULL;
str_buf = tos_mmheap_calloc(2 * len + 1, sizeof(char));
if (!str_buf) {
return -1;
}
__hex2str((uint8_t *)buf, str_buf, len);
char cmd[100] = {0};
at_echo_t echo;
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SEND_CMSGHEX, str_buf);
cmd[sizeof(cmd) - 1] = '\0';
tos_mmheap_free(str_buf);
tos_at_echo_create(&echo, NULL, 0, "+CMSGHEX: ACK Received");
tos_at_cmd_exec(&echo, 6000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return len;
}
return -1;
}
static int rhf76_send_unconfirmed(const void *buf, size_t len)
{
char *str_buf = NULL;
at_echo_t echo;
str_buf = tos_mmheap_calloc(2 * len + 1, sizeof(char));
if (!str_buf) {
return -1;
}
__hex2str((uint8_t *)buf, str_buf, len);
char cmd[100] = {0};
snprintf(cmd, sizeof(cmd), RHF76_ATCMD_FMT_SEND_MSGHEX, str_buf);
cmd[sizeof(cmd) - 1] = '\0';
tos_mmheap_free(str_buf);
tos_at_echo_create(&echo, NULL, 0, "+MSGHEX: Done");
tos_at_cmd_exec(&echo, 6000, cmd);
if (echo.status == AT_ECHO_STATUS_OK || echo.status == AT_ECHO_STATUS_EXPECT) {
return len;
}
return -1;
}
static int rhf76_close(void)
{
return 0;
}
lora_module_t lora_module_rhf76 = {
.init = rhf76_init,
.join_otaa = rhf76_join_otaa,
.join_abp = rhf76_join_abp,
.send = rhf76_send,
.send_unconfirmed = rhf76_send_unconfirmed,
.close = rhf76_close,
.recv_callback = K_NULL,
};
int rhf76_lora_init(hal_uart_port_t uart_port)
{
if (tos_at_init(uart_port, rhf76_at_event,
sizeof(rhf76_at_event) / sizeof(rhf76_at_event[0])) != 0) {
return -1;
}
tos_stopwatch_delay_ms(1000);
if (tos_lora_module_register(&lora_module_rhf76) != 0) {
return -1;
}
if (tos_lora_module_init() != 0) {
return -1;
}
return 0;
}

151
devices/rhf76_lora/RHF76.h Normal file
View File

@@ -0,0 +1,151 @@
/*----------------------------------------------------------------------------
* Tencent is pleased to support the open source community by making TencentOS
* available.
*
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
* If you have downloaded a copy of the TencentOS binary from Tencent, please
* note that the TencentOS binary is licensed under the BSD 3-Clause License.
*
* If you have downloaded a copy of the TencentOS source code from Tencent,
* please note that TencentOS source code is licensed under the BSD 3-Clause
* License, except for the third-party components listed below which are
* subject to different license terms. Your integration of TencentOS into your
* own projects may require compliance with the BSD 3-Clause License, as well
* as the other licenses applicable to the third-party components included
* within TencentOS.
*---------------------------------------------------------------------------*/
#ifndef __RHF76_H__
#define __RHF76_H__
#include <stdio.h>
#include <string.h>
#include "usart.h"
#include "tos_at.h"
#include "lora_module_wrapper.h"
#define UART_RXBUF_MAXSIZE 256
typedef enum lora_class {
LORA_CLASS_A,
LORA_CLASS_B,
LORA_CLASS_C,
} lora_class_t;
typedef enum lora_mode {
LORA_MODE_LWOTAA,
LORA_MODE_LWABP,
} lora_mode_t;
typedef enum lora_id_type {
LORA_ID_TYPE_DEVADDR,
LORA_ID_TYPE_DEVEUI,
LORA_ID_TYPE_APPEUI,
} lora_id_type_t;
typedef enum lora_key_type {
LORA_KEY_TYPE_APPKEY,
LORA_KEY_TYPE_APPSKEY,
LORA_KEY_TYPE_NWKSKEY,
} lora_key_type_t;
#define RHF76_ATCMD_SET_CLASS_A "AT+CLASS=A\r\n"
#define RHF76_ATCMD_SET_CLASS_B "AT+CLASS=B\r\n"
#define RHF76_ATCMD_SET_CLASS_C "AT+CLASS=C\r\n"
#define RHF76_ATCMD_REPLY_CLASS_A "+CLASS: A"
#define RHF76_ATCMD_REPLY_CLASS_B "+CLASS: B"
#define RHF76_ATCMD_REPLY_CLASS_C "+CLASS: C"
#define RHF76_ATCMD_RESET "AT+RESET\r\n"
#define RHF76_ATCMD_FMT_SET_ID_DEVADDR "AT+ID=\"devaddr\",\"%s\"\r\n"
#define RHF76_ATCMD_FMT_SET_ID_DEVEUI "AT+ID=\"deveui\",\"%s\"\r\n"
#define RHF76_ATCMD_FMT_SET_ID_DEVAPPEUI "AT+ID=\"appeui\",\"%s\"\r\n"
#define RHF76_ATCMD_FMT_SET_KEY_TYPE_APPKEY "AT+KEY=\"appkey\",%s\r\n"
#define RHF76_ATCMD_FMT_SET_KEY_TYPE_APPSKEY "AT+KEY=\"appskey\",%s\r\n"
#define RHF76_ATCMD_FMT_SET_KEY_TYPE_NWKSKEY "AT+KEY=\"nwkskey\",%s\r\n"
#define RHF76_ATCMD_FMT_SEND_CMSGHEX "AT+CMSGHEX=\"%s\"\r\n"
#define RHF76_ATCMD_FMT_SEND_MSGHEX "AT+MSGHEX=\"%s\"\r\n"
#define RHF76_ATCMD_SET_REPT "AT+REPT=%d\r\n"
#define RHF76_ATCMD_SET_DELAY "AT+DELAY=%s\r\n"
#define RHF76_ATCMD_SET_BAND_CN470 "AT+DR=CN470\r\n"
#define RHF76_ATCMD_REPLY_BAND_CN470 "+DR: CN470"
#define RHF76_ATCMD_SET_DATA_RATE "AT+DR=%d\r\n"
#define RHF76_ATCMD_SET_CHANNEL "at+ch=num,80-87\r\n"
#define RHF76_ATCMD_SET_ADR_OFF "at+adr=off\r\n"
#define RHF76_ATCMD_JOIN "AT+join\r\n"
#define RHF76_ATCMD_SET_MODE_LWOTAA "AT+MODE=LWOTAA\r\n"
#define RHF76_ATCMD_SET_MODE_LWABP "AT+MODE=LWABP\r\n"
#define RHF76_ATCMD_REPLY_MODE_LWOTAA "+MODE: LWOTAA"
#define RHF76_ATCMD_REPLY_MODE_LWABP "+MODE: LWABP"
int rhf76_lora_init(hal_uart_port_t uart_port);
/**
* @brief set the delay for RX1,RX2,JRX1,JRX2 OR query current delay config
* @note Examples:
* to set the delay(ms):
* rhf76_set_delay("RX1,2000");
*
* to query current delay config:
* rhf76_set_delay("?");
*
* @param params operation string
*
* @retval int Status
*/
int rhf76_set_delay(char *param);
/**
* @brief set repeat times when sending unconfirmed message
* @note it is equal to sending
* AT+REPT=2
* +REPT: 2
*
* @param num repeat times
*
* @retval int Status
*/
int rhf76_set_repeat(uint8_t num);
/**
* @brief set date rate, which would affect the maximum payload size
* @note this function is for DEBUG purpose only, it allows user to execute
* AT+ commands by passing the AT+ command to the function as an arg-
* ument.
* For example,users can query the RF configuration by following code:
*
* rhf76_at_cmd_exe("AT+MODE=TEST\r\n");
* rhf76_at_cmd_exe("AT+TEST=?\r\n");
*
* @param num data rate
*
* @retval int Status
*/
int rhf76_set_data_rate(uint8_t num);
/**
* @brief execute AT+ commands
* @note this function is for DEBUG purpose only, it allows user to execute
* AT+ commands by passing the AT+ command to the function as an arg-
* ument.
* For example,users can query the RF configuration by following code:
*
* rhf76_at_cmd_exe("AT+MODE=TEST\r\n");
* rhf76_at_cmd_exe("AT+TEST=?\r\n");
*
* @param cmd AT+ commands
*
* @retval int Status
*/
int rhf76_at_cmd_exe(char *cmd);
#endif /* __RHF76_H__ */