int gps_create_obj(gps_obj_t* gpsobj)
{
int ret = 0;
g_gps_obj = (gps_obj_t*)aos_malloc(sizeof(gps_obj_t));
if(g_gps_obj == NULL){
return -1;
}
memset(g_gps_obj, 0, sizeof(gps_obj_t));
/* install the phy sensor info into the sensor object datebase here */
g_gps_obj->io_port = gpsobj->io_port;
g_gps_obj->path = gpsobj->path;
g_gps_obj->tag = gpsobj->tag;
g_gps_obj->open = gpsobj->open;
g_gps_obj->close = gpsobj->close;
g_gps_obj->ioctl = gpsobj->ioctl;
g_gps_obj->read = gpsobj->read;
g_gps_obj->write = gpsobj->write;
g_gps_obj->irq_handle = gpsobj->irq_handle;
g_gps_obj->mode = gpsobj->mode;
g_gps_obj->power = DEV_POWER_OFF; // will update the status later
g_gps_obj->ref = 0; // count the ref of this sensor
/* register the sensor object into the irq list and vfs */
ret = gps_obj_register();
if (ret != 0) {
goto error;
}
LOG("%s %s successfully \n", GPS_STR, __func__);
return 0;
error:
free(g_gps_obj);
return -1;
}
void k_queue_init(struct k_queue *queue)
{
void *msg_start;
int size = 20;
int stat;
uint8_t blk_size = sizeof(void *) + 1;
msg_start = (void *)aos_malloc(size * blk_size);
assert(msg_start);
queue->_queue = (aos_queue_t *)aos_malloc(sizeof(aos_queue_t));
assert(queue->_queue);
stat = aos_queue_new(queue->_queue, msg_start, size * blk_size, blk_size);
assert(stat == 0);
sys_dlist_init(&queue->poll_events);
}
// register oob
static int at_oob(const char *prefix, const char *postfix, int maxlen,
oob_cb cb, void *arg)
{
oob_t *oob = NULL;
int i = 0;
if (maxlen < 0 || NULL == prefix) {
LOGE(MODULE_NAME, "%s invalid input \r\n", __func__);
return -1;
}
LOGD(MODULE_NAME, "New oob to register pre (%s) post %s \r\n", prefix,
((postfix == NULL) ? "NULL" : postfix));
if (at._oobs_num >= OOB_MAX) {
LOGW(MODULE_NAME, "No place left in OOB.\r\n");
return -1;
}
/*check oob is exit*/
for (i = 0; i < at._oobs_num; i++) {
if (strcmp(prefix, at._oobs[i].prefix) == 0) {
LOGW(MODULE_NAME, "oob prefix %s is already exist.\r\n", prefix);
return -1;
}
}
oob = &(at._oobs[at._oobs_num++]);
oob->oobinputdata = NULL;
if (postfix != NULL) {
oob->oobinputdata = aos_malloc(maxlen);
if (NULL == oob->oobinputdata) {
LOGE(MODULE_NAME, "fail to malloc len %d at %s for prefix %s \r\n",
maxlen, __func__, prefix);
return -1;
}
memset(oob->oobinputdata, 0, maxlen);
}
oob->maxlen = maxlen;
oob->prefix = (char *)prefix;
oob->postfix = (char *)postfix;
oob->cb = cb;
oob->arg = arg;
oob->reallen = 0;
LOGD(MODULE_NAME, "New oob registered (%s)", oob->prefix);
return 0;
}
int aos_workqueue_create(aos_workqueue_t *workqueue, int pri, int stack_size)
{
kstat_t ret;
cpu_stack_t *stk;
kworkqueue_t *wq;
if (workqueue == NULL) {
return -EINVAL;
}
if (stack_size < sizeof(cpu_stack_t)) {
return -EINVAL;
}
stk = aos_malloc(stack_size);
if (stk == NULL) {
return -ENOMEM;
}
wq = aos_malloc(sizeof(kworkqueue_t));
if (wq == NULL) {
aos_free(stk);
return -ENOMEM;
}
ret = krhino_workqueue_create(wq, "AOS", pri, stk,
stack_size / sizeof(cpu_stack_t));
if (ret != RHINO_SUCCESS) {
aos_free(wq);
aos_free(stk);
ERRNO_MAPPING(ret);
}
workqueue->hdl = wq;
workqueue->stk = stk;
return 0;
}
int aos_work_init(aos_work_t *work, void (*fn)(void *), void *arg, int dly)
{
kstat_t ret;
kwork_t *w;
if (work == NULL) {
return -EINVAL;
}
w = aos_malloc(sizeof(kwork_t));
if (w == NULL) {
return -ENOMEM;
}
ret = krhino_work_init(w, fn, arg, MS2TICK(dly));
if (ret != RHINO_SUCCESS) {
aos_free(w);
ERRNO_MAPPING(ret);
}
work->hdl = w;
return 0;
}
int aos_queue_new(aos_queue_t *queue, void *buf, unsigned int size, int max_msg)
{
kstat_t ret;
kbuf_queue_t *q;
if ((queue == NULL) || (buf == NULL)) {
return -EINVAL;
}
q = aos_malloc(sizeof(kbuf_queue_t));
if (q == NULL) {
return -ENOMEM;
}
ret = krhino_buf_queue_create(q, "AOS", buf, size, max_msg);
if (ret != RHINO_SUCCESS) {
aos_free(q);
ERRNO_MAPPING(ret);
}
queue->hdl = q;
return 0;
}
int aos_sem_new(aos_sem_t *sem, int count)
{
kstat_t ret;
ksem_t *s;
if (sem == NULL) {
return -EINVAL;
}
s = aos_malloc(sizeof(ksem_t));
if (s == NULL) {
return -ENOMEM;
}
ret = krhino_sem_create(s, "AOS", count);
if (ret != RHINO_SUCCESS) {
aos_free(s);
ERRNO_MAPPING(ret);
}
sem->hdl = s;
return 0;
}
int aos_mutex_new(aos_mutex_t *mutex)
{
kstat_t ret;
kmutex_t *m;
if (mutex == NULL) {
return -EINVAL;
}
m = aos_malloc(sizeof(kmutex_t));
if (m == NULL) {
return -ENOMEM;
}
ret = krhino_mutex_create(m, "AOS");
if (ret != RHINO_SUCCESS) {
aos_free(m);
ERRNO_MAPPING(ret);
}
mutex->hdl = m;
return 0;
}
static int at_reset()
{
int ret = 0;
char response[64] = {0};
char *commond = AT_RESET_CMD;
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode");
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at task created: %d, smpr: %d",
(uint32_t)tsk, (uint32_t)&tsk->smpr);
tsk->rsp = response;
tsk->rsp_offset = 0;
tsk->rsp_len = sizeof(response);
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_add_tail(&tsk->next, &at.task_l);
// uart operation should be inside mutex lock
if ((ret = hal_uart_send(&at._uart, (void *)commond,
strlen(commond), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send command failed");
goto end;
}
LOGD(MODULE_NAME, "Sending command %s", commond);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
aos_mutex_unlock(&at._mutex);
if ((ret = aos_sem_wait(&tsk->smpr, AOS_WAIT_FOREVER)) != 0) {
LOGE(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_del(&tsk->next, &at.task_l);
aos_mutex_unlock(&at._mutex);
if (aos_sem_is_valid(&tsk->smpr)) {
aos_sem_free(&tsk->smpr);
}
if (tsk) {
aos_free(tsk);
}
return ret;
}
/**
* Example:
* AT+ENETRAWSEND=<len>
* ><data>
* OK
*
* Send data in 2 stages. These 2 stages must be finished inside
* one mutex lock.
* 1. Send 'fst' string (first stage);
* 2. Receving prompt, usually "<" character;
* 3. Send data (second stage) in 'len' length.
*/
static int at_send_data_2stage(const char *fst, const char *data,
uint32_t len, char *rsp, uint32_t rsplen/*, at_send_t t*/)
{
int ret = 0;
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode");
return -1;
}
if ((ret = at_reset()) != 0){
LOGE(MODULE_NAME, "There is something wrong with atparser and reset fail\n");
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at 2stage task created: %d, smpr: %d",
(uint32_t)tsk, (uint32_t)&tsk->smpr);
tsk->rsp = rsp;
tsk->rsp_offset = 0;
tsk->rsp_len = rsplen;
/* The 2 stages should be inside one mutex lock*/
/* Mutex context begin*/
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
LOGD(MODULE_NAME, "%s: at lock got", __func__);
slist_add_tail(&tsk->next, &at.task_l);
// uart operation should be inside mutex lock
if ((ret = hal_uart_send(&at._uart, (void *)fst,
strlen(fst), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send 2stage prefix failed");
goto end;
}
LOGD(MODULE_NAME, "Sending 2stage prefix %s", fst);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
if ((ret = hal_uart_send(&at._uart, (void *)data,
len, at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send 2stage data failed");
goto end;
}
LOGD(MODULE_NAME, "Sending 2stage data %s", data);
if ((ret = hal_uart_send(&at._uart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0) {
aos_mutex_unlock(&at._mutex);
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
aos_mutex_unlock(&at._mutex);
LOGD(MODULE_NAME, "%s: at lock released", __func__);
/* Mutex context end*/
if ((ret = aos_sem_wait(&tsk->smpr, AOS_WAIT_FOREVER)) != 0) {
LOGE(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
aos_mutex_lock(&at._mutex, AOS_WAIT_FOREVER);
slist_del(&tsk->next, &at.task_l);
aos_mutex_unlock(&at._mutex);
if (aos_sem_is_valid(&tsk->smpr)) aos_sem_free(&tsk->smpr);
if (tsk) aos_free(tsk);
return ret;
}
static void handle_udp_broadcast_data()
{
uint32_t len = 0;
uint32_t remoteport = 0;
int32_t linkid = 0;
int32_t ret = 0;
char reader[16] = {0};
char ipaddr[16] = {0};
char *recvdata = NULL;
/* Eat the "DP_BROADCAST," */
at.read(reader, 13);
if (memcmp(reader, "DP_BROADCAST,", strlen("DP_BROADCAST,")) != 0) {
LOGE(TAG, "%s invalid event format!!!\r\n",
reader[0], reader[1], reader[2], reader[3], reader[4], reader[5]);
return;
}
/* get ip addr */
ret = socket_data_info_get(ipaddr, sizeof(ipaddr), &socket_ip_info_check);
if (ret) {
LOGE(TAG, "Invalid ip addr %s !!!\r\n", ipaddr);
return;
}
LOGD(TAG, "get broadcast form ip addr %s \r\n", ipaddr);
/* get ip port */
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid ip addr %s !!!\r\n", reader);
return;
}
LOGD(TAG, "get broadcast form ip port %s \r\n", reader);
remoteport = atoi(reader);
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, 1, &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid link id 0x%02x !!!\r\n", reader[0]);
return;
}
linkid = reader[0] - '0';
LOGD(TAG, "get udp broadcast linkid %d \r\n", linkid);
/* len */
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid datalen %s !!!\r\n", reader);
return;
}
len = atoi(reader);
if (len > MAX_DATA_LEN) {
LOGE(TAG, "invalid input socket data len %d \r\n", len);
return;
}
/* Prepare socket data */
recvdata = (char *)aos_malloc(len + 1);
if (!recvdata) {
LOGE(TAG, "Error: %s %d out of memory, len is %d. \r\n", __func__, __LINE__, len);
return;
}
at.read(recvdata, len);
recvdata[len] = '\0';
if (strcmp(ipaddr, localipaddr) != 0) {
if (g_netconn_data_input_cb && (g_link[linkid].fd >= 0)) {
if (g_netconn_data_input_cb(g_link[linkid].fd, recvdata, len, ipaddr, remoteport)) {
LOGE(TAG, " %s socket %d get data len %d fail to post to sal, drop it\n",
__func__, g_link[linkid].fd, len);
}
}
} else {
LOGD(TAG, "drop broadcast packet len %d \r\n", len);
}
aos_free(recvdata);
}
static void handle_socket_data()
{
int link_id = 0;
int ret = 0;
uint32_t len = 0;
char reader[16] = {0};
char *recvdata = NULL;
/* Eat the "OCKET," */
at.read(reader, 6);
if (memcmp(reader, "OCKET,", strlen("OCKET,")) != 0) {
LOGE(TAG, "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x invalid event format!!!\r\n",
reader[0], reader[1], reader[2], reader[3], reader[4], reader[5]);
return;
}
memset(reader, 0, sizeof(reader));
ret = socket_data_info_get(reader, 1, &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid link id 0x%02x !!!\r\n", reader[0]);
return;
}
link_id = reader[0] - '0';
memset(reader, 0, sizeof(reader));
/* len */
ret = socket_data_info_get(reader, sizeof(reader), &socket_data_len_check);
if (ret) {
LOGE(TAG, "Invalid datalen %s !!!\r\n", reader);
return;
}
len = atoi(reader);
if (len > MAX_DATA_LEN) {
LOGE(TAG, "invalid input socket data len %d \r\n", len);
return;
}
/* Prepare socket data */
recvdata = (char *)aos_malloc(len + 1);
if (!recvdata) {
LOGE(TAG, "Error: %s %d out of memory, len is %d. \r\n", __func__, __LINE__, len);
return;
}
at.read(recvdata, len);
recvdata[len] = '\0';
LOGD(TAG, "The socket data is %s", recvdata);
if (g_netconn_data_input_cb && (g_link[link_id].fd >= 0)) {
/* TODO get recv data src ip and port*/
if (g_netconn_data_input_cb(g_link[link_id].fd, recvdata, len, NULL, 0)) {
LOGE(TAG, " %s socket %d get data len %d fail to post to sal, drop it\n",
__func__, g_link[link_id].fd, len);
}
}
LOGD(TAG, "%s socket data on link %d with length %d posted to sal\n",
__func__, link_id, len);
aos_free(recvdata);
}
static void at_worker(void *arg)
{
int offset = 0;
int ret = 0;
int at_task_empty = 0;
int at_task_reponse_begin = 0;
int memcpy_size = 0;
int rsp_prefix_len = 0;
int rsp_success_postfix_len = 0;
int rsp_fail_postfix_len = 0;
char c;
at_task_t *tsk;
char * buf = NULL;
char * rsp_prefix = NULL;
char * rsp_success_postfix = NULL;
char * rsp_fail_postfix = NULL;
oob_t * oob = NULL;
LOGD(MODULE_NAME, "at_work started.");
buf = aos_malloc(RECV_BUFFER_SIZE);
if (NULL == buf) {
LOGE(MODULE_NAME, "AT worker fail to malloc ,task exist \r\n");
aos_task_exit(0);
return;
}
memset(buf, 0, RECV_BUFFER_SIZE);
while (true) {
// read from uart and store buf
if (at._mode != ASYN) {
aos_msleep(1);
}
ret = at_getc(&c);
if (ret != 0) {
continue;
}
if (offset + 1 >= RECV_BUFFER_SIZE) {
LOGE(MODULE_NAME, "Fatal error, no one is handling AT uart");
continue;
}
buf[offset++] = c;
buf[offset] = 0;
for (int k = 0; k < at._oobs_num; k++) {
oob = &(at._oobs[k]);
if (oob->reallen > 0 ||
(offset >= strlen(oob->prefix) &&
memcmp(oob->prefix, buf + offset - strlen(oob->prefix),
strlen(oob->prefix)) == 0)) {
LOGD(MODULE_NAME, "AT! %s\r\n", oob->prefix);
if (oob->postfix == NULL) {
oob->cb(oob->arg, NULL, 0);
memset(buf + offset - strlen(oob->prefix), 0, offset);
offset -= strlen(oob->prefix);
} else {
if (oob->reallen == 0) {
memset(oob->oobinputdata, 0, oob->maxlen);
memcpy(oob->oobinputdata, oob->prefix,
strlen(oob->prefix) - 1);
oob->reallen += strlen(oob->prefix) - 1;
}
if (oob->reallen < oob->maxlen) {
oob->oobinputdata[oob->reallen] = c;
oob->reallen++;
if ((oob->reallen >=
strlen(oob->prefix) + strlen(oob->postfix)) &&
(strncmp(oob->oobinputdata + oob->reallen -
strlen(oob->postfix),
oob->postfix,
strlen(oob->postfix)) == 0)) {
/*recv postfix*/
oob->cb(oob->arg, oob->oobinputdata, oob->reallen);
memset(oob->oobinputdata, 0, oob->reallen);
oob->reallen = 0;
memset(buf, 0, offset);
offset = 0;
}
} else {
LOGE(MODULE_NAME,
"invalid oob %s input , for oversize %s \r\n",
oob->prefix, oob->oobinputdata);
memset(oob->oobinputdata, 0, oob->reallen);
oob->reallen = 0;
memset(buf, 0, offset);
offset = 0;
}
/*oob data maybe more than buf size */
if (offset > (RECV_BUFFER_SIZE - 2)) {
memset(buf, 0, offset);
offset = 0;
}
}
continue;
}
}
aos_mutex_lock(&at.task_mutex, AOS_WAIT_FOREVER);
at_task_empty = slist_empty(&at.task_l);
if (!at_task_empty) {
tsk = slist_first_entry(&at.task_l, at_task_t, next);
}
aos_mutex_unlock(&at.task_mutex);
// if no task, continue recv
if (at_task_empty) {
LOGD(MODULE_NAME, "No task in queue");
goto check_buffer;
}
if (NULL != tsk->rsp_prefix && 0 != tsk->rsp_prefix_len) {
rsp_prefix = tsk->rsp_prefix;
rsp_prefix_len = tsk->rsp_prefix_len;
} else {
rsp_prefix = at._default_recv_prefix;
rsp_prefix_len = at._recv_prefix_len;
}
if (NULL != tsk->rsp_success_postfix &&
0 != tsk->rsp_success_postfix_len) {
rsp_success_postfix = tsk->rsp_success_postfix;
rsp_success_postfix_len = tsk->rsp_success_postfix_len;
} else {
rsp_success_postfix = at._default_recv_success_postfix;
rsp_success_postfix_len = at._recv_success_postfix_len;
}
if (NULL != tsk->rsp_fail_postfix && 0 != tsk->rsp_fail_postfix_len) {
rsp_fail_postfix = tsk->rsp_fail_postfix;
rsp_fail_postfix_len = tsk->rsp_fail_postfix_len;
} else {
rsp_fail_postfix = at._default_recv_fail_postfix;
rsp_fail_postfix_len = at._recv_fail_postfix_len;
}
if (offset >= rsp_prefix_len && at_task_reponse_begin == 0 &&
(strncmp(buf + offset - rsp_prefix_len, rsp_prefix,
rsp_prefix_len) == 0)) {
at_task_reponse_begin = 1;
}
if (at_task_reponse_begin == 1) {
if (tsk->rsp_offset < tsk->rsp_len) {
tsk->rsp[tsk->rsp_offset] = c;
tsk->rsp_offset++;
if ((tsk->rsp_offset >= rsp_success_postfix_len &&
strncmp(
tsk->rsp + tsk->rsp_offset - rsp_success_postfix_len,
rsp_success_postfix, rsp_success_postfix_len) == 0) ||
(tsk->rsp_offset >= rsp_fail_postfix_len &&
strncmp(tsk->rsp + tsk->rsp_offset - rsp_fail_postfix_len,
rsp_fail_postfix, rsp_fail_postfix_len) == 0)) {
aos_sem_signal(&tsk->smpr);
at_task_reponse_begin = 0;
memset(buf, 0, offset);
offset = 0;
}
} else {
memset(tsk->rsp, 0, tsk->rsp_len);
strcpy(tsk->rsp, rsp_fail_postfix);
aos_sem_signal(&tsk->smpr);
at_task_reponse_begin = 0;
memset(buf, 0, offset);
offset = 0;
}
}
check_buffer:
// in case buffer is full
if (offset > (RECV_BUFFER_SIZE - 2)) {
printf("buffer full \r\n");
memcpy_size = rsp_prefix_len > rsp_success_postfix_len
? rsp_prefix_len
: rsp_success_postfix_len;
memcpy_size = memcpy_size > rsp_fail_postfix_len
? memcpy_size
: rsp_fail_postfix_len;
memcpy(buf, buf + offset - memcpy_size, memcpy_size);
memset(buf + memcpy_size, 0, offset - memcpy_size);
offset = memcpy_size;
}
}
return;
}
/**
* Example:
* AT+ENETRAWSEND=<len>
* ><data>
* OK
*
* Send data in 2 stages. These 2 stages must be finished inside
* one mutex lock.
* 1. Send 'fst' string (first stage);
* 2. Receving prompt, usually ">" character;
* 3. Send data (second stage) in 'len' length.
*/
static int at_send_data_2stage(const char *fst, const char *data, uint32_t len,
char *rsp, uint32_t rsplen)
{
int ret = 0;
if (inited == 0) {
LOGE(MODULE_NAME, "at have not init yet\r\n");
return -1;
}
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode \r\n");
return -1;
}
if (NULL == fst) {
LOGE(MODULE_NAME, "%s invalid input \r\n", __FUNCTION__);
return -1;
}
if (NULL == rsp || 0 == rsplen) {
LOGE(MODULE_NAME, "%s invalid input \r\n", __FUNCTION__);
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
memset(tsk, 0, sizeof(at_task_t));
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at task created: %d, smpr: %d", (uint32_t)tsk,
(uint32_t)&tsk->smpr);
tsk->command = (char *)fst;
tsk->rsp = rsp;
tsk->rsp_len = rsplen;
aos_mutex_lock(&at.at_uart_send_mutex, AOS_WAIT_FOREVER);
at_worker_task_add(tsk);
// uart operation should be inside mutex lock
#ifdef HDLC_UART
if ((ret = hdlc_uart_send(&hdlc_encode_ctx, at._pstuart, (void *)fst,
strlen(fst), at._timeout, true)) != 0)
#else
if ((ret = hal_uart_send(at._pstuart, (void *)fst, strlen(fst),
at._timeout)) != 0)
#endif
{
LOGE(MODULE_NAME, "uart send command failed");
goto end;
}
LOGD(MODULE_NAME, "Sending command %s", fst);
#ifdef HDLC_UART
if ((ret = hdlc_uart_send(
&hdlc_encode_ctx, at._pstuart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout, false)) != 0)
#else
if ((ret = hal_uart_send(at._pstuart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0)
#endif
{
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
#ifdef AT_PARSER_DELAY_FLAG
aos_msleep(20);
#endif
#ifdef HDLC_UART
if ((ret = hdlc_uart_send(&hdlc_encode_ctx, at._pstuart, (void *)data, len,
at._timeout, true)) != 0)
#else
if ((ret = hal_uart_send(at._pstuart, (void *)data, len, at._timeout)) != 0)
#endif
{
LOGE(MODULE_NAME, "uart send 2stage data failed");
goto end;
}
LOGD(MODULE_NAME, "Sending 2stage data %s", data);
if ((ret = aos_sem_wait(&tsk->smpr, TASK_DEFAULT_WAIT_TIME)) != 0) {
LOGE(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
at_worker_task_del(tsk);
aos_mutex_unlock(&at.at_uart_send_mutex);
return ret;
}
static int at_send_raw_self_define_respone_formate_internal(
const char *command, uint32_t cmdlen, char *rsp, uint32_t rsplen,
char *rsp_prefix, char *rsp_success_postfix, char *rsp_fail_postfix)
{
int ret = 0;
if (inited == 0) {
LOGE(MODULE_NAME, "at have not init yet\r\n");
return -1;
}
if (at._mode != ASYN) {
LOGE(MODULE_NAME, "Operation not supported in non asyn mode \r\n");
return -1;
}
if (NULL == command) {
LOGE(MODULE_NAME, "%s invalid input \r\n", __FUNCTION__);
return -1;
}
if (NULL == rsp || 0 == rsplen) {
LOGE(MODULE_NAME, "%s invalid input \r\n", __FUNCTION__);
return -1;
}
at_task_t *tsk = (at_task_t *)aos_malloc(sizeof(at_task_t));
if (NULL == tsk) {
LOGE(MODULE_NAME, "tsk buffer allocating failed");
return -1;
}
memset(tsk, 0, sizeof(at_task_t));
if ((ret = aos_sem_new(&tsk->smpr, 0)) != 0) {
LOGE(MODULE_NAME, "failed to allocate semaphore");
goto end;
}
LOGD(MODULE_NAME, "at task created: %d, smpr: %d", (uint32_t)tsk,
(uint32_t)&tsk->smpr);
if (NULL != rsp_prefix) {
tsk->rsp_prefix = rsp_prefix;
tsk->rsp_prefix_len = strlen(rsp_prefix);
}
if (NULL != rsp_success_postfix) {
tsk->rsp_success_postfix = rsp_success_postfix;
tsk->rsp_success_postfix_len = strlen(rsp_success_postfix);
}
if (NULL != rsp_fail_postfix) {
tsk->rsp_fail_postfix = rsp_fail_postfix;
tsk->rsp_fail_postfix_len = strlen(rsp_fail_postfix);
}
tsk->command = (char *)command;
tsk->rsp = rsp;
tsk->rsp_len = rsplen;
at_worker_task_add(tsk);
// uart operation should be inside mutex lock
#ifdef HDLC_UART
if ((ret = hdlc_uart_send(&hdlc_encode_ctx, at._pstuart, (void *)command,
cmdlen, at._timeout, true)) != 0)
#else
if ((ret = hal_uart_send(at._pstuart, (void *)command, cmdlen,
at._timeout)) != 0)
#endif
{
LOGE(MODULE_NAME, "uart send command failed");
goto end;
}
LOGD(MODULE_NAME, "Sending command %s", command);
#ifdef HDLC_UART
if ((ret = hdlc_uart_send(
&hdlc_encode_ctx, at._pstuart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout, false)) != 0)
#else
if ((ret = hal_uart_send(at._pstuart, (void *)at._send_delimiter,
strlen(at._send_delimiter), at._timeout)) != 0)
#endif
{
LOGE(MODULE_NAME, "uart send delimiter failed");
goto end;
}
LOGD(MODULE_NAME, "Sending delimiter %s", at._send_delimiter);
if ((ret = aos_sem_wait(&tsk->smpr, TASK_DEFAULT_WAIT_TIME)) != 0) {
LOGD(MODULE_NAME, "sem_wait failed");
goto end;
}
LOGD(MODULE_NAME, "sem_wait succeed.");
end:
at_worker_task_del(tsk);
return ret;
}
/**
* \brief Initialize usart interface
*/
int32_t usart_os_init(struct usart_os_descriptor *const descr, void *const hw, uint8_t *rx_buffer,
uint16_t rx_buffer_length, void *const func)
{
int32_t rc;
ASSERT(descr && hw && rx_buffer && rx_buffer_length);
if (ERR_NONE != ringbuffer_init(&descr->rx, rx_buffer, rx_buffer_length)) {
return ERR_INVALID_ARG;
}
descr->kbuf_data = aos_malloc(MAX_BUF_UART_BYTES);
if (descr->kbuf_data == NULL) {
return -1;
}
memset(descr->kbuf_data, 0, MAX_BUF_UART_BYTES);
rc = krhino_buf_queue_create(&descr->kbuf, "buf_queue_uart", descr->kbuf_data, MAX_BUF_UART_BYTES, 1);
rc = sem_init(&descr->rx_sem, 0);
if (rc < 0) {
return rc;
}
rc = sem_init(&descr->tx_sem, 0);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
return rc;
}
rc = aos_mutex_new(&descr->rx_mutex);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
sem_deinit(&descr->tx_sem);
return rc;
}
rc = aos_mutex_new(&descr->tx_mutex);
if (rc < 0) {
sem_deinit(&descr->rx_sem);
sem_deinit(&descr->tx_sem);
aos_mutex_free(&descr->rx_mutex);
return rc;
}
descr->sync_device.hw = hw;
rc = _usart_async_init(&descr->device, hw);
if (rc) {
sem_deinit(&descr->tx_sem);
sem_deinit(&descr->rx_sem);
aos_mutex_free(&descr->rx_mutex);
aos_mutex_free(&descr->tx_mutex);
return rc;
}
descr->rx_buffer = NULL;
descr->rx_size = 0;
descr->rx_length = 0;
descr->io.read = usart_async_read;
descr->io.write = usart_sync_write;
descr->device.usart_cb.tx_byte_sent = usart_os_process_byte_sent;
descr->device.usart_cb.rx_done_cb = usart_fill_rx_buffer;
descr->device.usart_cb.tx_done_cb = usart_os_transmission_complete;
descr->device.usart_cb.error_cb = usart_os_error;
_usart_async_set_irq_state(&descr->device, USART_ASYNC_RX_DONE, true);
_usart_async_set_irq_state(&descr->device, USART_ASYNC_ERROR, true);
return ERR_NONE;
}
/*
* initialization parameter: mqtt_params
*/
int mqtt_client_example(void)
{
int rc = 0;
iotx_conn_info_pt pconn_info;
iotx_mqtt_param_t mqtt_params;
if (msg_buf != NULL) {
return rc;
}
if (NULL == (msg_buf = (char *)aos_malloc(MSG_LEN_MAX))) {
LOG("not enough memory");
rc = -1;
release_buff();
return rc;
}
if (NULL == (msg_readbuf = (char *)aos_malloc(MSG_LEN_MAX))) {
LOG("not enough memory");
rc = -1;
release_buff();
return rc;
}
/* Device AUTH */
if (0 != IOT_SetupConnInfo(PRODUCT_KEY, DEVICE_NAME, DEVICE_SECRET, (void **)&pconn_info)) {
LOG("AUTH request failed!");
rc = -1;
release_buff();
return rc;
}
/* Initialize MQTT parameter */
memset(&mqtt_params, 0x0, sizeof(mqtt_params));
mqtt_params.port = pconn_info->port;
mqtt_params.host = pconn_info->host_name;
mqtt_params.client_id = pconn_info->client_id;
mqtt_params.username = pconn_info->username;
mqtt_params.password = pconn_info->password;
mqtt_params.pub_key = pconn_info->pub_key;
mqtt_params.request_timeout_ms = 2000;
mqtt_params.clean_session = 0;
mqtt_params.keepalive_interval_ms = 60000;
mqtt_params.pread_buf = msg_readbuf;
mqtt_params.read_buf_size = MSG_LEN_MAX;
mqtt_params.pwrite_buf = msg_buf;
mqtt_params.write_buf_size = MSG_LEN_MAX;
mqtt_params.handle_event.h_fp = event_handle_mqtt;
mqtt_params.handle_event.pcontext = NULL;
/* Construct a MQTT client with specify parameter */
gpclient = IOT_MQTT_Construct(&mqtt_params);
if (NULL == gpclient) {
LOG("MQTT construct failed");
rc = -1;
release_buff();
//aos_unregister_event_filter(EV_SYS, mqtt_service_event, gpclient);
} else{
aos_register_event_filter(EV_SYS, mqtt_service_event, gpclient);
}
return rc;
}
