chenjintao
3e463f57b6
Configure the default WSS endpoint and ISRG Root X2 trust anchor, preserve device authentication, enforce TLS and WebSocket handshake validation, and handle partial I/O and connection cleanup. Add host tests, server probes, package verification and integration documentation. Backend 443 /ws still returns HTTP 404; on-device validation remains pending.
1359 lines
30 KiB
C
1359 lines
30 KiB
C
#include <string.h>
|
|
#include <stdint.h>
|
|
#include "hal_api.h"
|
|
#include <stdio.h>
|
|
#include "ql_type.h"
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
|
|
#include <stdint.h>
|
|
#include "ql_type.h"
|
|
#include "ql_power.h"
|
|
#include "ql_rtos.h"
|
|
#include "ql_application.h"
|
|
#include "ql_audio.h"
|
|
#include "ql_gpio.h"
|
|
#include "sockets.h"
|
|
#include "ql_uart.h"
|
|
#include "ql_func.h"
|
|
#include "netdb.h"
|
|
#include "ql_sim.h"
|
|
#include "ql_dev.h"
|
|
#include "ql_wtd.h"
|
|
#include "ql_fs.h"
|
|
#include "ql_fota.h"
|
|
#include "ql_sim.h"
|
|
#include "ql_ping.h"
|
|
#include "ql_nw.h"
|
|
#include "ql_atcmd.h"
|
|
#include "ql_uart.h"
|
|
#include "hal_api.h"
|
|
#include "build_macro.h"
|
|
#include "ql_rtc.h"
|
|
#include "talkingq_wss.h"
|
|
#include "ql_cell_locator.h"
|
|
|
|
|
|
int hal_os_init()
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
void* hal_os_malloc(uint32_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
/**
|
|
* @brief 释放内存
|
|
*
|
|
* @param[in] ptr 内存指针
|
|
*/
|
|
void hal_os_free(void *ptr)
|
|
{
|
|
if(ptr==NULL)return;
|
|
free(ptr);
|
|
}
|
|
|
|
|
|
void *hal_os_realloc(void *old, uint32_t size)
|
|
{
|
|
return realloc(old,size);
|
|
}
|
|
|
|
int hal_os_get_localtime(char *buf)
|
|
{
|
|
time_t _time = 0x00000001;
|
|
struct tm now_time;
|
|
_time = time(NULL);
|
|
ql_localtime_r(&_time,&now_time);
|
|
buf[0] = now_time.tm_year+1900-2000;
|
|
buf[1] = now_time.tm_mon+1;//0-11 0为1月
|
|
buf[2] = now_time.tm_mday;
|
|
buf[3] = now_time.tm_hour;
|
|
buf[4] = now_time.tm_min;
|
|
buf[5] = now_time.tm_sec;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int hal_os_set_localtime(char *buf)
|
|
{
|
|
ql_rtc_time_t rtm;
|
|
|
|
rtm.tm_sec = buf[5];
|
|
rtm.tm_min = buf[4];
|
|
rtm.tm_hour = buf[3];
|
|
rtm.tm_mday = buf[2];
|
|
rtm.tm_mon = buf[1];
|
|
rtm.tm_year = buf[0]+2000;
|
|
|
|
return ql_rtc_set_time(&rtm);
|
|
}
|
|
|
|
|
|
int hal_os_get_boottime(char *buf)
|
|
{
|
|
|
|
return -1;
|
|
}
|
|
|
|
int hal_os_set_time(char *buf)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int hal_os_set_time_sec(uint32_t sec)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
uint32_t hal_os_get_rand()
|
|
{
|
|
return ql_geu_random_number();
|
|
}
|
|
|
|
int hal_os_set_timezone(int zone)
|
|
{
|
|
//TODO
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_timezone(int *zone)
|
|
{
|
|
//TODO
|
|
*zone = 8;
|
|
return 0;
|
|
}
|
|
|
|
uint64_t hal_os_up_time_ms(void)
|
|
{
|
|
return ql_rtos_get_systicks()*5;
|
|
}
|
|
|
|
uint64_t hal_os_timestamp_ms(void)
|
|
{
|
|
struct timeval tv = {0};
|
|
gettimeofday(&tv, NULL);
|
|
return tv.tv_sec*1000 + tv.tv_usec/1000;
|
|
}
|
|
|
|
int hal_os_log(char *tag, int level, const char *buf, int len)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void hal_os_task_sleep_ms(uint32_t ms)
|
|
{
|
|
ql_rtos_task_sleep_ms(ms);
|
|
}
|
|
|
|
void hal_os_delay_us(uint32_t us)
|
|
{
|
|
ql_rtos_delay_us(us);
|
|
}
|
|
|
|
int hal_os_get_hal_ver(char *buf)
|
|
{
|
|
strcpy(buf,"V1");
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_build_model(char *buf)
|
|
{
|
|
//strcpy(buf,CUSTOM_APP_BUILD_MODEL);
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_build_ver(char *buf)
|
|
{
|
|
// sprintf(buf,"%s-%s",CUSTOM_APP_BUILD_VER,CUSTOM_APP_BUILD_TIME);
|
|
sprintf(buf,"%s",CUSTOM_APP_BUILD_VER);
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_build_rev(char *buf)
|
|
{
|
|
//strcpy(buf,CUSTOM_APP_BUILD_REV);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_build_time(char *buf)
|
|
{
|
|
strcpy(buf,CUSTOM_APP_BUILD_TIME);
|
|
return 0;
|
|
}
|
|
|
|
|
|
void *hal_os_semaphore_create(void)
|
|
{
|
|
ql_sem_t *sem = hal_os_malloc(sizeof(ql_sem_t));
|
|
QlOSStatus err = 0;
|
|
|
|
err = ql_rtos_semaphore_create(sem,0);
|
|
if(err != 0){
|
|
hal_os_free(sem);
|
|
return NULL;
|
|
}
|
|
|
|
return sem;
|
|
}
|
|
|
|
int hal_os_semaphore_destroy(void **sem)
|
|
{
|
|
if(sem==NULL)return -1;
|
|
if(*sem==NULL)return -1;
|
|
void **mysem = *sem;
|
|
int ret = ql_rtos_semaphore_delete(*mysem);
|
|
hal_os_free(*sem);
|
|
*sem = NULL;
|
|
return ret;
|
|
}
|
|
|
|
int hal_os_semaphore_get_cnt(void *sem, uint32_t *count)
|
|
{
|
|
if(!sem)return-1;
|
|
void **mysem = sem;
|
|
if(!mysem)return-1;
|
|
uint32 mycount=0;
|
|
int ret = ql_rtos_semaphore_get_cnt(*mysem,&mycount);
|
|
*count=mycount;
|
|
return ret;
|
|
}
|
|
|
|
int hal_os_semaphore_post(void *sem)
|
|
{
|
|
if(!sem)return-1;
|
|
void **mysem = sem;
|
|
if(!mysem)return-1;
|
|
return ql_rtos_semaphore_release(*mysem);
|
|
}
|
|
|
|
int hal_os_semaphore_post_once(void *sem)
|
|
{
|
|
if(!sem)return-1;
|
|
void **mysem = sem;
|
|
if(!mysem)return-1;
|
|
|
|
uint32_t count=0;
|
|
int ret = hal_os_semaphore_get_cnt(sem,&count);
|
|
|
|
if(ret==0 && count>=1){
|
|
return 1;
|
|
}
|
|
|
|
return ql_rtos_semaphore_release(*mysem);
|
|
}
|
|
|
|
int hal_os_semaphore_wait(void *sem, uint32_t timeout_ms)
|
|
{
|
|
if(timeout_ms == WAIT_INFINITE) timeout_ms = 0xFFFFFFFF;
|
|
if(!sem)return-1;
|
|
void **mysem = sem;
|
|
if(!mysem)return-1;
|
|
return ql_rtos_semaphore_wait(*mysem,timeout_ms);
|
|
}
|
|
|
|
typedef struct st_ec_task
|
|
{
|
|
ql_task_t taskRef;
|
|
int status;
|
|
}ec_task_t;
|
|
|
|
void *hal_os_task_create(char *name, uint8_t priority, uint32_t stackSize, void (*work_cb)(void *), void *arg)
|
|
{
|
|
uint8_t priority_osi = 100;
|
|
QlOSStatus err = 0;
|
|
ec_task_t *mytsk = hal_os_malloc(sizeof(ec_task_t));
|
|
|
|
|
|
err = ql_rtos_task_create (&mytsk->taskRef, stackSize, priority_osi, name, work_cb, arg, 3);
|
|
if(err != 0){
|
|
hal_os_free(mytsk);
|
|
return NULL;
|
|
}
|
|
mytsk->status = 0;
|
|
return mytsk;
|
|
}
|
|
|
|
int hal_os_task_destroy(void **thread)
|
|
{
|
|
ql_task_t task_del;
|
|
int ret = 0;
|
|
if(thread!=NULL){
|
|
ec_task_t *mytsk = (ec_task_t *)*thread;
|
|
if(mytsk!=NULL){
|
|
task_del = mytsk->taskRef;
|
|
hal_os_free(mytsk);
|
|
mytsk=NULL;
|
|
ql_rtos_task_delete(task_del);
|
|
}else{
|
|
ret = ql_rtos_task_delete(NULL);
|
|
}
|
|
return ret;
|
|
}else{
|
|
ret = ql_rtos_task_delete(NULL);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
typedef struct st_ec_timer
|
|
{
|
|
ql_timer_t timer;
|
|
void (*callBackRoutine)(u32);
|
|
uint32_t timerMs;
|
|
uint8_t timer_type;
|
|
}ec_timer_t;
|
|
|
|
|
|
void *hal_os_timer_create(void (*timer_cb)(void *), void *arg, uint8_t timer_type)
|
|
{
|
|
ec_timer_t *timer = hal_os_malloc(sizeof(ec_timer_t));
|
|
timer->callBackRoutine = timer_cb;
|
|
timer->timer_type = timer_type;
|
|
int err = ql_rtos_timer_create(&timer->timer);
|
|
if(err != 0){
|
|
hal_os_free(timer);
|
|
return NULL;
|
|
}
|
|
|
|
return timer;
|
|
}
|
|
|
|
|
|
int hal_os_timer_start(void *timer, uint32_t timeMs)
|
|
{
|
|
if(!timer)return-1;
|
|
ec_timer_t *timer_t = timer;
|
|
|
|
return ql_rtos_timer_start(timer_t->timer,timeMs,timer_t->timer_type,timer_t->callBackRoutine,0);
|
|
}
|
|
|
|
|
|
int hal_os_timer_stop(void *timer)
|
|
{
|
|
if(!timer)return-1;
|
|
ec_timer_t *timer_t = timer;
|
|
|
|
return ql_rtos_timer_stop(timer_t->timer);
|
|
}
|
|
|
|
|
|
int hal_os_timer_destroy(void **timer){
|
|
int ret=-1;
|
|
if(timer==NULL)return -1;
|
|
if(*timer!=NULL){
|
|
ec_timer_t *timer_t = *timer;
|
|
ret = ql_rtos_timer_delete(timer_t->timer);
|
|
hal_os_free(*timer);
|
|
}
|
|
*timer = NULL;
|
|
return ret;
|
|
}
|
|
|
|
|
|
void *hal_os_mutex_create(void)
|
|
{
|
|
ql_mutex_t *mutex = hal_os_malloc(sizeof(ql_mutex_t));
|
|
QlOSStatus err = 0;
|
|
|
|
err = ql_rtos_mutex_create(mutex);
|
|
if(err != 0){
|
|
hal_os_free(mutex);
|
|
return NULL;
|
|
}
|
|
|
|
return mutex;
|
|
}
|
|
|
|
int hal_os_mutex_destroy(void **mutex)
|
|
{
|
|
if(mutex==NULL)return -1;
|
|
if(*mutex == NULL)return -1;
|
|
void **mymutex = *mutex;
|
|
int ret = ql_rtos_mutex_delete(*mymutex);
|
|
hal_os_free(*mutex);
|
|
*mutex=NULL;
|
|
return ret;
|
|
}
|
|
|
|
int hal_os_mutex_lock(void *mutex)
|
|
{
|
|
if(!mutex)return-1;
|
|
void **mymutex = mutex;
|
|
if(!*mymutex)return-1;
|
|
return ql_rtos_mutex_lock(*mymutex,10000);
|
|
}
|
|
|
|
int hal_os_mutex_try_lock(void *mutex)
|
|
{
|
|
if(!mutex)return-1;
|
|
void **mymutex = mutex;
|
|
if(!*mymutex)return-1;
|
|
return ql_rtos_mutex_try_lock(*mymutex);
|
|
}
|
|
|
|
int hal_os_mutex_unlock(void *mutex)
|
|
{
|
|
if(!mutex)return-1;
|
|
void **mymutex = mutex;
|
|
if(!*mymutex)return-1;
|
|
return ql_rtos_mutex_unlock(*mymutex);
|
|
}
|
|
|
|
void *hal_os_queue_create(uint16_t cnt, uint16_t size)
|
|
{
|
|
ql_queue_t *queue = hal_os_malloc(sizeof(ql_queue_t));
|
|
QlOSStatus err = 0;
|
|
|
|
err = ql_rtos_queue_create(queue,size,cnt);
|
|
if(err != 0){
|
|
hal_os_free(queue);
|
|
return NULL;
|
|
}
|
|
|
|
return queue;
|
|
}
|
|
|
|
|
|
int hal_os_queue_send(void *queue, void *buf, uint16_t buf_len, uint32_t timeout)
|
|
{
|
|
if(!queue)return-1;
|
|
void **myqueue = queue;
|
|
if(!*myqueue)return-1;
|
|
if(timeout == WAIT_INFINITE) timeout = 0xFFFFFFFF;
|
|
return ql_rtos_queue_release(*myqueue,buf_len,buf,timeout);
|
|
}
|
|
|
|
|
|
int hal_os_queue_recv(void *queue, void *buf, uint16_t buf_len, uint32_t timeout)
|
|
{
|
|
if(!queue)return-1;
|
|
void **myqueue = queue;
|
|
if(!*myqueue)return-1;
|
|
if(timeout == WAIT_INFINITE) timeout = 0xFFFFFFFF;
|
|
return ql_rtos_queue_wait(*myqueue,buf,buf_len,timeout);
|
|
}
|
|
|
|
int hal_os_queue_get_cnt(void *queue)
|
|
{
|
|
if(!queue)return-1;
|
|
void **myqueue = queue;
|
|
if(!*myqueue)return-1;
|
|
uint32 cnt;
|
|
if(0== ql_rtos_queue_get_cnt(*myqueue,&cnt)){
|
|
return cnt;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
int hal_os_queue_delete(void** queue)
|
|
{
|
|
if(queue==NULL)return -1;
|
|
if(*queue==NULL)return -1;
|
|
void **myqueue = *queue;
|
|
int ret = ql_rtos_queue_delete(*myqueue);
|
|
hal_os_free(*queue);
|
|
*queue=NULL;
|
|
return ret;
|
|
}
|
|
|
|
int hal_os_feed_dog()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int hal_os_reboot(char mode)
|
|
{
|
|
ql_power_reset();
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int rb_get_space_free(struct ringbuffer *rb)
|
|
{
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
if (rb->end >= rb->start) {
|
|
return rb->length - (rb->end - rb->start)-1;
|
|
} else {
|
|
return rb->start - rb->end-1;
|
|
}
|
|
}
|
|
|
|
int rb_get_space_used(struct ringbuffer *rb)
|
|
{
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
if (rb->end >= rb->start) {
|
|
return rb->end - rb->start;
|
|
} else {
|
|
return rb->length - (rb->start - rb->end);
|
|
}
|
|
}
|
|
|
|
void *hal_os_rb_create(int len)
|
|
{
|
|
struct ringbuffer *rb = hal_os_malloc(sizeof(struct ringbuffer));
|
|
if (!rb) {
|
|
RLOGE("malloc ringbuffer failed!\n");
|
|
return NULL;
|
|
}
|
|
rb->length = len + 1;
|
|
rb->start = 0;
|
|
rb->end = 0;
|
|
rb->buffer = hal_os_malloc(rb->length);
|
|
if (!rb->buffer) {
|
|
RLOGE("malloc rb->buffer failed!\n");
|
|
hal_os_free(rb);
|
|
return NULL;
|
|
}
|
|
//rb->mutex = hal_os_mutex_create();
|
|
rb->mutex = NULL;
|
|
return rb;
|
|
}
|
|
|
|
int hal_os_rb_destroy(void *rbx)
|
|
{
|
|
struct ringbuffer *rb = (struct ringbuffer *)rbx;
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
|
|
if(rb->mutex){
|
|
hal_os_mutex_destroy(&rb->mutex);
|
|
}
|
|
|
|
hal_os_free(rb->buffer);
|
|
hal_os_free(rb);
|
|
return 0;
|
|
}
|
|
|
|
static void *rb_end_ptr(struct ringbuffer *rb)
|
|
{
|
|
return (void *)((char *)rb->buffer + rb->end);
|
|
}
|
|
|
|
static void *rb_start_ptr(struct ringbuffer *rb)
|
|
{
|
|
return (void *)((char *)rb->buffer + rb->start);
|
|
}
|
|
|
|
int hal_os_rb_clean(void*rbx)
|
|
{
|
|
struct ringbuffer *rb = (struct ringbuffer *)rbx;
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
|
|
hal_os_mutex_lock(rb->mutex);
|
|
rb->start = 0;
|
|
rb->end = 0;
|
|
memset(rb->buffer,0,rb->length);
|
|
hal_os_mutex_unlock(rb->mutex);
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_rb_write(void *rbx, const void *buf, int len, uint32_t timeout)
|
|
{
|
|
struct ringbuffer *rb = (struct ringbuffer *)rbx;
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
|
|
uint64_t start_ms = hal_os_up_time_ms();
|
|
|
|
if(len==0){
|
|
return 0;
|
|
}
|
|
|
|
while (timeout>0)
|
|
{
|
|
int left = rb_get_space_free(rb);
|
|
if (len > left) {
|
|
if(hal_os_up_time_ms()-start_ms>timeout){
|
|
RLOGE("Not enough space write: %zu request, %zu available\n", len, left);
|
|
return -1;
|
|
}else{
|
|
hal_os_task_sleep_ms(2);
|
|
}
|
|
}else{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//hal_os_mutex_lock(rb->mutex);
|
|
//ql_rtos_enter_critical();
|
|
if ((rb->length - rb->end) < len) {
|
|
int half_tail = rb->length - rb->end;
|
|
memcpy(rb_end_ptr(rb), (unsigned char*)buf, half_tail);
|
|
rb->end = (rb->end + half_tail) % rb->length;
|
|
|
|
int half_head = len - half_tail;
|
|
memcpy(rb_end_ptr(rb), (unsigned char*)buf+half_tail, half_head);
|
|
rb->end = (rb->end + half_head) % rb->length;
|
|
} else {
|
|
memcpy(rb_end_ptr(rb), buf, len);
|
|
rb->end = (rb->end + len) % rb->length;
|
|
}
|
|
//ql_rtos_exit_critical();
|
|
// hal_os_mutex_unlock(rb->mutex);
|
|
|
|
return len;
|
|
}
|
|
|
|
#define MIN(a, b) ((a) > (b) ? (b) : (a))
|
|
|
|
|
|
int hal_os_rb_read(void*rbx, void *buf, int len, uint32_t timeout)
|
|
{
|
|
struct ringbuffer *rb = (struct ringbuffer *)rbx;
|
|
if (!rb) {
|
|
return -1;
|
|
}
|
|
|
|
uint32_t start_ms = hal_os_up_time_ms();
|
|
while (timeout>0)
|
|
{
|
|
int left = rb_get_space_used(rb);
|
|
if (len > left) {
|
|
if(hal_os_up_time_ms()-start_ms>timeout){
|
|
RLOGE("Not enough space read: %zu request, %zu available\n", len, left);
|
|
return -1;
|
|
}else{
|
|
hal_os_task_sleep_ms(2);
|
|
}
|
|
}else{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// hal_os_mutex_lock(rb->mutex);
|
|
//ql_rtos_enter_critical();
|
|
int rlen = MIN(len, rb_get_space_used(rb));
|
|
|
|
if ((rb->length - rb->start) < rlen) {
|
|
int half_tail = rb->length - rb->start;
|
|
memcpy(buf, rb_start_ptr(rb), half_tail);
|
|
rb->start = (rb->start + half_tail) % rb->length;
|
|
|
|
int half_head = rlen - half_tail;
|
|
memcpy((unsigned char*)buf+half_tail, rb_start_ptr(rb), half_head);
|
|
rb->start = (rb->start + half_head) % rb->length;
|
|
} else {
|
|
memcpy(buf, rb_start_ptr(rb), rlen);
|
|
rb->start = (rb->start + rlen) % rb->length;
|
|
}
|
|
|
|
if ((rb->start == rb->end) || (rb_get_space_used(rb) == 0)) {
|
|
rb->start = rb->end = 0;
|
|
}
|
|
//ql_rtos_exit_critical();
|
|
// hal_os_mutex_unlock(rb->mutex);
|
|
return rlen;
|
|
}
|
|
#if 0
|
|
static void *rb_dump(struct ringbuffer *rb, int *blen)
|
|
{
|
|
if (!rb) {
|
|
return NULL;
|
|
}
|
|
void *buf = NULL;
|
|
int len = rb_get_space_used(rb);
|
|
if (len <= 0) {
|
|
return NULL;
|
|
}
|
|
buf = hal_os_malloc(len);
|
|
if (!buf) {
|
|
RLOGE("malloc %zu failed!\n", len);
|
|
return NULL;
|
|
}
|
|
*blen = len;
|
|
|
|
if ((rb->length - rb->start) < len) {
|
|
int half_tail = rb->length - rb->start;
|
|
memcpy(buf, rb_start_ptr(rb), half_tail);
|
|
|
|
int half_head = len - half_tail;
|
|
memcpy((unsigned char*)buf+half_tail, rb->buffer, half_head);
|
|
} else {
|
|
memcpy(buf, rb_start_ptr(rb), len);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static void rb_cleanup(struct ringbuffer *rb)
|
|
{
|
|
if (!rb) {
|
|
return;
|
|
}
|
|
rb->start = rb->end = 0;
|
|
}
|
|
#endif
|
|
|
|
unsigned char calculateChecksum(unsigned char *data, int length) {
|
|
unsigned char checksum = 0;
|
|
for (int i = 0; i < length; i++) {
|
|
checksum ^= data[i];
|
|
}
|
|
return checksum;
|
|
}
|
|
|
|
int hal_kv_set(char *key, void *val, int len)
|
|
{
|
|
uint8_t checkbuf[4]={0};
|
|
int ret;
|
|
QFILE * fp = NULL;
|
|
char path[128]={0};
|
|
|
|
snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);
|
|
|
|
fp = ql_fopen(path,"wb+");
|
|
if(fp==NULL)return -1;
|
|
checkbuf[0]=0xAA;
|
|
checkbuf[1]=len/256;
|
|
checkbuf[2]=len%256;
|
|
checkbuf[3]=calculateChecksum(val,len);
|
|
ret = ql_fwrite((void *)checkbuf, 4, 1, fp);
|
|
if(ret != 4)
|
|
{
|
|
printf("[FS]ERROR!!! *** file write fail: %s ***\r\n", path);
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
ret = ql_fwrite((void *)val, len, 1, fp);
|
|
if(ret != len)
|
|
{
|
|
printf("[FS]ERROR!!! *** file write fail: %s ***\r\n", path);
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
ql_fclose(fp);
|
|
return 0;
|
|
}
|
|
|
|
int hal_kv_get(char *key, void *val, int len)
|
|
{
|
|
uint8_t checkbuf[4]={0};
|
|
int ret;
|
|
QFILE * fp = NULL;
|
|
char path[128]={0};
|
|
int readlen = 0;
|
|
|
|
snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);
|
|
|
|
fp = ql_fopen(path,"rb+");
|
|
if(fp==NULL)return -1;
|
|
ret = ql_fread((void *)checkbuf, 4, 1, fp);
|
|
if(ret !=4 )
|
|
{
|
|
printf("[FS]ERROR!!! *** file read fail: %s ***\r\n", path);
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
if(checkbuf[0]!=0xAA){
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
readlen = checkbuf[1]*256+checkbuf[2];
|
|
if(len<readlen){
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
ret = ql_fread((void *)val, readlen, 1, fp);
|
|
if(ret !=readlen)
|
|
{
|
|
printf("[FS]ERROR!!! *** file read fail: %s ***\r\n", path);
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
|
|
ret = calculateChecksum(val,readlen);
|
|
|
|
if(ret!=checkbuf[3]){
|
|
RLOGE("[FS]ERROR!!! *** file read fail4: %s ***\r\n", path);
|
|
ql_fclose(fp);
|
|
return -1;
|
|
}
|
|
|
|
ql_fclose(fp);
|
|
return readlen;
|
|
}
|
|
|
|
int hal_kv_del(char *key)
|
|
{
|
|
char path[128]={0};
|
|
snprintf(path,sizeof(path)-1,"U:/config_k_%s",key);
|
|
|
|
return ql_remove(path);
|
|
}
|
|
|
|
#if 0
|
|
#define DEVICE_SN_FILE "U:/talkingq_sn.txt"
|
|
#define DEVICE_ID_FILE "U:/talkingq_id.txt"
|
|
#define TALKINGQ_URL_FILE "U:/talkingq_url.txt"
|
|
|
|
|
|
int read_device_sn(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
if(ql_access(DEVICE_SN_FILE, 0)!=0){
|
|
printf("read %s not is exist\n", DEVICE_SN_FILE);
|
|
return -1;
|
|
}
|
|
|
|
fp = ql_fopen(DEVICE_SN_FILE, "r");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_SN_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fread(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file read fail: %s \r\n", DEVICE_SN_FILE);
|
|
}
|
|
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int save_device_sn(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
|
|
fp = ql_fopen(DEVICE_SN_FILE, "w+");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_SN_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fwrite(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file write fail: %s \r\n", DEVICE_SN_FILE);
|
|
}
|
|
|
|
printf("save_device_sn:%s\n", buff);
|
|
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int read_device_id(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
if(ql_access(DEVICE_ID_FILE, 0)!=0){
|
|
printf("read %s not is exist\n", DEVICE_ID_FILE);
|
|
return -1;
|
|
}
|
|
fp = ql_fopen(DEVICE_ID_FILE, "r");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_ID_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fread(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file read fail: %s \r\n", DEVICE_ID_FILE);
|
|
}
|
|
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int save_device_id(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
|
|
fp = ql_fopen(DEVICE_ID_FILE, "w+");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", DEVICE_ID_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fwrite(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file write fail: %s \r\n", DEVICE_ID_FILE);
|
|
}
|
|
|
|
printf("save_device_id:%s\n", buff);
|
|
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int read_talkingq_url(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
|
|
if(ql_access(TALKINGQ_URL_FILE, 0)!=0){
|
|
printf("read %s not is exist\n", TALKINGQ_URL_FILE);
|
|
return -1;
|
|
}
|
|
|
|
fp = ql_fopen(TALKINGQ_URL_FILE, "r");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", TALKINGQ_URL_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fread(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file read fail: %s \r\n", TALKINGQ_URL_FILE);
|
|
}
|
|
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
if(strncmp(buff,"ws://",5)){
|
|
printf("error ws url %s",buff);
|
|
return -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int save_talkingq_url(uint8_t *buff, int len)
|
|
{
|
|
QFILE * fp = NULL;
|
|
int ret = -1;
|
|
|
|
if(strncmp(buff,"ws://",5)){
|
|
printf("error ws url %s",buff);
|
|
return -1;
|
|
}
|
|
|
|
fp = ql_fopen(TALKINGQ_URL_FILE, "w+");
|
|
|
|
if(NULL == fp)
|
|
{
|
|
printf("[FS]ERROR!!! *** file open fail: %s \r\n", TALKINGQ_URL_FILE);
|
|
return -1;
|
|
}
|
|
|
|
ret = ql_fwrite(buff, len, 1, fp);
|
|
if(ret < 0)
|
|
{
|
|
printf("[FS]ERROR!!! *** file write fail: %s \r\n", TALKINGQ_URL_FILE);
|
|
}
|
|
|
|
printf("save_talkingq_url:%s\n", buff);
|
|
ql_fclose(fp);
|
|
fp = NULL;
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
int hal_os_get_talkingq_url(char *pdevice_id)
|
|
{
|
|
char temp_device_id[TALKINGQ_URL_CAPACITY] = {0};
|
|
int saved = hal_kv_get("talkingq_url", temp_device_id, sizeof(temp_device_id));
|
|
temp_device_id[sizeof(temp_device_id) - 1] = 0;
|
|
|
|
//read_talkingq_url(temp_device_id,sizeof(temp_device_id));
|
|
if(saved > 0 && strlen(temp_device_id)>0 && !talkingq_is_legacy_ws_url(temp_device_id)){
|
|
strcpy(pdevice_id, temp_device_id);
|
|
}else{
|
|
//strcpy(pdevice_id,"ws://api.talkingq.com:8080");
|
|
//strcpy(pdevice_id,"ws://175.24.73.253:80");
|
|
strcpy(pdevice_id, TALKINGQ_WSS_URL);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_set_talkingq_url(char *pdevice_id)
|
|
{
|
|
char temp_device_id[64] = {0x00};
|
|
strcpy(temp_device_id, pdevice_id);
|
|
hal_kv_set("talkingq_url", temp_device_id, strlen(temp_device_id)+1);
|
|
// save_talkingq_url(temp_device_id, strlen(temp_device_id)+1);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_device_id(char *pdevice_id)
|
|
{
|
|
char temp_device_id[32];
|
|
memset(temp_device_id, 0, sizeof(temp_device_id));
|
|
hal_kv_get("device_id", temp_device_id, sizeof(temp_device_id));
|
|
|
|
// read_device_id(temp_device_id,sizeof(temp_device_id));
|
|
if(strlen(temp_device_id)>0){
|
|
strcpy(pdevice_id, temp_device_id);
|
|
}else{
|
|
// strcpy(pdevice_id,"TalkingQ_XQSN00001005");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_set_device_id(char *pdevice_id)
|
|
{
|
|
char temp_device_id[32] = {0x00};
|
|
strcpy(temp_device_id, pdevice_id);
|
|
hal_kv_set("device_id", temp_device_id, strlen(temp_device_id)+1);
|
|
// save_device_id(temp_device_id, strlen(temp_device_id)+1);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_get_device_sn(char *pdevice_sn)
|
|
{
|
|
char temp_device_sn[32];
|
|
memset(temp_device_sn, 0, sizeof(temp_device_sn));
|
|
hal_kv_get("device_sn", temp_device_sn, sizeof(temp_device_sn));
|
|
//read_device_sn(temp_device_sn, sizeof(temp_device_sn));
|
|
if(strlen(temp_device_sn)>0){
|
|
strcpy(pdevice_sn, temp_device_sn);
|
|
}else{
|
|
//strcpy(pdevice_sn,"TQ_XQSN000000001005");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int hal_os_set_device_sn(char *pdevice_sn)
|
|
{
|
|
char temp_device_sn[32]={0x00};
|
|
strcpy(temp_device_sn, pdevice_sn);
|
|
hal_kv_set("device_sn", temp_device_sn, strlen(temp_device_sn)+1);
|
|
// save_device_sn(temp_device_sn, strlen(temp_device_sn)+1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern int talkingq_ws_connect();
|
|
extern int talkingq_ws_send_text(char *senddata);
|
|
extern int audio_packet_type;
|
|
|
|
|
|
int hal_os_nfc_test(void)
|
|
{
|
|
printf("nfc_test\r\n");
|
|
talkingq_ws_connect();
|
|
talkingq_ws_send_text("REGISTER_TARGET_DEVICE:TalkingQ_XQSN00001004");
|
|
|
|
audio_packet_type = 4;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int hal_os_get_model(char *model)
|
|
{
|
|
strcpy(model,"CNLD-BK-S");
|
|
return 0;
|
|
}
|
|
|
|
|
|
char* hal_os_get_current_version(void)
|
|
{
|
|
return "1.0.0";
|
|
}
|
|
|
|
|
|
typedef struct hal_dev_uart_struct
|
|
{
|
|
uint8_t portno;
|
|
uint8_t hal_portno;
|
|
void *ringbuf;
|
|
}hal_dev_uart_t;
|
|
|
|
|
|
void quec_uart_callback(QL_UART_PORT_NUMBER_E port, int len, void *para)
|
|
{
|
|
hal_dev_uart_t *uart = para;
|
|
if(para==NULL)return;
|
|
int read_len = 0;
|
|
char r_data[1024] = {0};
|
|
read_len = ql_uart_read(port, r_data, sizeof(r_data));
|
|
if(read_len>0&&uart->ringbuf!=NULL){
|
|
hal_os_rb_write(uart->ringbuf,r_data,read_len,0);
|
|
}
|
|
}
|
|
|
|
void * hal_dev_uart_open(uint8_t portno, char* configbuf)
|
|
{
|
|
int ret;
|
|
hal_dev_uart_t *uart = hal_os_malloc(sizeof(hal_dev_uart_t));
|
|
if(!uart)return NULL;
|
|
uart->portno = portno;
|
|
ql_uart_config_t uart_cfg = {0};
|
|
|
|
|
|
if(configbuf && !strcmp(configbuf,"3686400,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_3686400;
|
|
}else if(configbuf && !strcmp(configbuf,"460800,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_460800;
|
|
}else if(configbuf && !strcmp(configbuf,"921600,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_921600;
|
|
}else if(configbuf && !strcmp(configbuf,"115200,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_115200;
|
|
}else if(configbuf && !strcmp(configbuf,"9600,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_9600;
|
|
}else if(configbuf && !strcmp(configbuf,"38400,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_38400;
|
|
}else if(configbuf && !strcmp(configbuf,"19200,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_19200;
|
|
}else if(configbuf && !strcmp(configbuf,"28800,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_28800;
|
|
}else if(configbuf && !strcmp(configbuf,"57600,8,n,1")){
|
|
uart_cfg.baudrate = QL_UART_BAUD_57600;
|
|
}
|
|
else{
|
|
goto failed;
|
|
}
|
|
|
|
uart_cfg.flow_ctrl = QL_FC_NONE;
|
|
uart_cfg.data_bit = QL_UART_DATABIT_8;
|
|
uart_cfg.stop_bit = QL_UART_STOP_1;
|
|
uart_cfg.parity_bit = QL_UART_PARITY_NONE;
|
|
|
|
|
|
if(uart->portno==0){
|
|
uart->hal_portno = QL_MAIN_UART_PORT;
|
|
}else if(uart->portno==1){
|
|
uart->hal_portno = QL_USB_CDC_PORT;
|
|
}else{
|
|
goto failed;
|
|
}
|
|
|
|
if(uart->portno==0){
|
|
ret = ql_uart_set_dcbconfig(uart->hal_portno, &uart_cfg);
|
|
if(QL_UART_SUCCESS != ret)
|
|
{
|
|
RLOGE("ql_uart_set_dcbconfig exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
ret = ql_uart_open(uart->hal_portno,uart_cfg.baudrate,QL_FC_NONE);
|
|
if(QL_UART_SUCCESS != ret)
|
|
{
|
|
RLOGE("ql_uart_open exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
|
|
goto failed;
|
|
}
|
|
|
|
uart->ringbuf = hal_os_rb_create(2048);
|
|
if(!uart->ringbuf){
|
|
RLOGE("hal_os_rb_create exit portno %d hal_portno %d",uart->portno,uart->hal_portno);
|
|
goto failed;
|
|
}
|
|
|
|
ql_uart_register_cb_ex(uart->hal_portno, quec_uart_callback,uart);
|
|
|
|
return uart;
|
|
|
|
failed:
|
|
hal_os_free(uart);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int32_t hal_dev_uart_write(void *uart, unsigned char *buf, uint32_t len, uint32_t timeout_ms)
|
|
{
|
|
hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
|
|
uint64_t t_start = hal_os_up_time_ms();
|
|
int ret;
|
|
|
|
if(myuart==NULL)return -1;
|
|
|
|
ret = ql_uart_write(myuart->hal_portno, buf, len);
|
|
|
|
if(ret<0)return ret;
|
|
return len;
|
|
}
|
|
|
|
int32_t hal_dev_uart_read(void *uart, unsigned char *buf, uint32_t len, uint32_t timeout_ms)
|
|
{
|
|
hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
|
|
uint64_t t_start = hal_os_up_time_ms();
|
|
int ret;
|
|
int recv_index = 0;
|
|
int recv_req = len;
|
|
uint64_t t_start2=t_start;
|
|
|
|
if(myuart==NULL){
|
|
hal_os_task_sleep_ms(3);
|
|
return -1;
|
|
}
|
|
|
|
rerecv:
|
|
ret = hal_os_rb_read(myuart->ringbuf, buf + recv_index, recv_req, 0);
|
|
if(ret<0){
|
|
return -1;
|
|
}else if(ret<recv_req){
|
|
recv_req = recv_req - ret;
|
|
recv_index += ret;
|
|
if(hal_os_up_time_ms()-t_start>=timeout_ms){
|
|
ret = -3;
|
|
if(recv_index!=0 && recv_index!=len){
|
|
RLOGD("uart read data timeout len %d recv %d port %d",len, recv_index, myuart->portno);
|
|
return ret;
|
|
}
|
|
|
|
return recv_index;
|
|
}else if((hal_os_up_time_ms()-t_start2)>5000){
|
|
t_start2 = hal_os_up_time_ms();
|
|
hal_os_feed_dog();
|
|
}else if(ret==0 && len==1){
|
|
hal_os_task_sleep_ms(2);
|
|
}else if(ret==0){
|
|
hal_os_task_sleep_ms(1);
|
|
}
|
|
goto rerecv;
|
|
}
|
|
ret = 0;
|
|
|
|
return len;
|
|
}
|
|
int hal_dev_uart_close(void *uart)
|
|
{
|
|
hal_dev_uart_t *myuart = (hal_dev_uart_t *)uart;
|
|
int ret = ql_uart_close(myuart->hal_portno);
|
|
if(myuart->ringbuf!=NULL)hal_os_rb_destroy(myuart->ringbuf);
|
|
hal_os_free(uart);
|
|
return ret;
|
|
}
|
|
|
|
static void ql_cell_call_back(QL_CELL_LOC_STATE_E state, ql_cell_cfg *cell_cfg)
|
|
{
|
|
RLOGD("cb lng: %f, lat: %f, accuracy: %d err:%d\n",cell_cfg->lng, cell_cfg->lat, cell_cfg->accuracy, cell_cfg->err.err_code);
|
|
}
|
|
|
|
#define CELL_LOCATOR_SERVER_DOMAIN "www.queclocator.com"
|
|
|
|
int hal_os_get_locator(float *lon,float *lat)
|
|
{
|
|
int ret;
|
|
char token [32] ="go518q365z17qA22";
|
|
int port = 80;
|
|
int timeout = 10;
|
|
ql_cell_cfg *g_cell_cfg = NULL;
|
|
|
|
RLOGD("cell_locator started!!");
|
|
|
|
g_cell_cfg = malloc(sizeof(ql_cell_cfg));
|
|
if(g_cell_cfg == NULL){
|
|
RLOGE("g_cell_cfg malloc failed !!");
|
|
|
|
return -1;
|
|
}
|
|
ret = ql_cell_locator_init(g_cell_cfg);
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator_init error.");
|
|
|
|
goto error;
|
|
}
|
|
ret = ql_cell_locator_set_server(g_cell_cfg,CELL_LOCATOR_SERVER_DOMAIN, port);
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator_set_server error.");
|
|
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_set_cid(g_cell_cfg,1);
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator_set_cid error.");
|
|
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_set_timeout(g_cell_cfg,timeout);
|
|
if(ret)
|
|
{
|
|
|
|
RLOGE("ql_cell_locator_set_timeout error.");
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_set_token(g_cell_cfg,token, strlen(token));
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator_set_token error.");
|
|
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_ASYN, 0);
|
|
if(ret)
|
|
{
|
|
|
|
RLOGE("ql_cell_locator set ASYN error.");
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_ASYN_CB, ql_cell_call_back);/*Asynchronous callback*/
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator set ASYN_CB error");
|
|
goto error;
|
|
}
|
|
|
|
ret = ql_cell_locator_setopt(g_cell_cfg, QL_CELL_OPT_METHOD, QL_CELL_TYPE_CELL);
|
|
if(ret)
|
|
{
|
|
RLOGE("ql_cell_locator set METHOD error.");
|
|
goto error;
|
|
}
|
|
|
|
|
|
ret = ql_cell_locator_perform(g_cell_cfg);
|
|
if(ret){
|
|
RLOGE("ql_cell_locator_perform ret %d error:%d",ret,g_cell_cfg->err.err_code);
|
|
|
|
}else{
|
|
*lon = g_cell_cfg->lng;
|
|
*lat = g_cell_cfg->lat;
|
|
|
|
RLOGD("lon: %f, lat: %f, accuracy: %d city_code:%s err:%d",g_cell_cfg->lng,g_cell_cfg->lat,g_cell_cfg->accuracy,g_cell_cfg->city_code,g_cell_cfg->err.err_code);
|
|
}
|
|
|
|
error:
|
|
ql_cell_locator_release(g_cell_cfg);
|
|
|
|
return ret;
|
|
}
|
|
|