developer
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

support 4G adapter and ec200t device

This commit is contained in:
Liu_Weichao 2021-10-13 17:57:34 +08:00
parent 2aa5c0f0ba
commit ab578dfe0e
8 changed files with 218 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
APP_Framework/Framework/connection/4G/EC200T/Kconfig
View File

@ -17,7 +17,7 @@ if ADD_XIUOS_FETURES
config ADAPTER_EC200T_DRIVER
string "EC200T device uart driver path"
default "/dev/uart2_dev2"
default "/dev/usart2_dev2"
depends on !ADAPTER_EC200T_DRIVER_EXTUART
if ADAPTER_EC200T_DRIVER_EXTUART

183
APP_Framework/Framework/connection/4G/EC200T/ec200t.c
View File

@ -21,6 +21,21 @@
#include <adapter.h>
#include <at_agent.h>
#define EC200T_AT_MODE_CMD "+++"
#define EC200T_GET_CCID_CMD "AT+CCID\r\n"
#define EC200T_GET_CPIN_CMD "AT+CPIN?\r\n"
#define EC200T_GET_CREG_CMD "AT+CREG?\r\n"
#define EC200T_OPEN_SOCKET_CMD "AT+QIOPEN=1,%u"
#define EC200T_CLOSE_SOCKET_CMD "AT+QICLOSE=%u\r\n"
#define EC200T_ACTIVE_PDP_CMD "AT+QIACT=1\r\n"
#define EC200T_DEACTIVE_PDP_CMD "AT+QIDEACT=1\r\n"
#define EC200T_CFG_TCP_CMD "AT+QICSGP"
#define EC200T_OK_REPLY "OK"
#define EC200T_READY_REPLY "READY"
#define EC200T_CREG_REPLY ",1"
#define EC200T_CONNECT_REPLY "CONNECT"
static void Ec200tPowerSet(void)
{
int pin_fd;
@ -47,6 +62,8 @@ static void Ec200tPowerSet(void)
PrivWrite(pin_fd, &pin_stat, 1);
PrivClose(pin_fd);
PrivTaskDelay(10000);
}
static int Ec200tOpen(struct Adapter *adapter)
@ -70,32 +87,6 @@ static int Ec200tOpen(struct Adapter *adapter)
adapter->agent = at_agent;
}
/*step3: serial write "+++", quit transparent mode*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
/*step4: serial write "AT+CCID", get SIM ID*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+CCID\r\n");
PrivTaskDelay(2500);
/*step5: serial write "AT+CPIN?", check SIM status*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+CPIN?\r\n");
PrivTaskDelay(2500);
/*step6: serial write "AT+CREG?", check whether registered to GSM net*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+CREG?\r\n");
PrivTaskDelay(2500);
/*step7: serial write "AT+QICLOSE", close socket connect before open socket*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QICLOSE=0\r\n");
PrivTaskDelay(2500);
/*step8: serial write "AT+QIDEACT", close TCP net before open socket*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QIDEACT=1\r\n");
PrivTaskDelay(2500);
ADAPTER_DEBUG("Ec200t open done\n");
@ -105,31 +96,41 @@ static int Ec200tOpen(struct Adapter *adapter)
static int Ec200tClose(struct Adapter *adapter)
{
int ret = 0;
uint8_t ec200t_cmd[64];
if (!adapter->agent) {
printf("Ec200tClose AT agent NULL\n");
return -1;
}
AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
/*step1: serial write "+++", quit transparent mode*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
/*step2: serial write "AT+QICLOSE", close socket connect before open socket*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QICLOSE=0\r\n");
PrivTaskDelay(2500);
memset(ec200t_cmd, 0, sizeof(ec200t_cmd));
sprintf(ec200t_cmd, EC200T_CLOSE_SOCKET_CMD, adapter->socket.socket_id);
ret = AtCmdConfigAndCheck(adapter->agent, ec200t_cmd, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
/*step3: serial write "AT+QIDEACT", close TCP net before open socket*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QIDEACT=1\r\n");
PrivTaskDelay(2500);
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_DEACTIVE_PDP_CMD, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
out:
/*step4: close ec200t serial port*/
PrivClose(adapter->fd);
/*step5: power down ec200t*/
Ec200tPowerSet();
return 0;
return ret;
}
static int Ec200tIoctl(struct Adapter *adapter, int cmd, void *args)
@ -159,15 +160,41 @@ static int Ec200tIoctl(struct Adapter *adapter, int cmd, void *args)
ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
ioctl_cfg.args = &serial_cfg;
PrivIoctl(adapter->fd, OPE_INT, &ioctl_cfg);
Ec200tPowerSet();
return 0;
}
static int Ec200tConnect(struct Adapter *adapter, enum NetRoleType net_role, const char *ip, const char *port, enum IpType ip_type)
{
int ret = 0;
uint8_t ec200t_cmd[64];
/*step1: serial write "AT+QICSGP", connect to China Mobile using ipv4 or ipv6*/
AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
/*step1: serial write "+++", quit transparent mode*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
/*step2: serial write "AT+CCID", get SIM ID*/
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_GET_CCID_CMD, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
/*step3: serial write "AT+CPIN?", check SIM status*/
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_GET_CPIN_CMD, EC200T_READY_REPLY);
if (ret < 0) {
goto out;
}
/*step4: serial write "AT+CREG?", check whether registered to GSM net*/
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_GET_CREG_CMD, EC200T_CREG_REPLY);
if (ret < 0) {
goto out;
}
/*step5: serial write "AT+QICSGP", connect to China Mobile using ipv4 or ipv6*/
memset(ec200t_cmd, 0, sizeof(ec200t_cmd));
if (IPV4 == ip_type) {
@ -176,58 +203,105 @@ static int Ec200tConnect(struct Adapter *adapter, enum NetRoleType net_role, con
strcpy(ec200t_cmd, "AT+QICSGP=1,2,\"CMNET\",\"\",\"\",1\r\n");
}
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, ec200t_cmd);
ret = AtCmdConfigAndCheck(adapter->agent, ec200t_cmd, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
PrivTaskDelay(2500);
/*step2: serial write "AT+QIACT", open TCP net*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QIACT=1\r\n");
PrivTaskDelay(2500);
/*step3: serial write "AT+QIOPEN", connect socket using TCP*/
/*step6: serial write "AT+QICLOSE", close socket connect before open socket*/
memset(ec200t_cmd, 0, sizeof(ec200t_cmd));
strcpy(ec200t_cmd, "AT+QIOPEN=1,0,\"TCP\",\"");
sprintf(ec200t_cmd, EC200T_CLOSE_SOCKET_CMD, adapter->socket.socket_id);
ret = AtCmdConfigAndCheck(adapter->agent, ec200t_cmd, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
/*step7: serial write "AT+QIDEACT", close TCP net before open socket*/
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_DEACTIVE_PDP_CMD, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
/*step8: serial write "AT+QIACT", open TCP net*/
ret = AtCmdConfigAndCheck(adapter->agent, EC200T_ACTIVE_PDP_CMD, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
/*step9: serial write "AT+QIOPEN", connect socket using TCP*/
memset(ec200t_cmd, 0, sizeof(ec200t_cmd));
sprintf(ec200t_cmd, EC200T_OPEN_SOCKET_CMD, adapter->socket.socket_id);
strcat(ec200t_cmd, ",\"TCP\",\"");
strcat(ec200t_cmd, ip);
strcat(ec200t_cmd, "\",");
strcat(ec200t_cmd, port);
strcat(ec200t_cmd, ",0,2\r\n");
ADAPTER_DEBUG("Ec200t connect AT CMD :%s\n", ec200t_cmd);
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, ec200t_cmd);
AtSetReplyEndChar(adapter->agent, 0x43, 0x54);
ret = AtCmdConfigAndCheck(adapter->agent, ec200t_cmd, EC200T_CONNECT_REPLY);
if (ret < 0) {
goto out;
}
ADAPTER_DEBUG("Ec200t connect TCP done\n");
return 0;
out:
ADAPTER_DEBUG("Ec200t connect TCP failed. Power down\n");
Ec200tPowerSet();
return -1;
}
static int Ec200tSend(struct Adapter *adapter, const void *buf, size_t len)
{
PrivWrite(adapter->fd, buf, len);
x_err_t result = EOK;
if (adapter->agent) {
EntmSend(adapter->agent, (const char *)buf, len);
} else {
printf("Ec200tSend can not find agent\n");
}
return 0;
}
static int Ec200tRecv(struct Adapter *adapter, void *buf, size_t len)
{
PrivRead(adapter->fd, buf, len);
return 0;
if (adapter->agent) {
return EntmRecv(adapter->agent, (char *)buf, len, 40000);
} else {
printf("Ec200tRecv can not find agent\n");
}
return -1;
}
static int Ec200tDisconnect(struct Adapter *adapter)
{
int ret = 0;
uint8_t ec200t_cmd[64];
AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B);
/*step1: serial write "+++", quit transparent mode*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "+++");
/*step2: serial write "AT+QICLOSE", close socket connect before open socket*/
ATOrderSend(adapter->agent, REPLY_TIME_OUT, NULL, "AT+QICLOSE=0\r\n");
PrivTaskDelay(2500);
memset(ec200t_cmd, 0, sizeof(ec200t_cmd));
sprintf(ec200t_cmd, EC200T_CLOSE_SOCKET_CMD, adapter->socket.socket_id);
ret = AtCmdConfigAndCheck(adapter->agent, ec200t_cmd, EC200T_OK_REPLY);
if (ret < 0) {
goto out;
}
ADAPTER_DEBUG("Ec200t disconnect TCP done\n");
return 0;
out:
ADAPTER_DEBUG("Ec200t disconnect TCP failed. Power down\n");
Ec200tPowerSet();
return -1;
}
static const struct IpProtocolDone ec200t_done =
@ -261,10 +335,5 @@ AdapterProductInfoType Ec200tAttach(struct Adapter *adapter)
product_info->model_done = (void *)&ec200t_done;
Ec200tPowerSet();
return product_info;
}

