这是rt-thread中4G模块U9507的驱动代码，请解释这个驱动代码，并解释清楚每个函数的作用以及运行的逻辑，逐行代码进行解释
/*
* File : at_socket_u9507c.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software
Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software
Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2019-03-12 liuke first version
*/
#include <stdio.h>
#include <string.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <sys/socket.h>
#include <at.h>
#include <at_socket.h>
#include "at_socket_cfg.h"
#if !defined(AT_SW_VERSION_NUM) || AT_SW_VERSION_NUM < 0x10200
#error "This AT Client version is older, please check and update latest AT Client!"
#endif
#define LOG_TAG "at.u9507c"
#include <at_log.h>
#ifdef AT_DEVICE_USE_U9507
#define U9507C_MODULE_SEND_MAX_SIZE 1500
#define U9507C_WAIT_CONNECT_TIME 5000
#define U9507C_THREAD_STACK_SIZE 2048
#define U9507C_THREAD_PRIORITY (RT_THREAD_PRIORITY_MAX/2)
#define U9507C_SOCKET_POS 1
#define U9300_DEVICE_USE 1
/* set real event by current socket and current state */
#define SET_EVENT(socket, event) (((socket + 1) << 16) | (event))
/* AT socket event type */
#define U9507C_EVENT_CONN_OK (1L << 0)
#define U9507C_EVENT_SEND_OK (1L << 1)
#define U9507C_EVENT_RECV_OK (1L << 2)
#define U9507C_EVNET_CLOSE_OK (1L << 3)
#define U9507C_EVENT_CONN_FAIL (1L << 4)
#define U9507C_EVENT_SEND_FAIL (1L << 5)
/* AT+CSTT command default*/
#ifdef USE_SLDY_SIMCARD
char *CGDCONT_CHINA_MOBILE = "AT+CGDCONT=1,\"IP\",\"dxcycek.dy.sd\"";
#else
char *CGDCONT_CHINA_MOBILE = "AT+CGDCONT=1,\"IP\",\"CMNET\"";
#endif
char *CGDCONT_CHINA_UNICOM = "AT+CGDCONT=1,\"IP\",\"UNINET\"";
char *CGDCONT_CHINA_TELECOM = "AT+CGDCONT=1,\"IP\",\"CTNET\"";
char net_status = 0;
char module_rdy = 0;
static rt_event_t at_socket_event;
static rt_mutex_t at_event_lock;
char recv_sms_flg = 0;
static at_evt_cb_t at_evt_cb_set[] = {
[AT_SOCKET_EVT_RECV] = NULL,
[AT_SOCKET_EVT_CLOSED] = NULL,
};
#ifdef GSM_USE_SMS
static struct rt_messagequeue mq;
char* msm_context = RT_NULL;
/* 消息队列中用到的放置消息的内存池 */
static char msg_pool[64];
char* read_sms(void);
#endif
int get_iemi(char *iemi);
static int at_socket_event_send(uint32_t event)
{
return (int) rt_event_send(at_socket_event, event);
}
static int at_socket_event_recv(uint32_t event, uint32_t timeout, rt_uint8_t option)
{
int result = 0;
rt_uint32_t recved;
result = rt_event_recv(at_socket_event, event, option | RT_EVENT_FLAG_CLEAR, timeout, &recved);
if (result != RT_EOK)
{
return -RT_ETIMEOUT;
}
return recved;
}
/**
* close socket by AT commands.
*
* @param current socket
*
* @return 0: close socket success
* -1: send AT commands error
* -2: wait socket event timeout
* -5: no memory
*/
static int u9507c_socket_close(int socket)
{
int result = 0;
at_response_t resp = RT_NULL;
resp = at_create_resp(64, 2, rt_tick_from_millisecond(2 * 1000));
if (!resp)
{
LOG_E("No memory for response structure!");
return -RT_ENOMEM;
}
/* default connection timeout is 10 seconds, but it set to 1 seconds is convenient to use.*/
result = at_exec_cmd(RT_NULL, "AT+MIPCLOSE=%d", socket+U9507C_SOCKET_POS);
if (result < 0)
{
LOG_E("socket (%d) close failed, wait close OK timeout or ERROR.", socket);
}
if (resp)
{
at_delete_resp(resp);
}
return result;
}
/**
* create TCP/UDP client or server connect by AT commands.
*
* @param socket current socket
* @param ip server or client IP address
* @param port server or client port
* @param type connect socket type(tcp, udp)
* @param is_client connection is client
*
* @return 0: connect success
* -1: connect failed, send commands error or type error
* -2: wait socket event timeout
* -5: no memory
*/
static int u9507c_socket_connect(int socket, char *ip, int32_t port, enum at_socket_type type, rt_bool_t is_client)
{
int result = 0, event_result = 0;
rt_bool_t retryed = RT_FALSE;
RT_ASSERT(ip);
RT_ASSERT(port >= 0);
/* lock AT socket connect */
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
__retry:
if (is_client)
{
switch (type)
{
case AT_SOCKET_TCP:
/* send AT commands(eg: AT+QIOPEN=0,"TCP","x.x.x.x", 1234) to connect TCP server */
if (at_exec_cmd(RT_NULL, "AT+MIPOPEN=%d,0,\"%s\",%d,0", socket+U9507C_SOCKET_POS, ip, port) < 0)
{
result = -RT_ERROR;
goto __exit;
}
break;
case AT_SOCKET_UDP:
if (at_exec_cmd(RT_NULL, "AT+MIPOPEN=%d,0,\"%s\",%d,1", socket+U9507C_SOCKET_POS, ip, port) < 0)
{
result = -RT_ERROR;
goto __exit;
}
break;
default:
LOG_E("Not supported connect type : %d.", type);
result = -RT_ERROR;
goto __exit;
//break;
}
}
/* waiting result event from AT URC, the device default connection timeout is 75 seconds, but it set to 10 seconds is convenient to use.*/
if (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(30 * 1000), RT_EVENT_FLAG_OR) < 0)
{
LOG_E("socket (%d) connect failed, wait connect result timeout.", socket);
result = -RT_ETIMEOUT;
goto __exit;
}
/* waiting OK or failed result */
if ((event_result = at_socket_event_recv(U9507C_EVENT_CONN_OK | U9507C_EVENT_CONN_FAIL, rt_tick_from_millisecond(30 * 1000),
RT_EVENT_FLAG_OR)) < 0)
{
LOG_E("socket (%d) connect failed, wait connect OK|FAIL timeout.", socket);
result = -RT_ETIMEOUT;
goto __exit;
}
/* check result */
if (event_result & U9507C_EVENT_CONN_FAIL)
{
if (!retryed)
{
LOG_E("socket (%d) connect failed, maybe the socket was not be closed at the last time and now will retry.", socket);
if (u9507c_socket_close(socket) < 0)
{
goto __exit;
}
retryed = RT_TRUE;
goto __retry;
}
LOG_E("socket (%d) connect failed, failed to establish a connection.", socket);
result = -RT_ERROR;
goto __exit;
}
__exit:
if(result != 0)
{
u9507c_socket_close(socket);
}
/* unlock AT socket connect */
rt_mutex_release(at_event_lock);
return result;
}
/**
* send data to server or client by AT commands.
*
* @param socket current socket
* @param buff send buffer
* @param bfsz send buffer size
* @param type connect socket type(tcp, udp)
*
* @return >=0: the size of send success
* -1: send AT commands error or send data error
* -2: waited socket event timeout
* -5: no memory
*/
static int u9507c_socket_send(int socket,
const char *buff, size_t bfsz, enum at_socket_type type)
{
int result = 0, event_result = 0;
at_response_t resp = RT_NULL;
RT_ASSERT(buff);
resp = at_create_resp(2048, 2, rt_tick_from_millisecond(5000));
if (!resp)
{
LOG_E("No memory for response structure!");
return -RT_ENOMEM;
}
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
at_set_end_sign('>');
// bfsz > 1000 ? (bfsz=800) : (bfsz = bfsz);
/* set current socket for send URC event */
{
if (at_exec_cmd(resp, "AT+MIPTPS=3,%d,2000,%d", socket+U9507C_SOCKET_POS,bfsz) < 0)
{
result = -RT_ERROR;
goto __exit;
}
/* send the real data to server or client */
result = (int) at_client_send(buff,bfsz);
if (result == 0)
{
result = -RT_ERROR;
goto __exit;
}
/* waiting result event from AT URC */
if (at_socket_event_recv(SET_EVENT(socket, 0), rt_tick_from_millisecond(5 * 1000), RT_EVENT_FLAG_OR) < 0)
{
LOG_E("socket (%d) send failed, wait connect result timeout.", socket);
result = -RT_ETIMEOUT;
goto __exit;
}
/* waiting OK or failed result */
if ((event_result = at_socket_event_recv(U9507C_EVENT_SEND_OK | U9507C_EVENT_SEND_FAIL, rt_tick_from_millisecond(5 * 1000),
RT_EVENT_FLAG_OR)) < 0)
{
LOG_E("socket (%d) send failed, wait connect OK|FAIL timeout.", socket);
result = -RT_ETIMEOUT;
goto __exit;
}
/* check result */
if (event_result & U9507C_EVENT_SEND_FAIL)
{
LOG_E("socket (%d) send failed, return failed.", socket);
result = -RT_ERROR;
goto __exit;
}
else
{
result = bfsz;
}
}
if(event_result & U9507C_EVENT_SEND_OK)
{
}
__exit:
/* reset the end sign for data conflict */
at_set_end_sign(0);
rt_mutex_release(at_event_lock);
if (resp)
{
at_delete_resp(resp);
}
return result;
}
/**
* domain resolve by AT commands.
* http://xiantech.vicp.net:8888/update/
JSMO2O2G.rbl
* @param name domain name
* @param ip parsed IP address, it's length must be 16
*
* @return 0: domain resolve success
* -1: send AT commands error or response error
* -2: wait socket event timeout
* -5: no memory
*/
static int u9507c_domain_resolve(
const char *name, char ip[16])
{
#define RESOLVE_RETRY 5
int i, result = RT_EOK;
char recv_ip[16] = { 0 };
at_response_t resp = RT_NULL;
RT_ASSERT(name);
RT_ASSERT(ip);
/* The maximum response time is 14 seconds, affected by network status */
resp = at_create_resp(128, 4, rt_tick_from_millisecond(14 * 1000));
if (!resp)
{
LOG_E("No memory for response structure!");
return -RT_ENOMEM;
}
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
for(i = 0; i < RESOLVE_RETRY; i++)
{
if (at_exec_cmd(resp, "AT+MIPDNSR=\"%s\"", name) < 0)
{
result = -RT_ERROR;
goto __exit;
}
/* parse the third line of response data, get the IP address */ // +MIPDNSR:118.24.195.65
if(at_resp_parse_line_args_by_kw(resp, "+MIPDNSR:", "+MIPDNSR:%s", recv_ip) < 0)
{
rt_thread_delay(rt_tick_from_millisecond(100));
/* resolve failed, maybe receive an URC CRLF */
continue;
}
if (strlen(recv_ip) < 8)
{
rt_thread_delay(rt_tick_from_millisecond(100));
/* resolve failed, maybe receive an URC CRLF */
continue;
}
else
{
strncpy(ip, recv_ip, 15);
ip[15] = '\0';
break;
}
}
__exit:
rt_mutex_release(at_event_lock);
if (resp)
{
at_delete_resp(resp);
}
return result;
}
/**
* set AT socket event notice callback
*
* @param event notice event
* @param cb notice callback
*/
static void u9507c_socket_set_event_cb(at_socket_evt_t event, at_evt_cb_t cb)
{
if (event < sizeof(at_evt_cb_set) / sizeof(at_evt_cb_set[1]))
{
at_evt_cb_set[event] = cb;
}
}
static void urc_connect_func(
const char *data, rt_size_t size)
{
int socket ;
int result = 0;
RT_ASSERT(data && size);
if(!sscanf(data, "+MIPOPEN=%d,%d", &socket , &result))
{
sscanf(data, "+MIPOPEN:%d,%d", &socket , &result);
}
// LOG_I("Connect server success.");
//LOG_I("urc_connect_func data = %s,result = %d .",data,result);
if (result == 1)
{
at_socket_event_send(SET_EVENT(socket-U9507C_SOCKET_POS, U9507C_EVENT_CONN_OK));
}
else
{
at_socket_event_send(SET_EVENT(socket-U9507C_SOCKET_POS, U9507C_EVENT_CONN_FAIL));
}
}
static void urc_send_func(
const char *data, rt_size_t size)
{
int socket ;
int result = 0;
RT_ASSERT(data && size);
//+MIPPUSH:1,1.
sscanf(data, "+MIPPUSH:%d,%d", &socket , &result);
//LOG_I("urc_send_func data = %s,socket = %d .",data,result);
if(result)
{
at_socket_event_send(SET_EVENT(socket-U9507C_SOCKET_POS, U9507C_EVENT_SEND_OK));
}
else
{
at_socket_event_send(SET_EVENT(socket-U9507C_SOCKET_POS, U9507C_EVENT_SEND_FAIL));
}
}
static void urc_close_func(
const char *data, rt_size_t size)
{
int socket = 0 ;
RT_ASSERT(data && size);
sscanf(data, "+MIPCLOSE:%d,%*s", &socket);
if(socket > 0)
{
if (at_evt_cb_set[AT_SOCKET_EVT_CLOSED])
{
at_evt_cb_set[AT_SOCKET_EVT_CLOSED](socket-U9507C_SOCKET_POS, AT_SOCKET_EVT_CLOSED, NULL, 0);
}
}
}
static void urc_recv_func(
const char *data, rt_size_t size)
{
int socket = 0;
rt_int32_t bfsz = 0,temp_size = 0;
rt_int32_t timeout;
char *recv_buf = RT_NULL, temp[8];;
char readcmd[16],vldp = 0;
RT_ASSERT(data && size);
/* get the current socket and receive buffer size by receive data */
vldp = sscanf(data, "+MIPRTCP=%d,%d", &socket,&bfsz);
//LOG_I("urc_recv_func %d , data = %s , socket = %d , bfsz = %d .\n",vldp,data,socket,bfsz);
if(vldp == 0)
{
vldp = sscanf(data, "+MIPRUDP=%d,%d", &socket,&bfsz); // +MIPRUDP: %*[^,],%*[^,],
}
if(vldp == 1)
{
rt_thread_mdelay(120);
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
rt_sprintf(readcmd,"AT+MIPREAD=%d\r\n",socket);
at_client_send(readcmd,rt_strlen(readcmd));
// //LOG_I("urc_recv_func readcmd = %s .",readcmd);
if(1 == U9300_DEVICE_USE)
{
// //LOG_I("U9300_DEVICE_USE send ok success !");
at_socket_event_send(SET_EVENT(socket-U9507C_SOCKET_POS, U9507C_EVENT_SEND_OK));
}
rt_mutex_release(at_event_lock);
return;
}
timeout = bfsz;
/* sync receive data */
recv_buf = rt_calloc(1, bfsz);
if (!recv_buf)
{
LOG_E("no memory for URC receive buffer (%d)!", bfsz);
/* read and clean the coming data */
while (temp_size < bfsz)
{
if (bfsz - temp_size > sizeof(temp))
{
at_client_recv(temp, sizeof(temp), timeout);
}
else
{
at_client_recv(temp, bfsz - temp_size, timeout);
}
temp_size += sizeof(temp);
}
return;
}
/* sync receive data */
if (at_client_recv(recv_buf, bfsz, timeout) != bfsz)
{
LOG_E("receive size(%d) data failed!", bfsz);
rt_free(recv_buf);
return;
}
//LOG_I("urc_recv_func recv_buf = %s .\n",recv_buf);
/* notice the receive buffer and buffer size */
if (at_evt_cb_set[AT_SOCKET_EVT_RECV])
{
at_evt_cb_set[AT_SOCKET_EVT_RECV](socket-U9507C_SOCKET_POS, AT_SOCKET_EVT_RECV, recv_buf, bfsz);
}
}
static char ping_sta = 0;
static void urc_ping_func(
const char *data, rt_size_t size)
{
static int icmp_seq = 0;
int i, j = 0;
int result, recv_len = 60, time, ttl= 255;
int sent, rcvd, avg;
char dst_ip[16] = { 0 };
RT_ASSERT(data);
for (i=0;i<size;i++)
{
if(*(data+i) == '.')
j++;
}
if (j != 0)
{ //+MPING:220.181.38.148,1,123
sscanf(data, "+MPING:%[^,],%d,%d", dst_ip, &icmp_seq, &time);
rt_kprintf("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", recv_len, dst_ip, icmp_seq, ttl, time);
}
else
{ //+MPINGSTATE:0,4,4,109
sscanf(data, "+MPINGSTATE: %d,%d,%d,%d", &result, &sent, &rcvd, &avg);
if (result == 0)
rt_kprintf("%d sent %d received %d lost, average=%dms\n", sent, rcvd, sent - rcvd, avg);
else
rt_kprintf("Can not found host\n");
ping_sta = 1;
}
}
static void urc_sms_func(
const char *data, rt_size_t size)
{
int msg_pos = 0;
rt_kprintf("receive a message\n");
sscanf(data,"+CMTI: %*[^,],%d",&msg_pos);
rt_kprintf("msg pos: %d\n",msg_pos);
recv_sms_flg = 1;
SHOW_STATUS(SMS_TIPS);
#ifdef GSM_USE_SMS
rt_mq_send(&mq, &msg_pos, sizeof(int));
#endif
}
#if 1
static void urc_func(
const char *data, rt_size_t size)
{
int mode = 0;
RT_ASSERT(data);
LOG_I("URC data : %.*s", size, data);
if(sscanf(data,"^MODE: %d",&mode))
{
if(mode == 0)
net_status = 0;
else
module_rdy = 1;
}
}
#endif
static
const struct at_urc urc_table[] = {
{"+MIPOPEN", "\r\n", urc_connect_func},
{"+MIPCLOSE:", "\r\n", urc_close_func},
{"+MIPRTCP", "\r\n", urc_recv_func},
{"+MIPRUDP", "\r\n", urc_recv_func},
{"^MODE:", "\r\n", urc_func},
{"+CMTI:", "\r\n", urc_sms_func},
{"+MPING:", "\r\n", urc_ping_func},
{"+MPINGSTATE:", "\r\n", urc_ping_func},
{"+MIPPUSH", "\r\n", urc_send_func},
};
#define AT_SEND_CMD(resp, resp_line, timeout, cmd) \
do \
{ \
if (at_exec_cmd(at_resp_set_info(resp, 128, resp_line, rt_tick_from_millisecond(timeout)), cmd) < 0) \
{ \
result = -RT_ERROR; \
goto __exit; \
} \
} while(0); \
/**
* 读GPRS接收到的短信
*
* 输入参数： 无
*
* 输出参数： RT_NULL : 没有读到短信
* char * : 读到短信内容的指针
*/
#ifdef GSM_USE_SMS
char* read_sms(void)
{
int result = 0;
char cmd_buf[15] = {0};
const char *message = RT_NULL;
at_response_t resp = RT_NULL;
int msg_pos = 0;
result = rt_mq_recv(&mq, &msg_pos, sizeof(int),RT_WAITING_FOREVER);//RT_TICK_PER_SECOND);
if(result != RT_EOK)
{
return RT_NULL;
}
resp = at_create_resp(128, 4, rt_tick_from_millisecond(300));
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
rt_sprintf(cmd_buf,"AT+CMGR=%d",msg_pos);
AT_SEND_CMD(resp, 0, 300, cmd_buf); // 读取信息内容
message = at_resp_get_line(resp,3);
msm_context = rt_malloc(rt_strlen(message));
if(msm_context != RT_NULL)
{
memcpy(msm_context,message,rt_strlen(message));
}
rt_sprintf(cmd_buf,"AT+CMGD=%d,4",msg_pos);
AT_SEND_CMD(resp, 0, 25*1000, cmd_buf); // 删除该条短信
__exit:
rt_mutex_release(at_event_lock);
if (resp)
{
at_delete_resp(resp);
}
if(msm_context)
{
return (char*)msm_context;
}
else
{
return RT_NULL;
}
}
//MSH_CMD_
EXPORT(read_sms,read message);
#endif
/* init for U9507C */
void lte_init_thread_entry(void *parameter)
{
#define CPIN_RETRY 10
#define CSQ_RETRY 20
#define CREG_RETRY 10
#define CGREG_RETRY 20
at_response_t resp = RT_NULL;
int i = 0;
int mipcall_state=0;
char parsed_data[10];
rt_err_t result = RT_EOK;
module_rdy = 0;
net_status = 0;
resp = at_create_resp(128, 0, rt_tick_from_millisecond(300));
if (!resp)
{
LOG_E("No memory for response structure!");
result = -RT_ENOMEM;
goto __exit;
}
LOG_D("Start initializing the U9507C module");
rt_pin_write(U9507C_POWER_CTL,PIN_LOW);
rt_thread_mdelay(5000);
rt_pin_write(U9507C_POWER_CTL,PIN_HIGH);
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
module_rdy = 0;
while((!module_rdy)&&(i<30))
{
i++;
rt_thread_mdelay(1000);
}
i = 0;
/* waiting for dirty data to be digested */
wait_connect:
/* wait U9507C startup finish */
if (at_client_wait_connect(U9507C_WAIT_CONNECT_TIME))
{
if(i++ < 3)
{
goto wait_connect;
}
result = -RT_ETIMEOUT;
goto __exit;
}
/* disable echo */
/* get module version */
AT_SEND_CMD(resp, 0, 300, "ATI");
/* show module version */
for (i = 0; i < (int)resp->line_counts - 1; i++)
{
LOG_D("%s", at_resp_get_line(resp, i + 1));
}
i = 0;
/* disable echo */
AT_SEND_CMD(resp, 0, 300, "ATE0");
/* check SIM card */
for (i = 0; i < CPIN_RETRY; i++)
{
at_exec_cmd(at_resp_set_info(resp, 128, 2, rt_tick_from_millisecond(5000)), "AT+CPIN?");
if (at_resp_get_line_by_kw(resp, "READY"))
{
LOG_D("SIM card detection success");
break;
}
rt_thread_delay(rt_tick_from_millisecond(1000));
}
if (i == CPIN_RETRY)
{
LOG_E("SIM card detection failed!");
result = -RT_ERROR;
goto __exit;
}
/* check the GSM network is registered */
for (i = 0; i < CREG_RETRY; i++)
{
AT_SEND_CMD(resp, 0, 300, "AT+CREG?");
at_resp_parse_line_args_by_kw(resp, "+CREG:", "+CREG: %s", &parsed_data);
if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("GSM network is registered (%s)", parsed_data);
break;
}
rt_thread_delay(rt_tick_from_millisecond(1000));
}
if (i == CREG_RETRY)
{
/* check the GPRS network is registered */
for (i = 0; i < CGREG_RETRY; i++)
{
AT_SEND_CMD(resp, 0, 300, "AT+CGREG?");
at_resp_parse_line_args_by_kw(resp, "+CGREG:", "+CGREG: %s", &parsed_data);
if (!strncmp(parsed_data, "0,1", sizeof(parsed_data)) || !strncmp(parsed_data, "0,5", sizeof(parsed_data)))
{
LOG_D("GPRS network is registered (%s)", parsed_data);
break;
}
rt_thread_delay(rt_tick_from_millisecond(1000));
}
if (i == CGREG_RETRY)
{
LOG_E("The GPRS network is register failed (%s)", parsed_data);
result = -RT_ERROR;
goto __exit;
}
}
/* check signal strength */
for (i = 0; i < CSQ_RETRY; i++)
{
AT_SEND_CMD(resp, 0, 300, "AT+CSQ");
at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %s", &parsed_data);
if (strncmp(parsed_data, "99,99", sizeof(parsed_data)))
{
sscanf(parsed_data,"%d,%*s", &SignalStrength);
LOG_D("Signal strength: %s", parsed_data);
break;
}
rt_thread_delay(rt_tick_from_millisecond(1000));
}
if (i == CSQ_RETRY)
{
LOG_E("Signal strength check failed (%s)", parsed_data);
result = -RT_ERROR;
goto __exit;
}
{
char cgdcont[64];
rt_sprintf(cgdcont,"AT+CGDCONT=1,\"IP\",\"%s\"",gSysPara.APN);
AT_SEND_CMD(resp, 0, 300, "AT+COPS?");
at_resp_parse_line_args_by_kw(resp, "+COPS:", "+COPS: %*[^\"]\"%[^\"]", &parsed_data);
if (strcmp(parsed_data, "CHINA MOBILE") == 0)
{
/* "CMCC" */
LOG_I("%s", parsed_data);
AT_SEND_CMD(resp, 0, 500, cgdcont);
}
else if (strcmp(parsed_data, "CHN-UNICOM") == 0)
{
/* "UNICOM" */
LOG_I("%s", parsed_data);
AT_SEND_CMD(resp, 0, 500, cgdcont);
}
else if (strcmp(parsed_data, "CHN-CT") == 0)
{
AT_SEND_CMD(resp, 0, 500, cgdcont);
/* "CT" */
LOG_I("%s", parsed_data);
}
}
// AT_SEND_CMD(resp, 0, 150 * 1000, "AT+MIPCLOSE?");//+MIPCLOSE:1
//at_resp_parse_line_args_by_kw(resp, "+MIPCLOSE:", "+MIPCLOSE:%d", &socket_value);
// rt_thread_delay(rt_tick_from_millisecond(100));
{
extern SysPara gSysPara;
char sim_iemi[16];
get_iemi(sim_iemi);
if(rt_memcmp(sim_iemi,gSysPara.SIM_IMSI,15))
{
rt_memcpy(gSysPara.SIM_IMSI,sim_iemi,15);
save_syspara();
}
}
/* Deactivate context profile */
AT_SEND_CMD(resp, 0, 40 * 1000, "AT+MIPCALL=0");
/* Activate context profile */
AT_SEND_CMD(resp, 0, 150 * 1000, "AT+MIPCALL=1");
/* Query the status of the context profile */
AT_SEND_CMD(resp, 0, 150 * 1000, "AT+MIPCALL?");
//at_resp_parse_line_args_by_kw(resp, "+MIPCALL:", "+MIPCALL: %*[^\"]\"%[^\"]", &parsed_data);
at_resp_parse_line_args_by_kw(resp, "+MIPCALL:", "+MIPCALL:%d", &mipcall_state);
AT_SEND_CMD(resp, 0, 1000, "AT+CMGF=1");
AT_SEND_CMD(resp, 0, 1000, "AT+CNMI=2,1");
AT_SEND_CMD(resp, 0, 1000, "AT+LSHAUTOWRAPEN?");
rt_thread_mdelay(200);
AT_SEND_CMD(resp, 0, 1000, "AT+LSHAUTOWRAPEN=?");
rt_thread_mdelay(200);
AT_SEND_CMD(resp, 0, 1000, "AT+LSHAUTOWRAPEN=1");
rt_thread_mdelay(200);
AT_SEND_CMD(resp, 0, 1000, "AT+MIPRS=0");
if(mipcall_state == 0)
{
result = -RT_ERROR;
goto __exit;
}
__exit:
rt_mutex_release(at_event_lock);
if (resp)
{
at_delete_resp(resp);
}
if (!result)
{
net_status = 1;
LOG_I("AT network initialize success!");
}
else
{
net_status = 0;
LOG_E("AT network initialize failed (%d)!", result);
}
}
int u9507c_net_init(void)
{
#ifdef PKG_AT_INIT_BY_THREAD
rt_thread_t tid;
tid = rt_thread_create("u9507c_net_init", lte_init_thread_entry, RT_NULL, U9507C_THREAD_STACK_SIZE, U9507C_THREAD_PRIORITY, 20);
if (tid)
{
rt_thread_startup(tid);
}
else
{
LOG_E("Create AT initialization thread fail!");
}
#else
u9507c_init_thread_entry(RT_NULL);
#endif
return RT_EOK;
}
void net_init(void)
{
u9507c_net_init();
}
int u9507c_ping(int argc, char **argv)
{
at_response_t resp = RT_NULL;
if (argc != 2)
{
rt_kprintf("Please input: at_ping <host address>.eg:ddress <at_ping \"www.baidu.com\">\n");
return -RT_ERROR;
}
ping_sta = 0;
resp = at_create_resp(128, 0, rt_tick_from_millisecond(5000));
if (!resp)
{
rt_kprintf("No memory for response structure!\n");
return -RT_ENOMEM;
}
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
if (at_exec_cmd(resp, "AT+MPING=\"%s\"", argv[1]) < 0)
{
rt_kprintf("AT send ping commands error!\n");
return -RT_ERROR;
}
if (resp)
{
at_delete_resp(resp);
}
while(!ping_sta)
{
rt_thread_mdelay(200);
}
rt_mutex_release(at_event_lock);
return RT_EOK;
}
int u9507c_ifconfig(void)
{
at_response_t resp = RT_NULL;
char resp_arg[AT_CMD_MAX_LEN] = { 0 };
rt_err_t result = RT_EOK;
rt_int32_t value;
resp = at_create_resp(128, 2, rt_tick_from_millisecond(300));
if (!resp)
{
rt_kprintf("No memory for response structure!\n");
return -RT_ENOMEM;
}
rt_mutex_take(at_event_lock, RT_WAITING_FOREVER);
/* Query the status of the context profile */
AT_SEND_CMD(resp, 0, 5 * 1000, "AT+MIPCALL?");
at_resp_parse_line_args_by_kw(resp, "+MIPCALL:", "+MIPCALL: %d,%s", &value,&resp_arg);
rt_kprintf("IP adress : %s\n", resp_arg);
__exit:
rt_mutex_release(at_event_lock);
if (resp)
{
at_delete_resp(resp);
}
return result;
}
int u9507c_connect(int argc, char **argv)
{
int32_t port;
if (argc != 3)
{
rt_kprintf("Please input: at_connect <host address> <port> eg:<at_connect \"113.140.31.150\" 60119>\n");
return -RT_ERROR;
}
sscanf(argv[2],"%d",&port);
if(0 == u9507c_socket_connect(0, argv[1], port, AT_SOCKET_TCP, 1))
{
rt_kprintf("Connect success!\n");
}
else
{
rt_kprintf("Connect failed!\n");
}
return RT_EOK;
}
int u9507c_close(int argc, char **argv)
{
if (u9507c_socket_close(0) < 0)
{
rt_kprintf("u9507c_socket_close fail\n");
}
else
{
rt_kprintf("u9507c_socket_closeed\n");
}
return RT_EOK;
}
int u9507c_send(int argc, char **argv)
{
char buff[16] = {1,2,3,4,5,6,7,8,9,0,0,1,2,0,3,4};
if(argc != 2)
{
if (u9507c_socket_send(0, buff, sizeof(buff), AT_SOCKET_TCP) < 0)
{
rt_kprintf("u9507c_socket_send fail\n");
return -RT_ERROR;
}
return RT_EOK;
}
if (u9507c_socket_send(0, argv[1], strlen(argv[1]), AT_SOCKET_TCP) < 0)
{
rt_kprintf("u9507c_socket_send fail\n");
return -RT_ERROR;
}
return RT_EOK;
}
int get_iemi(char *iemi)
{
at_response_t resp = RT_NULL;
int result = 0;
resp = at_create_resp(128, 4, rt_tick_from_millisecond(300));
if(resp == RT_NULL)
{
result = -RT_ERROR;
goto __exit;
}
if(iemi == RT_NULL)
{
result = -RT_ERROR;
goto __exit;
}
AT_SEND_CMD(resp, 0, 150 * 1000, "AT+CIMI");
at_resp_parse_line_args(resp,2, "%s", iemi);
LOG_I("IEMI : %s",iemi);
result = RT_EOK;
__exit:
at_delete_resp(resp);
return result;
}
int net_status_check(void)
{
at_response_t resp = RT_NULL;
int result = 0;
int netsta;
resp = at_create_resp(128, 4, rt_tick_from_millisecond(300));
if(resp == RT_NULL)
{
result = -RT_ERROR;
goto __exit;
}
if(rt_mutex_take(at_event_lock, 1000) != RT_EOK)
{
goto get_event_timeout;
}
AT_SEND_CMD(resp, 0, 1000, "AT+CSQ");
at_resp_parse_line_args_by_kw(resp, "+CSQ:", "+CSQ: %d,%*d", &SignalStrength);
// LOG_I("SignalStrength = %d",SignalStrength);
AT_SEND_CMD(resp, 0, 1000, "AT+MIPCALL?");
at_resp_parse_line_args_by_kw(resp, "+MIPCALL:", "+MIPCALL:%d,%*s", &netsta);
if(netsta == 0)
{
net_status = 0;
LOG_W("No net registered!");
}
__exit:
rt_mutex_release(at_event_lock);
get_event_timeout:
at_delete_resp(resp);
return result;
}
#ifdef FINSH_USING_MSH
#include <finsh.h>
MSH_CMD_
EXPORT_ALIAS(u9507c_net_init, at_net_init, initialize AT network);
MSH_CMD_
EXPORT_ALIAS(u9507c_ping, ping, AT ping network host);
MSH_CMD_
EXPORT_ALIAS(u9507c_ifconfig, ifconfig, list the information of network interfaces);
MSH_CMD_
EXPORT_ALIAS(u9507c_connect, at_connect, AT connect network host);
MSH_CMD_
EXPORT_ALIAS(u9507c_send, at_send, AT send a pack);
MSH_CMD_
EXPORT_ALIAS(u9507c_close, at_close, AT close a socket);
#endif
static
const struct at_device_ops u9507c_socket_ops = {
u9507c_socket_connect,
u9507c_socket_close,
u9507c_socket_send,
u9507c_domain_resolve,
u9507c_socket_set_event_cb,
};
static int at_socket_device_init(void)
{
rt_pin_mode(U9507C_POWER_CTL,PIN_MODE_OUTPUT);
rt_pin_write(U9507C_POWER_CTL,PIN_LOW);
/* create current AT socket event */
at_socket_event = rt_event_create("at_se", RT_IPC_FLAG_FIFO);
if (at_socket_event == RT_NULL)
{
LOG_E("AT client port initialize failed! at_sock_event create failed!");
return -RT_ENOMEM;
}
/* create current AT socket event lock */
at_event_lock = rt_mutex_create("at_se", RT_IPC_FLAG_FIFO);
if (at_event_lock == RT_NULL)
{
LOG_E("AT client port initialize failed! at_sock_lock create failed!");
rt_event_delete(at_socket_event);
return -RT_ENOMEM;
}
#ifdef GSM_USE_SMS
/* 初始化消息队列 */
rt_mq_init(&mq, "mqt",
&msg_pool[0], /* 内存池指向msg_pool */
sizeof(int), /* 每个消息的大小是 128 - void* */
sizeof(msg_pool), /* 内存池的大小是msg_pool的大小 */
RT_IPC_FLAG_FIFO); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
#endif
/* initialize AT client */
at_client_init("uart1", AT_DEVICE_RECV_BUFF_LEN); // AT_DEVICE_NAME
/* register URC data execution function */
at_set_urc_table(urc_table, sizeof(urc_table) / sizeof(urc_table[0]));
/* initialize u9507c network */
u9507c_net_init();
#ifdef GSM_USE_SMS
extern int sms_process_init();
sms_process_init();
#endif
/* set u9507c AT Socket options */
at_socket_device_register(&u9507c_socket_ops);
return RT_EOK;
}
INIT_APP_
EXPORT(at_socket_device_init);
void net_status_entry(void *paramter)
{
while(1)
{
rt_thread_mdelay(30*RT_TICK_PER_SECOND);
net_status_check();
}
}
int net_status_task(void)
{
rt_thread_t init_thread;
init_thread = rt_thread_create("netsta",
net_status_entry, RT_NULL,
2048, 30, 20);
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
return 0;
}
INIT_APP_
EXPORT(net_status_task);
#endif /* AT_DEVICE_U9507C */
本文介绍了在iOS开发中定义常量的两种常见方法：使用宏定义和通过声明常量变量来实现。这两种方法各有特点，适用于不同的场景。
扫一扫
370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
