823 lines
23 KiB
C
823 lines
23 KiB
C
/*================================================================
|
|
Copyright (c) 2020 Quectel Wireless Solution, Co., Ltd. All Rights Reserved.
|
|
Quectel Wireless Solution Proprietary and Confidential.
|
|
=================================================================*/
|
|
/*=================================================================
|
|
|
|
EDIT HISTORY FOR MODULE
|
|
|
|
This section contains comments describing changes made to the module.
|
|
Notice that changes are listed in reverse chronological order.
|
|
|
|
WHEN WHO WHAT, WHERE, WHY
|
|
------------ ------- -------------------------------------------------------------------------------
|
|
|
|
=================================================================*/
|
|
|
|
/*===========================================================================
|
|
* include files
|
|
===========================================================================*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "ql_application.h"
|
|
#include "ql_zip.h"
|
|
#include "ql_fs.h"
|
|
#include "ql_log.h"
|
|
#include "ql_rtos.h"
|
|
#include "ql_uart.h"
|
|
#include "ql_type.h"
|
|
#include "ql_func.h"
|
|
|
|
/*===========================================================================
|
|
* Macro Definition
|
|
===========================================================================*/
|
|
#define QL_ZIPDEMO_LOG(fmt, args...) printf("[%s %d]" fmt, __func__, __LINE__, ##args)
|
|
|
|
#define FILE_NAME1 "testFile1.txt"
|
|
#define FILE_NAME2 "testFile2.txt"
|
|
#define FILE_ZIP_NAME "test.zip"
|
|
#define FILE_NAME_ZIP1 "test01.txt"
|
|
#define FILE_NAME_ZIP2 "test02.txt"
|
|
#define U_DISK "U:"
|
|
#define U_FILE_UNDER_ROOT1 "" U_DISK "/" FILE_NAME1 ""
|
|
#define U_FILE_UNDER_ROOT2 "" U_DISK "/" FILE_NAME2 ""
|
|
#define U_FILE_UNDER_ZIP1 "" U_DISK "/" FILE_NAME_ZIP1 ""
|
|
#define U_FILE_UNDER_ZIP2 "" U_DISK "/" FILE_NAME_ZIP2 ""
|
|
#define U_FILE_UNDER_ZIP "" U_DISK "/" FILE_ZIP_NAME ""
|
|
#define DIR_NAME "testDir"
|
|
#define U_DIR_PATH "" U_DISK "/" DIR_NAME ""
|
|
|
|
#define ZIP_FILE_LEN (1024)
|
|
/*===========================================================================
|
|
* Variate
|
|
===========================================================================*/
|
|
const char *unZipFilePath = U_FILE_UNDER_ZIP;
|
|
|
|
char *unZip_path = NULL;
|
|
const char *TestFilePath[2] = {U_FILE_UNDER_ROOT1, U_FILE_UNDER_ROOT2};
|
|
const char *TestFilezipname[2] = {U_FILE_UNDER_ZIP1, U_FILE_UNDER_ZIP2};
|
|
|
|
enum
|
|
{
|
|
QL_SPI_DEV0 = 0,
|
|
QL_SPI_DEV2 = 2
|
|
};
|
|
enum
|
|
{
|
|
QL_PIN_16_19,
|
|
QL_PIN_33_36
|
|
};
|
|
enum
|
|
{
|
|
SPI_CLOCK_13M = 0x0,
|
|
SPI_CLOCK_26M = 0x1,
|
|
SPI_CLOCK_52M = 0x2,
|
|
};
|
|
|
|
typedef struct file
|
|
{
|
|
unsigned int cnt;
|
|
unsigned char buf[1024];
|
|
} file_contex;
|
|
|
|
/*===========================================================================
|
|
* Functions
|
|
===========================================================================*/
|
|
static void ql_zip_demo_thread(void *param)
|
|
{
|
|
int ret = 0;
|
|
int run_num = 0;
|
|
HZIP hz = 0;
|
|
QFILE *fp1 = NULL;
|
|
QFILE *fp2 = NULL;
|
|
unsigned char *zip_fs_space = calloc(10, ZIP_FILE_LEN);
|
|
if (NULL == zip_fs_space)
|
|
{
|
|
QL_ZIPDEMO_LOG("malloc err\r\n");
|
|
return;
|
|
}
|
|
ql_rtos_task_sleep_s(5);
|
|
QL_ZIPDEMO_LOG("========== zip demo start ==========\r\n");
|
|
QL_ZIPDEMO_LOG("========== start create Test Files:[%s][%s]==========\r\n", TestFilePath[0], TestFilePath[1]);
|
|
fp1 = ql_fopen(TestFilePath[0], "w+");
|
|
fp2 = ql_fopen(TestFilePath[1], "w+");
|
|
if ((fp1 == NULL) || (fp2 == NULL))
|
|
{
|
|
QL_ZIPDEMO_LOG("open file failed ! %p-%p\r\n", fp1, fp2);
|
|
QL_ZIPDEMO_LOG("========== Create Test Files:[%s][%s] fail==========\r\n", TestFilePath[0], TestFilePath[1]);
|
|
goto main_exit;
|
|
}
|
|
else
|
|
{
|
|
QL_ZIPDEMO_LOG("open file:[%x][%x] success!\r\n", fp1, fp2);
|
|
}
|
|
memset(zip_fs_space, 'a', 10 * ZIP_FILE_LEN);
|
|
ret = ql_fwrite(zip_fs_space, 10 * ZIP_FILE_LEN, 1, fp1);
|
|
if (ret > 0)
|
|
{
|
|
QL_ZIPDEMO_LOG("file:test01.txt write :%d bytes data\r\n", ret);
|
|
}
|
|
else
|
|
{
|
|
ql_fclose(fp1);
|
|
ql_fclose(fp2);
|
|
QL_ZIPDEMO_LOG("file:test01.txt write Failed\r\n");
|
|
QL_ZIPDEMO_LOG("========== Create Test Files:[%s][%s] Failed==========\r\n", TestFilePath[0], TestFilePath[1]);
|
|
goto main_exit;
|
|
}
|
|
memset(zip_fs_space, 'b', 5 * ZIP_FILE_LEN);
|
|
ret = ql_fwrite(zip_fs_space, 5 * ZIP_FILE_LEN, 1, fp2);
|
|
if (ret > 0)
|
|
{
|
|
QL_ZIPDEMO_LOG("file:test02.txt write :%d bytes data\r\n", ret);
|
|
}
|
|
else
|
|
{
|
|
ql_fclose(fp1);
|
|
ql_fclose(fp2);
|
|
QL_ZIPDEMO_LOG("file:test02.txt write Failed\r\n");
|
|
QL_ZIPDEMO_LOG("========== Create Test Files:[%s][%s] Failed==========\r\n", TestFilePath[0], TestFilePath[1]);
|
|
goto main_exit;
|
|
}
|
|
ql_fclose(fp1);
|
|
ql_fclose(fp2);
|
|
QL_ZIPDEMO_LOG("========== Create Test Files:[%s][%s] success==========\r\n", TestFilePath[0], TestFilePath[1]);
|
|
ql_rtos_task_sleep_s(5);
|
|
|
|
for (run_num = 0; run_num < 1; run_num++)
|
|
{
|
|
QL_ZIPDEMO_LOG("========== loop_test[%d] start==========\r\n", run_num + 1);
|
|
QL_ZIPDEMO_LOG("========== start zip file[%d]==========\r\n", run_num + 1);
|
|
|
|
hz = ql_fs_zip_create(unZipFilePath, 0, &ret);
|
|
if (ret < 0)
|
|
{
|
|
QL_ZIPDEMO_LOG("create empty.zip:[%s] Failed,errcode=%d\r\n", unZipFilePath, ret);
|
|
goto main_exit;
|
|
}
|
|
else
|
|
{
|
|
QL_ZIPDEMO_LOG("create empty.zip:[%s] Success\r\n", unZipFilePath);
|
|
}
|
|
|
|
ret = ql_fs_zip_add_file(hz, TestFilezipname[0], TestFilePath[0]);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
QL_ZIPDEMO_LOG("add [%s] to zip Failed\r\n", TestFilePath[0]);
|
|
goto main_exit;
|
|
}
|
|
QL_ZIPDEMO_LOG("add [%s] to zip Success\r\n", TestFilePath[0]);
|
|
|
|
ret = ql_fs_zip_add_file(hz, TestFilezipname[1], TestFilePath[1]);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
QL_ZIPDEMO_LOG("add [%s] to zip Failed\r\n", TestFilePath[1]);
|
|
goto main_exit;
|
|
}
|
|
QL_ZIPDEMO_LOG("add [%s] to zip Success\r\n", TestFilePath[1]);
|
|
|
|
ql_fs_zip_close(hz);
|
|
#if 0
|
|
//?????
|
|
ql_rtos_task_sleep_s(5);
|
|
ql_unzip_mem_data_s *ql_unzip_tmp = (ql_unzip_mem_data_s *)calloc(1, sizeof(ql_unzip_mem_data_s));
|
|
if (ql_unzip_tmp == NULL)
|
|
{
|
|
QL_ZIPDEMO_LOG("malloc err");
|
|
goto main_exit;
|
|
}
|
|
|
|
ql_unzip_tmp->data = (void *)calloc(1, 15*ZIP_FILE_LEN);
|
|
if (ql_unzip_tmp->data == NULL)
|
|
{
|
|
QL_ZIPDEMO_LOG("malloc err");
|
|
free(ql_unzip_tmp);
|
|
goto main_exit;
|
|
}
|
|
|
|
ql_unzip_tmp->total_len = 15*ZIP_FILE_LEN;
|
|
ret = ql_fs_unzip_ex(unZipFilePath, QL_UNZIP_TO_MEMERY, ql_unzip_tmp);
|
|
if(ret!=QL_FILE_OK)
|
|
{
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Failed",unZipFilePath);
|
|
free(ql_unzip_tmp->data);
|
|
free(ql_unzip_tmp);
|
|
goto main_exit;
|
|
}
|
|
QL_ZIPDEMO_LOG("used_len=%d,item_num=%d\n",ql_unzip_tmp->used_len, ql_unzip_tmp->item_num);
|
|
|
|
int j=0;
|
|
int i = 0;
|
|
char *tmep = NULL;
|
|
for (j=0; j<ql_unzip_tmp->item_num; j++)
|
|
{
|
|
QL_ZIPDEMO_LOG("file path=%s\n", ql_unzip_tmp->item[j].file_path);
|
|
QL_ZIPDEMO_LOG("file len=%d,type=%d\n", ql_unzip_tmp->item[j].item_len, ql_unzip_tmp->item[j].file_type);
|
|
tmep = (char *)ql_unzip_tmp->item[j].item_data;
|
|
if (tmep && ql_unzip_tmp->item[j].file_type == QL_UNZIP_FILE)
|
|
{
|
|
if (0 == strcmp(ql_unzip_tmp->item[j].file_path, TestFilePath[0]))
|
|
{
|
|
for (i=0; i<ql_unzip_tmp->item[j].item_len; i++)
|
|
{
|
|
if (tmep[i] != 'a')
|
|
{
|
|
QL_ZIPDEMO_LOG("not match -----------");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (0 == strcmp(ql_unzip_tmp->item[j].file_path, TestFilePath[1]))
|
|
{
|
|
for (i=0; i<ql_unzip_tmp->item[j].item_len; i++)
|
|
{
|
|
if (tmep[i] != 'b')
|
|
{
|
|
QL_ZIPDEMO_LOG("not match -----------");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(ql_unzip_tmp->data);
|
|
free(ql_unzip_tmp);
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Success\r\n",unZipFilePath);
|
|
#else
|
|
//???????
|
|
QL_ZIPDEMO_LOG("========== zip file[%d] success==========\r\n", run_num + 1);
|
|
ql_rtos_task_sleep_s(5);
|
|
QL_ZIPDEMO_LOG("========== start unzip file[%d]==========\r\n", run_num + 1);
|
|
|
|
ret = ql_fs_unzip(unZipFilePath, unZip_path, 1);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Failed\r\n", unZipFilePath);
|
|
goto main_exit;
|
|
}
|
|
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Success\r\n", unZipFilePath);
|
|
|
|
#endif
|
|
QL_ZIPDEMO_LOG("========== unzip file[%d] success==========\r\n", run_num + 1);
|
|
|
|
ql_rtos_task_sleep_s(5);
|
|
}
|
|
main_exit:
|
|
QL_ZIPDEMO_LOG("========== zip demo end ==========\r\n");
|
|
ql_remove(TestFilePath[0]);
|
|
ql_remove(TestFilePath[1]);
|
|
if (zip_fs_space != NULL)
|
|
{
|
|
free(zip_fs_space);
|
|
zip_fs_space = NULL;
|
|
}
|
|
ql_rtos_task_delete(NULL);
|
|
return;
|
|
}
|
|
|
|
// application_init(ql_zip_demo_thread, "ql_zipdemo", 32, 0);
|
|
|
|
static void ql_unzip_demo_test(void *param)
|
|
{
|
|
|
|
ql_rtos_task_sleep_s(5);
|
|
QL_ZIPDEMO_LOG("========== start unzip file==========\r\n");
|
|
|
|
int ret = ql_fs_unzip(unZipFilePath, unZip_path, 1);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Failed\r\n", unZipFilePath);
|
|
goto main_exit;
|
|
}
|
|
QL_ZIPDEMO_LOG("unzip file:[%s] Success\r\n", unZipFilePath);
|
|
main_exit:
|
|
QL_ZIPDEMO_LOG("========== zip demo end ==========\r\n");
|
|
ql_rtos_task_delete(NULL);
|
|
return;
|
|
}
|
|
|
|
#define NAND_DEV "NAND:/"
|
|
#define U_DEV "U:"
|
|
#define TEST_TXT_NAME "test.txt"
|
|
#define TEST_ZIP_NAME "test.zip"
|
|
|
|
#define LITFS_ZIP_PATH "" U_DEV "/" TEST_ZIP_NAME ""
|
|
|
|
typedef unsigned int File_Handle;
|
|
typedef unsigned int size_t;
|
|
void nand_zip_test(void *argv)
|
|
{
|
|
|
|
int ret = 0;
|
|
File_Handle filep;
|
|
size_t status = 0;
|
|
HZIP hzs;
|
|
|
|
ql_rtos_task_sleep_s(5);
|
|
ql_spi_nand_init(QL_SPI_DEV0, QL_PIN_33_36, SPI_CLOCK_26M);
|
|
|
|
//写入文件1
|
|
filep = ql_nand_fopen("mount_temp.txt", "w+");
|
|
if (filep < 0)
|
|
{
|
|
printf("nand mount Failed\r\n");
|
|
return;
|
|
}
|
|
char mount_buf[50]="mount_temp_the_test_file";
|
|
|
|
status = ql_nand_fwrite(mount_buf, 1, strlen(mount_buf), filep);
|
|
if (status != strlen(mount_buf))
|
|
{
|
|
printf("fx_file_write is failede.!!\n");
|
|
return;
|
|
}
|
|
|
|
status = ql_nand_fsync(filep);
|
|
if (status != 0)
|
|
{
|
|
printf("ql_nand_fsync is failede.!!\n");
|
|
return;
|
|
}
|
|
printf("ql_nand_fwrite is ok.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
|
|
//写入文件2
|
|
char bufs_test[50] = "quec_zips2_test_in_windows";
|
|
char reads_buf[56] = {0};
|
|
filep = ql_nand_fopen(TEST_TXT_NAME, "w+");
|
|
status = ql_nand_fwrite(bufs_test, 1, strlen(bufs_test), filep);
|
|
if (status != strlen(bufs_test))
|
|
{
|
|
printf("fx_file_write is failede.!!\n");
|
|
return;
|
|
}
|
|
status = ql_nand_fsync(filep);
|
|
if (status != 0)
|
|
{
|
|
printf("ql_nand_fsync is failede.!!\n");
|
|
return;
|
|
}
|
|
printf("ql_nand_fwrite is ok.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
|
|
// 构建nand文件路径，用于压缩解压
|
|
char unZipFilePath[50] = {0};
|
|
sprintf(unZipFilePath, "%s%s", NAND_DEV, TEST_TXT_NAME);
|
|
char zipFilePath[50] = {0};
|
|
sprintf(zipFilePath, "%s%s", NAND_DEV, TEST_ZIP_NAME);
|
|
|
|
// 创建一个zip文件头
|
|
hzs = ql_fs_zip_create(zipFilePath, 0, &ret);
|
|
if (ret < 0)
|
|
{
|
|
printf("create empty.zip:[%s] Failed,errcode=%d\r\n", zipFilePath, ret);
|
|
ql_fs_zip_close(hzs);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
printf(("create empty.zip:[%s] Success\r\n", zipFilePath));
|
|
}
|
|
|
|
//添加文件1
|
|
ret = ql_fs_zip_add_file(hzs, TEST_TXT_NAME, unZipFilePath);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("add [%s] to zip Failed\r\n", TEST_TXT_NAME);
|
|
ql_fs_zip_close(hzs);
|
|
return;
|
|
}
|
|
|
|
///添加文件2
|
|
char unZipFilePath2[50] = {0};
|
|
sprintf(unZipFilePath2, "%s%s", NAND_DEV, "mount_temp.txt");
|
|
|
|
ret = ql_fs_zip_add_file(hzs, "mount_temp.txt", unZipFilePath2);
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("add [mount_temp.txt] to zip Failed\r\n");
|
|
ql_fs_zip_close(hzs);
|
|
return;
|
|
}
|
|
|
|
printf("add to zip Success\r\n");
|
|
ql_fs_zip_close(hzs);
|
|
// printf("add to zip Success\r\n");
|
|
printf("zip_size_file:[%d]\r\n", sizeof(zipFilePath));
|
|
|
|
//先移除文件
|
|
ret = ql_nand_fremove(TEST_TXT_NAME);
|
|
ret = ql_nand_fremove("mount_temp.txt");
|
|
|
|
printf("ql_nand_fsize :ret=%d\r\n", ql_nand_fsize(TEST_ZIP_NAME));
|
|
|
|
//开始解压数据
|
|
#if 1
|
|
ql_rtos_task_sleep_s(5);
|
|
printf("========== start unzip file[%d]==========\r\n");
|
|
|
|
char *unZip_path = "NAND:/";
|
|
ret = ql_fs_unzip(zipFilePath, NULL, 1);
|
|
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("unzip file:[%s] Failed\r\n", zipFilePath);
|
|
return;
|
|
}
|
|
printf("unzip file:[%s] Success\r\n", zipFilePath);
|
|
#endif
|
|
//读取解压的文件
|
|
#if 1
|
|
printf("========== start read file1==========\r\n");
|
|
filep = ql_nand_fopen(TEST_TXT_NAME, "r");
|
|
if (filep < 0)
|
|
{
|
|
printf("nand mount Failed:%d\r\n",__LINE__);
|
|
return;
|
|
}
|
|
status = ql_nand_fread(reads_buf, 1, sizeof(reads_buf), filep);
|
|
|
|
printf("status:%d\r\n",status);
|
|
|
|
ql_nand_fclose(filep);
|
|
printf("reads_buf1:%s\r\n", reads_buf);
|
|
|
|
|
|
printf("========== read file2_start==========\r\n");
|
|
|
|
memset(reads_buf, 0, sizeof(reads_buf));
|
|
|
|
filep = ql_nand_fopen("mount_temp.txt", "r");
|
|
if (filep < 0)
|
|
{
|
|
printf("nand mount Failed:%d\r\n",__LINE__);
|
|
return;
|
|
}
|
|
status = ql_nand_fread(reads_buf, 1, sizeof(reads_buf), filep);
|
|
|
|
printf("status:%d\r\n", status);
|
|
|
|
ql_nand_fclose(filep);
|
|
|
|
printf("reads_buf2:%s\r\n", reads_buf);
|
|
printf("read from zip Success\r\n");
|
|
|
|
printf("========== end read file==========\r\n");
|
|
|
|
#endif
|
|
//把压缩包数据写到littfs系统中，方便导入到windows中进行解压
|
|
#if 0
|
|
|
|
printf("========== start read test_zip==========\r\n");
|
|
|
|
char zip_buf[169]={0};
|
|
|
|
filep=ql_nand_fopen("test.zip", "rb");
|
|
|
|
if(filep == NULL){
|
|
printf("fx_file_open is failede.!!\r\n");
|
|
return;
|
|
}
|
|
status = ql_nand_fread(zip_buf,1,sizeof(zip_buf),filep);
|
|
|
|
if(status != 168){
|
|
printf("fx_file_read is failede.!!\n");
|
|
ql_nand_fclose(filep);
|
|
return;
|
|
}
|
|
printf("read from zip Success\r\n");
|
|
|
|
printf("status:%d\r\n",status);
|
|
|
|
ql_nand_fclose(filep);
|
|
|
|
// printf("zip_data:");
|
|
|
|
// for(int i=0;i<sizeof(zip_buf);i++){
|
|
// printf("%x",zip_buf[i]);
|
|
// }
|
|
// printf("\r\n");
|
|
|
|
QFILE *littfs_filep = NULL;
|
|
|
|
littfs_filep = ql_fopen(LITFS_ZIP_PATH, "wb");
|
|
|
|
if(littfs_filep == NULL){
|
|
printf("ql_fopen is failede.!!\r\n");
|
|
return;
|
|
}
|
|
|
|
ret = ql_fwrite(zip_buf,sizeof(zip_buf),1,littfs_filep);
|
|
|
|
if(ret>0){
|
|
printf("ql_fwrite is ok.!!\r\n");
|
|
ql_fclose(littfs_filep);
|
|
}else{
|
|
printf("ql_fwrite is failede.!!\r\n");
|
|
ql_fclose(littfs_filep);
|
|
return;
|
|
}
|
|
ql_fclose(littfs_filep);
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
//解压从windows接受的压缩包
|
|
ql_sem_t semaRef;
|
|
int read_len = 0;
|
|
char r_data[1024] = {0};
|
|
void quec_uart_rx_callback(QL_UART_PORT_NUMBER_E port, void *para)
|
|
{
|
|
|
|
read_len = ql_uart_read(port, r_data, sizeof(r_data));
|
|
ql_rtos_semaphore_release(semaRef);
|
|
}
|
|
void quec_main_uart_rx(void)
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
ql_uart_config_t dcb;
|
|
ql_log_mask_set(QL_LOG_APP_MASK, QL_LOG_PORT_UART);
|
|
|
|
ret = ql_uart_open(QL_MAIN_UART_PORT, QL_UART_BAUD_115200, QL_FC_NONE);
|
|
|
|
ql_uart_get_dcbconfig(QL_MAIN_UART_PORT, &dcb);
|
|
|
|
dcb.baudrate = QL_UART_BAUD_115200;
|
|
ql_uart_set_dcbconfig(QL_MAIN_UART_PORT, &dcb);
|
|
|
|
ql_uart_register_cb(QL_MAIN_UART_PORT, quec_uart_rx_callback); // use callback to read uart data
|
|
|
|
// 清除可能已存在的信号量计数
|
|
while(ql_rtos_semaphore_wait(semaRef, 0) == 0);
|
|
|
|
ql_rtos_semaphore_wait(semaRef, QL_WAIT_FOREVER);
|
|
|
|
printf("data_len:%d\r\n", read_len);
|
|
|
|
// printf("data:\r\n");
|
|
// for (int i = 0; i < read_len; i++)
|
|
// {
|
|
// printf("%x", r_data[i]);
|
|
// }
|
|
|
|
// printf("\r\n");
|
|
|
|
}
|
|
|
|
static void nand_unzip_test(void *argv)
|
|
{
|
|
|
|
printf("======nand_unzip_test_start=======\r\n");
|
|
|
|
int ret = 0;
|
|
File_Handle filep,filep1;
|
|
size_t status = 0;
|
|
HZIP hzs;
|
|
|
|
char from_win_buf[50]={0};
|
|
|
|
ql_rtos_semaphore_create(&semaRef, 0);
|
|
|
|
quec_main_uart_rx();//接受从windows下压缩包的数据
|
|
|
|
ql_spi_nand_init(QL_SPI_DEV0, QL_PIN_33_36, SPI_CLOCK_26M);
|
|
|
|
filep = ql_nand_fopen("zip_test2.zip", "wb");
|
|
|
|
if (filep < 0)
|
|
{
|
|
printf("ql_nand_fopen is failede.!!\r\n");
|
|
return;
|
|
}
|
|
status = ql_nand_fwrite(r_data, 1, sizeof(r_data), filep);
|
|
|
|
if (status > 0)
|
|
{
|
|
printf("ql_nand_fwrite is ok.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
}
|
|
else
|
|
{
|
|
printf("ql_nand_fwrite is failede.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
return;
|
|
}
|
|
|
|
|
|
char zipFilePath[128] = {0};
|
|
|
|
sprintf(zipFilePath, "%s%s", NAND_DEV,"zip_test2.zip" );
|
|
|
|
ret = ql_fs_unzip(zipFilePath, NULL, 1);
|
|
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("unzip file:[%s] Failed\r\n", zipFilePath);
|
|
return;
|
|
}
|
|
printf("unzip file:[%s] Success\r\n", zipFilePath);
|
|
|
|
filep = ql_nand_fopen("zip_test.txt", "r");
|
|
|
|
if(filep < 0){
|
|
printf("ql_nand_fopen is failede.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
return;
|
|
}
|
|
|
|
//读文件1
|
|
status = ql_nand_fread(from_win_buf, 1, sizeof(from_win_buf), filep);
|
|
|
|
if (status > 0)
|
|
{
|
|
printf("ql_nand_fread is ok.!! %d\r\n",__LINE__);
|
|
ql_nand_fclose(filep);
|
|
}
|
|
else
|
|
{
|
|
printf("ql_nand_fread is failede.!!\r\n");
|
|
ql_nand_fclose(filep);
|
|
return;
|
|
}
|
|
|
|
printf("status:%d\r\n",status);
|
|
printf("from_win_buf:%s\r\n", from_win_buf);
|
|
|
|
//读文件2
|
|
memset(from_win_buf, 0, sizeof(from_win_buf));
|
|
|
|
filep1 = ql_nand_fopen("zip_test2.txt", "r");
|
|
|
|
if(filep1 < 0){
|
|
printf("ql_nand_fopen is failede.!!\r\n");
|
|
ql_nand_fclose(filep1);
|
|
return;
|
|
}
|
|
|
|
status = ql_nand_fread(from_win_buf, 1, sizeof(from_win_buf), filep1);
|
|
|
|
if (status > 0)
|
|
{
|
|
printf("ql_nand_fread is ok.!!\r\n");
|
|
ql_nand_fclose(filep1);
|
|
}
|
|
else
|
|
{
|
|
printf("ql_nand_fread is failede.!!\r\n");
|
|
ql_nand_fclose(filep1);
|
|
return;
|
|
}
|
|
|
|
printf("from_win_buf:%s\r\n", from_win_buf);
|
|
|
|
printf("======nand_unzip_test_end=======\r\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define FILE_ZIP_NAME1 "test3.zip"
|
|
#define FILE_NAME1 "ZIPTEST.TXT"
|
|
#define U_DISK1 "U:"
|
|
#define FILE_NAME_ZIP1 "ZIPTEST1.txt"
|
|
#define FILE_ZIP_DIR_FILE1 "" U_DISK1 "/" FILE_NAME_ZIP1 ""
|
|
#define FILE_ZIP_DS_FILE1 "" U_DISK1 "/" FILE_NAME1 ""
|
|
#define FILE_ZIP_PATH1 "" U_DISK1 "/" FILE_ZIP_NAME1 ""
|
|
const char *unZipFilePaths1 = FILE_ZIP_PATH1;
|
|
|
|
const char *zipFilePath1 = FILE_ZIP_DS_FILE1;
|
|
|
|
const char *zipNAME1 = FILE_ZIP_DIR_FILE1;
|
|
|
|
char *unZip_paths1 = NULL;
|
|
void littfs_zip_test(void *argv)
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
QFILE *filep = NULL;
|
|
|
|
HZIP hzs;
|
|
// ql_rtos_task_sleep_s(5);
|
|
// ql_spi_nand_init(QL_SPI_DEV0, QL_PIN_33_36,SPI_CLOCK_26M);
|
|
// ret = ql_nand_mkdir("quec_zips1");
|
|
// printf("ql_nand_mkdir %d\n",ret);
|
|
|
|
char bufs_test[50] = "quec_zips2_test_in_windows";
|
|
|
|
char read_buf[50] = {0};
|
|
|
|
filep = ql_fopen(FILE_ZIP_DS_FILE1, "wb+");
|
|
|
|
if (filep == NULL)
|
|
{
|
|
printf("fx_file_open is failede.!!\n");
|
|
return;
|
|
}
|
|
|
|
ret = ql_fwrite(bufs_test, strlen(bufs_test), 1, filep);
|
|
|
|
if (ret > 0)
|
|
{
|
|
printf("fx_file_write is success.!!\n");
|
|
}
|
|
else
|
|
{
|
|
printf("fx_file_write is failede.!!\n");
|
|
ql_fclose(filep);
|
|
|
|
return;
|
|
}
|
|
|
|
ql_fclose(filep);
|
|
|
|
ql_rtos_task_sleep_s(5);
|
|
|
|
// 创建一个zip文件头
|
|
hzs = ql_fs_zip_create(unZipFilePaths1, 0, &ret);
|
|
|
|
if (ret < 0)
|
|
{
|
|
printf("create empty.zip:[%s] Failed,errcode=%d\r\n", unZipFilePaths1, ret);
|
|
printf("------------------\n");
|
|
ql_fs_zip_close(hzs);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
printf(("create empty.zip:[%s] Success\r\n", unZipFilePaths1));
|
|
}
|
|
|
|
ret = ql_fs_zip_add_file(hzs, zipNAME1, zipFilePath1);
|
|
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("add [%s] to zip Failed\r\n", zipFilePath1);
|
|
ql_fs_zip_close(hzs);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
printf("add [%s] to zip Success\r\n", zipFilePath1);
|
|
}
|
|
|
|
ql_fs_zip_close(hzs);
|
|
|
|
// printf("add to zip Success\r\n");
|
|
ql_rtos_task_sleep_s(5);
|
|
printf("========== start unzip file[%d]==========\r\n");
|
|
|
|
ret = ql_fs_unzip(unZipFilePaths1, unZip_paths1, 1);
|
|
|
|
if (ret != QL_FILE_OK)
|
|
{
|
|
printf("unzip file:[%s] Failed\r\n", unZipFilePaths1);
|
|
return;
|
|
}
|
|
printf("unzip file:[%s] Success\r\n", unZipFilePaths1);
|
|
|
|
#if 0
|
|
printf("========== start read zip file==========\r\n");
|
|
|
|
filep =ql_fopen(unZipFilePaths1, "rb");
|
|
|
|
if(filep==NULL){
|
|
printf("littfss_fx_file_open is failede.!!\n");
|
|
return;
|
|
}
|
|
|
|
ret=ql_fread(read_buf, sizeof(read_buf), 1, filep);
|
|
|
|
ql_fclose(filep);
|
|
|
|
printf("read file size is %d\r\n",ret);
|
|
|
|
printf("data:");
|
|
for(int i=0;i<sizeof(read_buf);i++){
|
|
printf("%x",read_buf[i]);
|
|
}
|
|
printf("\r\n");
|
|
#endif
|
|
}
|
|
|
|
// application_init(ql_unzip_demo_test, "ql_zipdemo", 32, 0);
|
|
|
|
//application_init(nand_zip_test, "nand_zip_test", 10, 0);
|
|
|
|
//application_init(littfs_zip_test, "littfs_zip_test", 10, 0);
|
|
|
|
// application_init(ql_zip_demo_thread,"ql_zip_demo_thread",10,0);
|
|
|
|
//application_init(nand_unzip_test, "nand_unzip_test", 10, 0);
|
|
|
|
// application_init(test_seek, "test_seek", 10, 0);
|