12
APP_Framework/Framework/connection/4G/adapter_4G.c
View File

@ -95,16 +95,18 @@ int Adapter4GTest(void)
uint8 server_addr[64] = "115.238.53.61";
uint8 server_port[64] = "33333";
adapter->socket.socket_id = 0;
AdapterDeviceOpen(adapter);
AdapterDeviceControl(adapter, OPE_INT, &baud_rate);
AdapterDeviceConnect(adapter, CLIENT, server_addr, server_port, IPV4);
while (1) {
AdapterDeviceSend(adapter, send_msg, strlen(send_msg));
AdapterDeviceRecv(adapter, recv_msg, 128);
printf("4G recv msg %s\n", recv_msg);
}
// while (1) {
// AdapterDeviceSend(adapter, send_msg, strlen(send_msg));
// AdapterDeviceRecv(adapter, recv_msg, 128);
// printf("4G recv msg %s\n", recv_msg);
// }
#endif
return 0;

14
APP_Framework/Framework/connection/adapter.h
View File

@ -42,7 +42,7 @@ extern "C" {
#ifdef CONNECTION_FRAMEWORK_DEBUG
#define ADAPTER_DEBUG printf
#else
#define ADAPTER_DEBUF
#define ADAPTER_DEBUG
#endif
struct Adapter;
@ -52,8 +52,14 @@ typedef struct AdapterProductInfo *AdapterProductInfoType;
struct Socket
{
int id;
struct Adapter *adapter;
uint8_t type; ///< socket type:DGRAM->UDP,STREAM->TCP
uint8_t protocal; ///< udp or tcp
unsigned short listen_port; ///< 0-65535
uint8_t socket_id; ///< socket id
uint8_t recv_control; ///< receive control
uint8_t af_type; ///< IPv4 or IPv6
char *src_ip_addr; ///< source P address
char *dst_ip_addr; ///< destination IP address
};
enum AdapterType
@ -156,7 +162,7 @@ struct Adapter
struct AdapterProductInfo *info;
ATAgentType agent;
//struct Socket *socket;
struct Socket socket;
enum NetProtocolType net_protocol;
enum NetRoleType net_role;

62
APP_Framework/Framework/connection/adapter_agent.c
View File

@ -175,18 +175,67 @@ __out:
return result;
}
int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check)
{
int ret = 0;
char *result = NULL;
if (NULL == agent || NULL == cmd || NULL == check ) {
return -1;
}
ATReplyType reply = CreateATReply(64);
if (NULL == reply) {
printf("%s %d at_create_resp failed!\n",__func__,__LINE__);
ret = -1;
goto __exit;
}
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd);
PrivTaskDelay(3000);
result = GetReplyText(reply);
if (!result) {
printf("%s %n get reply failed.\n",__func__,__LINE__);
ret = -1;
goto __exit;
}
printf("[reply result :\n");
printf("%s]\n", result);
if(!strstr(result, check)) {
printf("%s %d check[%s] reply[%s] failed.\n",__func__,__LINE__,check,result);
ret = -1;
goto __exit;
}
__exit:
DeleteATReply(reply);
return ret;
}
char *GetReplyText(ATReplyType reply)
{
return reply->reply_buffer;
}
int AtSetReplyEndChar(ATAgentType agent, char ch)
int AtSetReplyLrEnd(ATAgentType agent, char enable)
{
if (!agent) {
return -ERROR;
}
agent->reply_end_char = ch;
agent->reply_lr_end = enable;
return EOK;
}
int AtSetReplyEndChar(ATAgentType agent, char last_ch, char end_ch)
{
if (!agent) {
return -ERROR;
}
agent->reply_end_last_char = last_ch;
agent->reply_end_char = end_ch;
return EOK;
}
@ -284,10 +333,11 @@ static int GetCompleteATReply(ATAgentType agent)
is_full = true;
}
if ((ch == '\n' && last_ch == '\r') ||
((ch == agent->reply_end_char) && (agent->reply_end_char)) ||
if (((ch == '\n') && (last_ch == '\r') && (agent->reply_lr_end)) ||
((ch == agent->reply_end_char) && (agent->reply_end_char) &&
(last_ch == agent->reply_end_last_char) && (agent->reply_end_last_char)) ||
((read_len == agent->reply_char_num) && (agent->reply_char_num))){
if (is_full){
if (is_full) {
printf("read line failed. The line data length is out of buffer size(%d)!", agent->maintain_max);
memset(agent->maintain_buffer, 0x00, agent->maintain_max);
agent->maintain_len = 0;
@ -351,7 +401,7 @@ static void *ATAgentReceiveProcess(void *param)
if (agent->reply != NULL){
ATReplyType reply = agent->reply;
agent->maintain_buffer[agent->maintain_len - 1] = '\0';
agent->maintain_buffer[agent->maintain_len] = '\0';
if (agent->maintain_len < reply->reply_max_len){
memcpy(reply->reply_buffer, agent->maintain_buffer, agent->maintain_len);

14
APP_Framework/Framework/connection/at_agent.h
View File

@ -26,6 +26,8 @@
#include <stdio.h>
#include <sys/types.h>
#define REPLY_TIME_OUT 3000
enum ReceiveMode
{
ENTM_MODE = 1,
@ -52,6 +54,8 @@ struct ATAgent
int lock;
ATReplyType reply;
char reply_lr_end;
char reply_end_last_char;
char reply_end_char;
uint32 reply_char_num;
int rsp_sem;
@ -69,18 +73,18 @@ typedef struct ATAgent *ATAgentType;
int EntmSend(ATAgentType agent, const char *data, int len);
int EntmRecv(ATAgentType agent, char *rev_buffer, int buffer_len, int timeout_s);
char *GetReplyText(ATReplyType reply);
int AtSetReplyEndChar(ATAgentType agent, char ch);
int AtSetReplyEndChar(ATAgentType agent, char last_ch, char end_ch);
int AtSetReplyCharNum(ATAgentType agent, unsigned int num);
int AtSetReplyLrEnd(ATAgentType agent, char enable);
ATReplyType CreateATReply(uint32 reply_max_len);
uint IpTint(char *ipstr);
unsigned int IpTint(char *ipstr);
void SwapStr(char *str, int begin, int end);
char* IpTstr(uint ipint);
char* IpTstr(unsigned int ipint);
ATAgentType GetATAgent(const char *agent_name);
int InitATAgent(const char *agent_name, int fd, uint32 maintain_max);
int ParseATReply(char* str, const char *format, ...);
void DeleteATReply(ATReplyType reply);
int ATOrderSend(ATAgentType agent, uint32 timeout_s, ATReplyType reply, const char *cmd_expr, ...);
#define REPLY_TIME_OUT 3000
int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check);
#endif

18
APP_Framework/Framework/connection/bluetooth/HC08/hc08.c
View File

@ -98,19 +98,19 @@ static int Hc08AtConfigure(ATAgentType agent, enum Hc08AtCmd hc08_at_cmd, void *
switch (hc08_at_cmd)
{
case HC08_AT_CMD_DETECT:
AtSetReplyEndChar(agent, 0x4B);
AtSetReplyEndChar(agent, 0x4F, 0x4B);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_DETECT_CMD);
break;
case HC08_AT_CMD_DEFAULT:
AtSetReplyEndChar(agent, 0x4B);
AtSetReplyEndChar(agent, 0x4F, 0x4B);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_DEFAULT_CMD);
break;
case HC08_AT_CMD_RESET:
AtSetReplyEndChar(agent, 0x4B);
AtSetReplyEndChar(agent, 0x4F, 0x4B);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_RESET_CMD);
break;
case HC08_AT_CMD_CLEAR:
AtSetReplyEndChar(agent, 0x4B);
AtSetReplyEndChar(agent, 0x4F, 0x4B);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_CLEAR_CMD);
break;
case HC08_AT_CMD_GET_DEVICE_INFO:
@ -121,23 +121,23 @@ static int Hc08AtConfigure(ATAgentType agent, enum Hc08AtCmd hc08_at_cmd, void *
baudrate = *(unsigned int *)param;
sprintf(cmd_str, HC08_SET_BAUDRATE_CMD, baudrate);
strcat(cmd_str, ",N");
AtSetReplyEndChar(agent, 0x45);
AtSetReplyEndChar(agent, 0x4E, 0x45);
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd_str);
reply_ok_flag = 0;
break;
case HC08_AT_CMD_GET_BAUDRATE:
AtSetReplyEndChar(agent, 0x4E);
AtSetReplyEndChar(agent, 0x2C, 0x4E);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_GET_BAUDRATE_CMD);
reply_ok_flag = 0;
break;
case HC08_AT_CMD_SET_CONNECTABLE:
connectable = (char *)param;
sprintf(cmd_str, HC08_SET_CONNECTABLE, connectable);
AtSetReplyEndChar(agent, 0x4B);
AtSetReplyEndChar(agent, 0x4F, 0x4B);
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd_str);
break;
case HC08_AT_CMD_GET_CONNECTABLE:
AtSetReplyEndChar(agent, 0x65);
AtSetReplyEndChar(agent, 0x6C, 0x65);
ATOrderSend(agent, REPLY_TIME_OUT, reply, HC08_GET_CONNECTABLE);
reply_ok_flag = 0;
break;
@ -346,7 +346,7 @@ static int Hc08Send(struct Adapter *adapter, const void *buf, size_t len)
x_err_t result = EOK;
if (adapter->agent) {
EntmSend(adapter->agent, (const char *)buf, len);
}else {
} else {
printf("Hc08Send can not find agent\n");
}
return 0;

33
APP_Framework/Framework/connection/zigbee/E18/e18.c
View File

@ -79,39 +79,6 @@ static int E18UartOpen(struct Adapter *adapter)
return 0;
}
static int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check)
{
char *result = NULL;
if (NULL == agent || NULL == cmd || NULL == check ) {
return -1;
}
ATReplyType reply = CreateATReply(64);
if (NULL == reply) {
printf("%s %d at_create_resp failed!\n",__func__,__LINE__);
return -1;
}
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd);
PrivTaskDelay(3000);
result = GetReplyText(reply);
if (!result) {
printf("%s %n get reply failed.\n",__func__,__LINE__);
goto __exit;
}
if(0 != strncmp(result, check, strlen(check))) {
printf("%s %d check[%s] reply[%s] failed.\n",__func__,__LINE__,check,result);
goto __exit;
}
return 0;
__exit:
DeleteATReply(reply);
return -1;
}
static int E18NetworkModeConfig(struct Adapter *adapter)
{
int ret = 0;