3945 lines
93 KiB
C
3945 lines
93 KiB
C
|
||
#define _IN_DATAFILE_C
|
||
#include "datafile.h"
|
||
|
||
#include "math.h"
|
||
#include "crc16.h"
|
||
#include "norflash.h"
|
||
#include "inout.h"
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
|
||
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
|
||
// 数据文件
|
||
#if (1)
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
// 用外部SRAM保存文件
|
||
// 文件内容
|
||
|
||
#define DS16ITEMSIZE (DATA_FILE_SIZE/sizeof(Ds16Item))
|
||
#define DS8ITEMSIZE (DATA_FILE_SIZE/sizeof(Ds8Item))
|
||
#define DS4ITEMSIZE (DATA_FILE_SIZE/sizeof(Ds4Item))
|
||
|
||
#define DS16ITEMSIZE_AT_BUF1 (DATA_FILE_SIZE1/sizeof(Ds16Item))
|
||
#define DS8ITEMSIZE_AT_BUF1 (DATA_FILE_SIZE1/sizeof(Ds8Item))
|
||
#define DS4ITEMSIZE_AT_BUF1 (DATA_FILE_SIZE1/sizeof(Ds4Item))
|
||
|
||
// 边框刺绣数据文件
|
||
#define DS16FRAMESIZE (DATA_FILE_SIZE3/sizeof(Ds16Item))
|
||
#define DS8FRAMESIZE (DATA_FILE_SIZE3/sizeof(Ds8Item))
|
||
#define DS4FRAMESIZE (DATA_FILE_SIZE3/sizeof(Ds4Item))
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
// 用外部串行 NOR Flash 保存文件
|
||
|
||
// FLASH 文件存放地址
|
||
#define NOR_FILE_BASE SNF_DAT_FILE_BEGIN // 存放文件区域 16M 字节
|
||
|
||
// 文件区域划分
|
||
// |-----------------|-----------------|-------------|
|
||
// | name | begin addr | size |
|
||
// |-----------------|-----------------|-------------|
|
||
// | file data area | 0x00 | 0x00FFE000 | 文件内容区域
|
||
// |-----------------|-----------------|-------------|
|
||
// | file manage | 0x00FFE000 | 0x00001000 | 文件管理区域，占用1个扇区
|
||
// |-----------------|-----------------|-------------|
|
||
|
||
|
||
#define NOR_FILE_DATA (NOR_FILE_BASE + 0x00000000)
|
||
#define MAX_NOR_FILE_SIZE (SNF_DAT_FILE_SIZE - SNF_BYTES_PER_SEC)
|
||
|
||
#define NOR_DAT_MANAGE (NOR_FILE_BASE + MAX_NOR_FILE_SIZE)
|
||
|
||
|
||
#define DS16SIZEINNOR (MAX_NOR_FILE_SIZE/sizeof(Ds16Item))
|
||
#define DS8SIZEINNOR (MAX_NOR_FILE_SIZE/sizeof(Ds8Item ))
|
||
#define DS4SIZEINNOR (MAX_NOR_FILE_SIZE/sizeof(Ds4Item ))
|
||
|
||
|
||
// FLASH 平均损耗算法（用循环利用法来减少针对扇区的擦除）
|
||
|
||
// 共16M的文件存储区域
|
||
// 以4K（扇区）为文件分配的基本单位，共4096个扇区。
|
||
// 用一个字节代表一个扇区，用于指示扇区的利用情况，共4096个字节。
|
||
// 因为数据是循环存储在扇区列表中的。
|
||
// 所以规定，字节数组中最大的值代表了扇区分配的开始（循环队列的开始）。
|
||
// 例如擦除后，全部为0xff，那么第0个扇区就是第一个开始利用的扇区。
|
||
// 如果第一次存储文件时占用了10个扇区，那么从第0个到第9个扇区对应的字节写为0x7F。
|
||
// 接下来存储文件时要占用5个扇区，那么从第10个到第14个对应的字节设置为0x7F。
|
||
// 以此类推，如果所有字节被写为0x7F，那么接下来的字节就要被写作0x3F。
|
||
// 循环队列每循环一次，写入的字节的数移动一个位，直到写入字节变为0x00。
|
||
// 如果所有字节都变成0x00，那么这个记录扇区就需要擦除。
|
||
|
||
// 这个记录扇区的作用是保证所有扇区的擦除次数尽量均匀，延长使用寿命。
|
||
|
||
#define NOR_DAT_SEC_BEG 0
|
||
#define NOR_DAT_SEC_NUM (MAX_NOR_FILE_SIZE / (SNF_BYTES_PER_SEC))
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
typedef struct
|
||
{
|
||
u8 wrflag; // 写入的记录字节
|
||
int begSecIdx; // 循环队列的起始索引
|
||
int queueSecNum; // 循环队列的长度,分配的扇区个数
|
||
int releaseFlag; // 释放标志
|
||
}NorSectorManager;
|
||
|
||
NorSectorManager g_norManager;
|
||
|
||
void InitNorSectorManage(void)
|
||
{
|
||
int i, idx;
|
||
u8 flag;
|
||
u8 rdata[SNF_BYTES_PER_SEC];
|
||
memset(&g_norManager, 0, sizeof(NorSectorManager));
|
||
|
||
DatFlashRdData(NOR_DAT_MANAGE, rdata, SNF_BYTES_PER_SEC); // 读取一个扇区
|
||
|
||
// 扫描管理扇区，得到最大的flag值
|
||
flag = 0;
|
||
for (i = 0, idx = 0; i < NOR_DAT_SEC_NUM; i++) // NOR_DAT_SEC_NUM 4095
|
||
{
|
||
if (flag < rdata[i])
|
||
{
|
||
flag = rdata[i]; // 取最大值,得到写入的最大记录字节
|
||
idx = i;
|
||
}
|
||
}
|
||
|
||
if (flag == 0)
|
||
{
|
||
// 擦除扇区
|
||
printf("Erase NOR_DAT_MANAGE\r\n");
|
||
DatFlash4kErase(NOR_DAT_MANAGE, 1);
|
||
flag = 0xff;
|
||
idx = 0;
|
||
}
|
||
|
||
flag >>= 1; //
|
||
|
||
g_norManager.wrflag = flag;
|
||
g_norManager.begSecIdx = idx;
|
||
g_norManager.queueSecNum = 0;
|
||
g_norManager.releaseFlag = 0;
|
||
|
||
// printf("InitNorSectorManage, wrflag=0x%x, begSecIdx=%d, queueSecNum=%d\r\n", g_norManager.wrflag, g_norManager.begSecIdx, g_norManager.queueSecNum);
|
||
}
|
||
|
||
// 通过扇区索引，得到扇区地址
|
||
u32 GetAddrFromSecIdx(int sidx)
|
||
{
|
||
sidx += g_norManager.begSecIdx;
|
||
while (sidx >= NOR_DAT_SEC_NUM)
|
||
{
|
||
sidx -= NOR_DAT_SEC_NUM;
|
||
}
|
||
return NOR_FILE_DATA + sidx * (SNF_BYTES_PER_SEC);
|
||
}
|
||
|
||
// 通过数据索引和数据大小，得到数据首地址
|
||
u32 GetAddrFromDatIdx(int didx, int size)
|
||
{
|
||
u32 addr;
|
||
u32 sidx, sofst;
|
||
|
||
sidx = didx * size / (SNF_BYTES_PER_SEC); // 扇区逻辑地址
|
||
sofst = (didx * size) % (SNF_BYTES_PER_SEC); // 扇区内偏移
|
||
|
||
addr = GetAddrFromSecIdx(sidx) + sofst;
|
||
|
||
return addr;
|
||
}
|
||
|
||
u32 GetAddrFromLAddr(int laddr, int size)
|
||
{
|
||
u32 addr;
|
||
u32 sidx, sofst;
|
||
|
||
sidx = laddr / (SNF_BYTES_PER_SEC); // 扇区逻辑地址
|
||
sofst = laddr % (SNF_BYTES_PER_SEC); // 扇区内偏移
|
||
|
||
addr = GetAddrFromSecIdx(sidx) + sofst;
|
||
|
||
return addr;
|
||
}
|
||
|
||
// 根据占据内存，分配占用空间，设置标志
|
||
// allocBytes:需要分配的字节数
|
||
void NorAllocAndSetUsingFlags(int allocBytes)
|
||
{
|
||
int i, idx;
|
||
int alcsecs; // 占用扇区数
|
||
u8 rdata[SNF_BYTES_PER_SEC];
|
||
|
||
// 计算占用扇区数
|
||
alcsecs = allocBytes + (SNF_BYTES_PER_SEC-1);
|
||
alcsecs /= (SNF_BYTES_PER_SEC); // 占用扇区数
|
||
|
||
printf("NorAllocAndSetUsingFlags, allocbyte=%d, alcsecs=%d\r\n", allocBytes, alcsecs);
|
||
|
||
g_norManager.begSecIdx += g_norManager.queueSecNum;
|
||
while (g_norManager.begSecIdx >= NOR_DAT_SEC_NUM)
|
||
{
|
||
g_norManager.begSecIdx -= NOR_DAT_SEC_NUM;
|
||
}
|
||
|
||
printf("before alloc, begsecidx=%d, queuenum=%d, wrflag=0x%x\r\n", g_norManager.begSecIdx, g_norManager.queueSecNum, g_norManager.wrflag);
|
||
|
||
if (alcsecs > NOR_DAT_SEC_NUM)
|
||
{
|
||
printf("alcsecs=%d > %d\r\n", alcsecs, NOR_DAT_SEC_NUM);
|
||
alcsecs = NOR_DAT_SEC_NUM;
|
||
}
|
||
|
||
DatFlashRdData(NOR_DAT_MANAGE, rdata, SNF_BYTES_PER_SEC); // 读取记录字节
|
||
|
||
g_norManager.queueSecNum = 0;
|
||
for (i = 0, idx = g_norManager.begSecIdx; i < alcsecs; i++)
|
||
{
|
||
g_norManager.queueSecNum++; // 计数增加
|
||
|
||
// 设置标志
|
||
rdata[idx] = g_norManager.wrflag;
|
||
|
||
// 索引增加
|
||
idx++;
|
||
if (idx >= NOR_DAT_SEC_NUM)
|
||
{
|
||
idx = 0;
|
||
if (g_norManager.wrflag == 0)
|
||
{
|
||
DatFlash4kErase(NOR_DAT_MANAGE, 1);
|
||
memset(rdata, 0xff, SNF_BYTES_PER_SEC);
|
||
g_norManager.wrflag = 0xff;
|
||
printf("re erase dat manage\r\n");
|
||
}
|
||
|
||
g_norManager.wrflag >>= 1;
|
||
printf("nor alloc queue return to 0, wrflag=0x%x\r\n", g_norManager.wrflag);
|
||
}
|
||
}
|
||
|
||
if (g_norManager.queueSecNum != alcsecs) // 验证分配个数
|
||
{
|
||
printf("Error: g_norManager.queueSecNum not euq alcsecs\r\n");
|
||
}
|
||
|
||
printf("after alloc, begsecidx=%d, queuenum=%d, wrflag=0x%x\r\n", g_norManager.begSecIdx, g_norManager.queueSecNum, g_norManager.wrflag);
|
||
|
||
g_norManager.releaseFlag = 0;
|
||
DatFlashWrData(NOR_DAT_MANAGE, rdata, SNF_BYTES_PER_SEC);
|
||
}
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// 擦除数据，释放空间
|
||
// sync:同步标志 0,同步擦除 1,异步擦除
|
||
int ReleaseSpace(int sync)
|
||
{
|
||
static int eraseidx = -1; // 擦除ID
|
||
if (sync != 0 && eraseidx == -1)
|
||
{
|
||
eraseidx = 0;
|
||
g_norManager.releaseFlag = 1;
|
||
}
|
||
|
||
if (g_norManager.releaseFlag == 0)
|
||
{
|
||
eraseidx = 0;
|
||
g_norManager.releaseFlag++;
|
||
}
|
||
else if (g_norManager.releaseFlag == 1)
|
||
{
|
||
if (g_norManager.queueSecNum != 0) // 分配的扇区不为0
|
||
{
|
||
u32 eaddr;
|
||
int idx, erflag;
|
||
printf("ReleaseSpace, secnum=%d, eraseidx=%d, sync=%d\r\n", g_norManager.queueSecNum, eraseidx, sync);
|
||
|
||
for (idx = eraseidx; idx < g_norManager.queueSecNum; idx++)
|
||
{
|
||
eaddr = GetAddrFromSecIdx(idx);
|
||
erflag = IsDatFlashEmpty(eaddr, SNF_BYTES_PER_SEC);
|
||
if (erflag != 0)
|
||
{
|
||
printf("DatFlash4kErase eaddr=0x%x\r\n", eaddr);
|
||
DatFlash4kErase(eaddr, 1);
|
||
}
|
||
if (sync == 0)
|
||
{
|
||
idx++;
|
||
break;
|
||
}
|
||
}
|
||
eraseidx = idx;
|
||
if (eraseidx >= g_norManager.queueSecNum)
|
||
{
|
||
eraseidx = -1;
|
||
g_norManager.releaseFlag = 2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
g_norManager.releaseFlag = -1; // 小数据文件,不使用norflash,无需擦除
|
||
}
|
||
}
|
||
return g_norManager.releaseFlag;
|
||
}
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// 数据存储在上位机（通过网络动态传输）
|
||
|
||
|
||
int GetADataItem(u8 fileBlk, u32 idx, DataItem * pDat)
|
||
{
|
||
return GetADataItemBase(fileBlk, idx, pDat, 1);
|
||
}
|
||
|
||
int GetADataItemNoSqrt(u8 fileBlk, u32 idx, DataItem * pDat)
|
||
{
|
||
return GetADataItemBase(fileBlk, idx, pDat, 0);
|
||
}
|
||
|
||
//-------------------------------------------------------------------------------
|
||
/* return : 0:正常
|
||
* -1:参数错误或文件存储方式不支持或数据格式不支持
|
||
* -2:没有找到索引值idx
|
||
* para:fileBlk,暂时无用
|
||
* sqrtflag,是否平方根计算len,较耗时
|
||
*/
|
||
int GetADataItemBase(u8 fileBlk, u32 idx, DataItem * pDat, int sqrtflag)
|
||
{
|
||
u32 address;
|
||
|
||
// 20231115
|
||
if (idx >= g_datFile.pFileHead->fileHead.itemNums)
|
||
{
|
||
printf("GetADataItem error, idx=%d > %d\r\n", idx, g_datFile.pFileHead->fileHead.itemNums);
|
||
return -1;
|
||
}
|
||
|
||
if (pDat == NULL)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds16Item)) // Ds16数据
|
||
{
|
||
if (g_datFile.storage == STORAGE_EXSRAM) // 文件存储在存储在SRAM中
|
||
{
|
||
if (idx >= DS16ITEMSIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(DataItem));
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds16Item * pDs16Item;
|
||
|
||
if (idx < DS16ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs16Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs16Item += (idx - DS16ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs16Item, sizeof(Ds16Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SPAREARAM) // 边框刺绣数据文件(也包括花样轮廓和开位线绣)
|
||
{
|
||
if (idx >= DS16FRAMESIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(DataItem));
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds16Item * pDs16Item;
|
||
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff3BegAddr);
|
||
pDs16Item += idx;
|
||
}
|
||
memcpy(pDat, pDs16Item, sizeof(Ds16Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH) // 文件存储在NORFlash中
|
||
{
|
||
u32 daddr;
|
||
if (idx >= DS16SIZEINNOR)
|
||
{
|
||
memset(pDat, 0, sizeof(DataItem));
|
||
return -1;
|
||
}
|
||
daddr = NOR_FILE_DATA+idx*sizeof(Ds16Item);
|
||
address = (u32)pDat;
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds16Item));
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS16ITEMSIZE+DS16SIZEINNOR))
|
||
{
|
||
memset(pDat, 0, sizeof(DataItem));
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS16ITEMSIZE)
|
||
{
|
||
Ds16Item * pDs16Item;
|
||
|
||
if (idx < DS16ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs16Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs16Item += (idx - DS16ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs16Item, sizeof(Ds16Item));
|
||
}
|
||
else
|
||
{
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS16ITEMSIZE, sizeof(Ds16Item));
|
||
address = (u32)pDat;
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds16Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
int i;
|
||
u32 dataddr;
|
||
|
||
for (i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
dataddr = idx * sizeof(Ds16Item); // 数据在文件中的地址
|
||
|
||
if ((dataddr >= g_datFile.pDatExCtrl->datExBeg[i]) &&
|
||
(dataddr < g_datFile.pDatExCtrl->datExBeg[i]+DAT_BLOCK_SIZE) ) // 在范围内，命中
|
||
{
|
||
dataddr -= g_datFile.pDatExCtrl->datExBeg[i]; // 数据在块内的地址（相对地址）
|
||
dataddr += (s32)(&(g_datFile.pDatExCtrl->datExBlock[i])); // 数据在缓冲区的地址（实际地址）
|
||
|
||
memcpy(pDat, (u8*)dataddr, sizeof(DataItem));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (i == FILE_EXBUF_NUM)
|
||
{
|
||
printf("not found the data of idx=%d\r\n", idx);
|
||
return -2;
|
||
}
|
||
}
|
||
else // 不支持的存储方式
|
||
{
|
||
printf("error2, not support storage\r\n");
|
||
return -1;
|
||
}
|
||
}
|
||
else if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds8Item)) // Ds8数据
|
||
{
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
if (idx >= DS8ITEMSIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds8Item));
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds8Item * pDs8Item;
|
||
|
||
if (idx < DS8ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs8Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs8Item += (idx - DS8ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs8Item, sizeof(Ds8Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SPAREARAM)
|
||
{
|
||
if (idx >= DS8FRAMESIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds8Item));
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds8Item * pDs8Item;
|
||
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff3BegAddr);
|
||
pDs8Item += idx;
|
||
}
|
||
memcpy(pDat, pDs8Item, sizeof(Ds8Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
u32 daddr;
|
||
if (idx >= DS8SIZEINNOR)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds8Item));
|
||
return -1;
|
||
}
|
||
daddr = NOR_FILE_DATA+idx*sizeof(Ds8Item);
|
||
address = (u32)pDat;
|
||
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds8Item));
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS8ITEMSIZE+DS8SIZEINNOR))
|
||
{
|
||
memset(pDat, 0, sizeof(Ds8Item));
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS8ITEMSIZE)
|
||
{
|
||
Ds8Item * pDs8Item;
|
||
|
||
if (idx < DS8ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs8Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs8Item += (idx - DS8ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs8Item, sizeof(Ds8Item));
|
||
}
|
||
else
|
||
{
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS8ITEMSIZE, sizeof(Ds8Item));
|
||
address = (u32)pDat;
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds8Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
int i;
|
||
u32 dataddr;
|
||
|
||
for (i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
dataddr = idx * sizeof(Ds8Item); // 数据在文件中的地址
|
||
|
||
if ((dataddr >= g_datFile.pDatExCtrl->datExBeg[i]) &&
|
||
(dataddr < g_datFile.pDatExCtrl->datExBeg[i]+DAT_BLOCK_SIZE) ) // 在范围内，命中
|
||
{
|
||
dataddr -= g_datFile.pDatExCtrl->datExBeg[i]; // 数据在块内的地址（相对地址）
|
||
dataddr += (s32)(&(g_datFile.pDatExCtrl->datExBlock[i])); // 数据在缓冲区的地址（实际地址）
|
||
|
||
memcpy(pDat, (u8*)dataddr, sizeof(Ds8Item));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (i == FILE_EXBUF_NUM)
|
||
{
|
||
printf("not found the data of idx=%d\r\n", idx);
|
||
return -2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
#if (1)
|
||
if (sqrtflag != 0)
|
||
{
|
||
pDat->len = sqrt(pDat->dx*pDat->dx + pDat->dy*pDat->dy);
|
||
}
|
||
#else
|
||
pDat->len = 0;
|
||
#endif
|
||
// memset(pDat->rev, 0, 6);
|
||
}
|
||
else if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds4Item))
|
||
{
|
||
Ds4Item dsr;
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
if (idx >= DS4ITEMSIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds4Item));
|
||
return -1;
|
||
}
|
||
|
||
Ds4Item * pDs4Item = &dsr;
|
||
|
||
if (idx < DS4ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs4Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs4Item += (idx - DS4ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs4Item, sizeof(Ds4Item));
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SPAREARAM)
|
||
{
|
||
if (idx >= DS4FRAMESIZE)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds4Item));
|
||
return -1;
|
||
}
|
||
|
||
Ds4Item * pDs4Item = &dsr;
|
||
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff3BegAddr);
|
||
pDs4Item += idx;
|
||
}
|
||
memcpy(pDat, pDs4Item, sizeof(Ds4Item));
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
u32 daddr;
|
||
if (idx >= DS4SIZEINNOR)
|
||
{
|
||
memset(pDat, 0, sizeof(Ds4Item));
|
||
return -1;
|
||
}
|
||
daddr = NOR_FILE_DATA+idx*sizeof(Ds4Item);
|
||
address = (u32)(&dsr);
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds4Item));
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS4ITEMSIZE+DS4SIZEINNOR))
|
||
{
|
||
memset(pDat, 0, sizeof(Ds4Item));
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS4ITEMSIZE)
|
||
{
|
||
Ds4Item * pDs4Item = &dsr;
|
||
|
||
if (idx < DS4ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs4Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs4Item += (idx - DS4ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs4Item, sizeof(Ds4Item));
|
||
}
|
||
else
|
||
{
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS4ITEMSIZE, sizeof(Ds4Item));
|
||
address = (u32)(&dsr);
|
||
DatFlashRdData(daddr, (u8*)(address), sizeof(Ds4Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
int i;
|
||
u32 dataddr;
|
||
|
||
for (i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
dataddr = idx * sizeof(Ds4Item); // 数据在文件中的地址
|
||
|
||
if ((dataddr >= g_datFile.pDatExCtrl->datExBeg[i]) &&
|
||
(dataddr < g_datFile.pDatExCtrl->datExBeg[i]+DAT_BLOCK_SIZE) ) // 在范围内，命中
|
||
{
|
||
dataddr -= g_datFile.pDatExCtrl->datExBeg[i]; // 数据在块内的地址（相对地址）
|
||
dataddr += (s32)(&(g_datFile.pDatExCtrl->datExBlock[i])); // 数据在缓冲区的地址（实际地址）
|
||
|
||
memcpy(&dsr, (u8*)dataddr, sizeof(Ds4Item));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (i == FILE_EXBUF_NUM)
|
||
{
|
||
printf("not found the data of idx=%d\r\n", idx);
|
||
return -2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
pDat->ctrl = dsr.ctrl;
|
||
pDat->attr = 0;
|
||
pDat->dx = dsr.dx;
|
||
pDat->dy = dsr.dx;
|
||
pDat->dr = 0;
|
||
|
||
// 方向属性
|
||
if ((dsr.attr & 0x80) != 0)
|
||
{
|
||
pDat->dx *= -10;
|
||
}
|
||
else
|
||
{
|
||
pDat->dx *= 10;
|
||
}
|
||
|
||
if ((dsr.attr & 0x40) != 0)
|
||
{
|
||
pDat->dy *= -10;
|
||
}
|
||
else
|
||
{
|
||
pDat->dy *= 10;
|
||
}
|
||
|
||
// 其他属性...
|
||
|
||
#if (1)
|
||
if (sqrtflag != 0)
|
||
{
|
||
pDat->len = sqrt(pDat->dx*pDat->dx + pDat->dy*pDat->dy);
|
||
}
|
||
#else
|
||
pDat->len = 0;
|
||
#endif
|
||
// memset(pDat->rev, 0, 6);
|
||
}
|
||
else // 非Ds16,Ds8,Ds4
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int WriteADataItem(u8 fileBlk, u32 idx, DataItem * pDat)
|
||
{
|
||
if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds16Item))
|
||
{
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
if (idx > DS16ITEMSIZE ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds16Item * pDs16Item;
|
||
|
||
if (idx < DS16ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs16Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs16Item += (idx - DS16ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDs16Item, pDat, sizeof(Ds16Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
return -1;
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS16ITEMSIZE+DS16SIZEINNOR) ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS16ITEMSIZE)
|
||
{
|
||
Ds16Item * pDs16Item;
|
||
|
||
if (idx < DS16ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs16Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs16Item = (Ds16Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs16Item += (idx - DS16ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDs16Item, pDat, sizeof(Ds16Item));
|
||
}
|
||
else
|
||
{
|
||
/* // 不支持写入单个针步......
|
||
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS16ITEMSIZE, sizeof(Ds16Item));
|
||
address = (u32)pDat;
|
||
|
||
NFlashWrData(daddr, (u16*)address, sizeof(Ds16Item)/2);
|
||
*/
|
||
return -1;
|
||
}
|
||
|
||
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
}
|
||
else if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds8Item))
|
||
{
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
if (idx > DS8ITEMSIZE ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds8Item * pDs8Item;
|
||
|
||
if (idx < DS8ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs8Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs8Item += (idx - DS8ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDs8Item, pDat, sizeof(Ds8Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
return -1;
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS8ITEMSIZE+DS8SIZEINNOR) ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS8ITEMSIZE)
|
||
{
|
||
Ds8Item * pDs8Item;
|
||
|
||
if (idx < DS8ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs8Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs8Item = (Ds8Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs8Item += (idx - DS8ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDs8Item, pDat, sizeof(Ds8Item));
|
||
}
|
||
else
|
||
{
|
||
/* // 不支持单个针步写入
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS8ITEMSIZE, sizeof(Ds8Item));
|
||
address = (u32)pDat;
|
||
NFlashWrData(daddr, (u16*)address, sizeof(Ds8Item)/2);
|
||
*/
|
||
return -1;
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
}
|
||
else if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(Ds4Item))
|
||
{
|
||
Ds4Item dsr;
|
||
|
||
dsr.ctrl = pDat->ctrl;
|
||
dsr.attr = pDat->attr;
|
||
dsr.dx = pDat->dx / 10;
|
||
dsr.dx = pDat->dy / 10;
|
||
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
if (idx >= (DS4ITEMSIZE) ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
Ds4Item * pDs4Item = &dsr;
|
||
|
||
if (idx < DS4ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs4Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs4Item += (idx - DS4ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDs4Item, pDat, sizeof(Ds4Item));
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
return -1;
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
if (idx >= (DS4ITEMSIZE+DS4SIZEINNOR) ||
|
||
pDat == NULL ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (idx < DS4ITEMSIZE)
|
||
{
|
||
Ds4Item * pDs4Item = &dsr;
|
||
|
||
if (idx < DS4ITEMSIZE_AT_BUF1)
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff1BegAddr);
|
||
pDs4Item += idx;
|
||
}
|
||
else
|
||
{
|
||
pDs4Item = (Ds4Item*)(g_datFile.dataBuff2BegAddr);
|
||
pDs4Item += (idx - DS4ITEMSIZE_AT_BUF1);
|
||
}
|
||
memcpy(pDat, pDs4Item, sizeof(Ds4Item));
|
||
}
|
||
else
|
||
{
|
||
/* // 不支持单个针步写入
|
||
u32 daddr;
|
||
daddr = GetAddrFromDatIdx(idx-DS4ITEMSIZE, sizeof(Ds4Item));
|
||
address = (u32)(&dsr);
|
||
NFlashWrData(daddr, (u16*)(address), sizeof(Ds4Item)/2);
|
||
*/
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
// begaddr 逻辑存储地址
|
||
int WriteFileData(u8 fileBlk, u32 begaddr, u8 * pBuf, u32 size)
|
||
{
|
||
if (pBuf == NULL)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
u8 * pData;
|
||
if (begaddr+size <= g_datFile.dataBuff1Len)
|
||
{
|
||
pData = (u8 *)(g_datFile.dataBuff1BegAddr + begaddr);
|
||
}
|
||
else if (begaddr+size <= g_datFile.dataBuff1Len+g_datFile.dataBuff2Len)
|
||
{
|
||
pData = (u8 *)(g_datFile.dataBuff2BegAddr + begaddr - g_datFile.dataBuff1Len);
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
// printf("WriteFileData from 0x%x to 0x%x, size=%d\r\n", (u32)pBuf, (u32)pData, size);
|
||
memcpy(pData, pBuf, size);
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SPAREARAM)
|
||
{
|
||
u8 * pData;
|
||
if (begaddr+size <= g_datFile.dataBuff3Len)
|
||
{
|
||
pData = (u8 *)(g_datFile.dataBuff3BegAddr + begaddr);
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
// printf("WriteFileData from 0x%x to 0x%x, size=%d\r\n", (u32)pBuf, (u32)pData, size);
|
||
memcpy(pData, pBuf, size);
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
if ((begaddr+size) > DS16SIZEINNOR*sizeof(Ds16Item) ||
|
||
0 )
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
DatFlashWrDataWithErase(NOR_FILE_DATA+begaddr, (u8*)pBuf, size);
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
u8 * pData;
|
||
|
||
if (begaddr+size <= g_datFile.dataBuff1Len)
|
||
{
|
||
pData = (u8 *)(g_datFile.dataBuff1BegAddr + begaddr);
|
||
memcpy(pData, pBuf, size);
|
||
// printf("WriteFileData from 0x%x to 0x%x, size=%d\r\n", (u32)pBuf, (u32)pData, size);
|
||
}
|
||
else if (begaddr+size <= g_datFile.dataBuff1Len+g_datFile.dataBuff2Len)
|
||
{
|
||
pData = (u8 *)(g_datFile.dataBuff2BegAddr + begaddr - g_datFile.dataBuff1Len);
|
||
memcpy(pData, pBuf, size);
|
||
// printf("WriteFileData from 0x%x to 0x%x, size=%d\r\n", (u32)pBuf, (u32)pData, size);
|
||
}
|
||
else if (begaddr+size <= g_datFile.dataBuff1Len+g_datFile.dataBuff2Len+MAX_NOR_FILE_SIZE)
|
||
{
|
||
u32 daddr;
|
||
|
||
// ReleaseSpace(1);
|
||
|
||
daddr = GetAddrFromLAddr(begaddr-(g_datFile.dataBuff1Len+g_datFile.dataBuff2Len), size);
|
||
DatFlashWrDataWithErase(daddr, (u8*)pBuf, size);
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
u32 blkidx, blkaddr;
|
||
int bufidx;
|
||
if ((size) != DAT_BLOCK_SIZE || // 只能存储1个数据包的大小
|
||
(begaddr) >= g_datFile.pFileHead->fileHead.dataSize ||
|
||
0 )
|
||
{
|
||
printf("(size=%d) != DAT_BLOCK_SIZE or (begaddr=%d) > (dataSize=%d)\r\n", size, begaddr, g_datFile.pFileHead->fileHead.dataSize);
|
||
return -1;
|
||
}
|
||
|
||
// 计算当前数据包在整个数据中的起始地址
|
||
blkidx = begaddr / DAT_BLOCK_SIZE; // 块号
|
||
blkaddr = blkidx * DAT_BLOCK_SIZE; // 块地址
|
||
if (blkaddr != begaddr)
|
||
{
|
||
printf("(blkaddr=%d) != (begaddr=%d)\r\n", blkaddr, begaddr);
|
||
return -1;
|
||
}
|
||
|
||
// 找到无效buf作为新数据存储区域
|
||
bufidx = -1;
|
||
for (int i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID && g_datFile.pDatExCtrl->datExBeg[i] == blkaddr) // 已存储区域有相同的存储地址
|
||
{
|
||
printf("save dat to same addr, blkidx=%d\r\n", blkidx);
|
||
// 数据存在时不再重复存储
|
||
break;
|
||
}
|
||
else if (g_datFile.pDatExCtrl->exbufFlag[i] == 0)
|
||
{
|
||
bufidx = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (bufidx >= 0 && bufidx < FILE_EXBUF_NUM)
|
||
{
|
||
u8 * pData;
|
||
g_datFile.pDatExCtrl->exbufFlag[bufidx] = DATA_VALID; // 增加标志计数
|
||
g_datFile.pDatExCtrl->datExBeg[bufidx] = blkaddr; // 记录起始地址
|
||
pData = (u8*)(&(g_datFile.pDatExCtrl->datExBlock[bufidx])); // 数据在buff中的实际地址
|
||
memcpy(pData, pBuf, size);
|
||
printf("save data bldidx=%d begaddr=0x%x to bufidx=%d\r\n", blkidx, begaddr, bufidx);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 判断数据是否在缓冲区中
|
||
// return:0,索引不在当前存储范围内
|
||
int IsDatIdxInBuf(int idx)
|
||
{
|
||
int i;
|
||
u32 dataddr;
|
||
int rslt = 0;
|
||
|
||
if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
if ((g_datFile.enflag == DATA_VALID) &&
|
||
(g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(DataItem)) &&
|
||
1 )
|
||
{
|
||
// 当前索引的数据需要在缓冲区中
|
||
if (idx >= 0 || idx < (s32)g_datFile.pFileHead->fileHead.itemNums)
|
||
{
|
||
for (i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
dataddr = idx * sizeof(DataItem); // 数据在文件中的地址
|
||
|
||
if ((dataddr >= g_datFile.pDatExCtrl->datExBeg[i]) &&
|
||
(dataddr < g_datFile.pDatExCtrl->datExBeg[i]+DAT_BLOCK_SIZE) ) // 在范围内，命中
|
||
{
|
||
rslt = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rslt = 1;
|
||
}
|
||
return rslt;
|
||
}
|
||
|
||
#define MAX_IDX_RANGE 7
|
||
#define MIN_IDX_RANGE 3 // 请求范围 向后:向前 7:3 当前索引所在数据块计入向后部分
|
||
|
||
// 根据索引来预先装载文件数据
|
||
int GetBlockIdxNeedtoLoad(int datidx)
|
||
{
|
||
int curidx, curaddr, minaddr, maxaddr, maxblkaddr, tempaddr;
|
||
int requestIdx = -1;
|
||
int rslt;
|
||
|
||
if (g_datFile.pFileHead->fileHead.bytesPerItem == sizeof(DataItem))
|
||
{
|
||
curidx = datidx;
|
||
if (curidx < 0)
|
||
{
|
||
curidx = 0;
|
||
}
|
||
else if (curidx >= g_datFile.pFileHead->fileHead.itemNums)
|
||
{
|
||
curidx = g_datFile.pFileHead->fileHead.itemNums - 1;
|
||
}
|
||
|
||
curaddr = curidx * sizeof(Ds16Item); // 当前索引在文件内的地址
|
||
curaddr /= DAT_BLOCK_SIZE;
|
||
curaddr *= DAT_BLOCK_SIZE; // 计算当前索引所在数据块起始地址
|
||
|
||
minaddr = curaddr - FILE_EXBUF_NUM * MIN_IDX_RANGE / 10 * DAT_BLOCK_SIZE;
|
||
if (minaddr < 0)
|
||
{
|
||
minaddr = 0;
|
||
}
|
||
|
||
maxblkaddr = (g_datFile.pFileHead->fileHead.itemNums - 1) * sizeof(Ds16Item);
|
||
maxblkaddr /= DAT_BLOCK_SIZE;
|
||
maxblkaddr *= DAT_BLOCK_SIZE;
|
||
|
||
maxaddr = curaddr + (FILE_EXBUF_NUM * MAX_IDX_RANGE / 10 - 1) * DAT_BLOCK_SIZE;
|
||
if (maxaddr > maxblkaddr)
|
||
{
|
||
maxaddr = maxblkaddr;
|
||
}
|
||
|
||
for (int i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
if (g_datFile.pDatExCtrl->datExBeg[i] < minaddr ||
|
||
g_datFile.pDatExCtrl->datExBeg[i] > maxaddr ||
|
||
0)
|
||
{
|
||
g_datFile.pDatExCtrl->exbufFlag[i] = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
tempaddr = curaddr;
|
||
while(tempaddr <= maxaddr)
|
||
{
|
||
rslt = 0;
|
||
for (int i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
if (tempaddr == g_datFile.pDatExCtrl->datExBeg[i])
|
||
{
|
||
rslt = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (rslt == 0)
|
||
{
|
||
requestIdx = tempaddr;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
tempaddr += DAT_BLOCK_SIZE;
|
||
}
|
||
}
|
||
|
||
if (requestIdx < 0)
|
||
{
|
||
tempaddr = curaddr;
|
||
while(tempaddr >= minaddr)
|
||
{
|
||
rslt = 0;
|
||
for (int i = 0; i < FILE_EXBUF_NUM; i++)
|
||
{
|
||
if (g_datFile.pDatExCtrl->exbufFlag[i] == DATA_VALID)
|
||
{
|
||
if (tempaddr == g_datFile.pDatExCtrl->datExBeg[i])
|
||
{
|
||
rslt = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (rslt == 0)
|
||
{
|
||
requestIdx = tempaddr;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
tempaddr -= DAT_BLOCK_SIZE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (requestIdx >= 0)
|
||
{
|
||
requestIdx /= DAT_BLOCK_SIZE;
|
||
}
|
||
|
||
return requestIdx;
|
||
}
|
||
|
||
void OutFileInfo(void)
|
||
{
|
||
printf("\r\ndata file info:\r\n");
|
||
|
||
printf("\tenflag=0x%x, storage=0x%x, ", g_datFile.enflag, g_datFile.storage);
|
||
if (g_datFile.storage == STORAGE_EXSRAM)
|
||
{
|
||
printf("data store at exsram\r\n");
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NORFLASH)
|
||
{
|
||
printf("data store at norflash\r\n");
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NANDFLASH)
|
||
{
|
||
printf("data store at nandflash\r\n");
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SRAMANDNOR)
|
||
{
|
||
printf("data store at exsram and norflash\r\n");
|
||
}
|
||
else if (g_datFile.storage == STORAGE_NETWORK)
|
||
{
|
||
printf("data store at network\r\n");
|
||
}
|
||
else if (g_datFile.storage == STORAGE_SPAREARAM)
|
||
{
|
||
printf("data store at frame exram\r\n");
|
||
}
|
||
else
|
||
{
|
||
printf("not support storage type\r\n");
|
||
}
|
||
|
||
printf("\r\n\tfilehead:\r\n");
|
||
printf("\tfilename=%s\r\n", g_datFile.pFileHead->fileHead.fileName);
|
||
printf("\tfilelen=%d,itemnums=%d,bytesperitem=%d,bytesperblk=%d\r\n", \
|
||
g_datFile.pFileHead->fileHead.dataSize, g_datFile.pFileHead->fileHead.itemNums, g_datFile.pFileHead->fileHead.bytesPerItem, g_datFile.pFileHead->fileHead.bytesPerBlk);
|
||
printf("\tchecksum=0x%x,checkCrc=0x%x\r\n", g_datFile.pFileHead->fileHead.dataChecksum, g_datFile.pFileHead->fileHead.checkCrc);
|
||
|
||
printf("\tbegHead=%d\r\n", g_datFile.pFileHead->fileHead.begHead);
|
||
|
||
printf("\tfileID=0x%x\r\n", g_datFile.pFileHead->fileHead.fileid);
|
||
|
||
printf("\tanchorx=%d,anchory=%d,\r\n\tbeginx=%d,beginy=%d,beginr=%d\r\n\tminx=%d,maxx=%d,miny=%d,maxy=%d\r\n", \
|
||
g_datFile.pFileHead->fileHead.anchorX, g_datFile.pFileHead->fileHead.anchorY, \
|
||
g_datFile.pFileHead->fileHead.beginX, g_datFile.pFileHead->fileHead.beginY, g_datFile.pFileHead->fileHead.beginR,\
|
||
g_datFile.pFileHead->fileHead.minX,g_datFile.pFileHead->fileHead.maxX,g_datFile.pFileHead->fileHead.minY,g_datFile.pFileHead->fileHead.maxY);
|
||
|
||
printf("\tanchorx2=%d,anchory2=%d,\r\n\tbeginx2=%d,beginy2=%d,beginr2=%d\r\n", \
|
||
g_datFile.pFileHead->fileHead.anchorX2, g_datFile.pFileHead->fileHead.anchorY2, \
|
||
g_datFile.pFileHead->fileHead.beginX2, g_datFile.pFileHead->fileHead.beginY2, g_datFile.pFileHead->fileHead.beginR2);
|
||
|
||
printf("\tEnFlag=0x%x,offsetX=%d,offsetY=%d\r\n", g_datFile.pFileHead->fileHead.EnFlag,
|
||
g_datFile.pFileHead->fileHead.offsetX, g_datFile.pFileHead->fileHead.offsetY);
|
||
|
||
printf("\txRepeatNums=%d,yRepeatNums=%d,xRepeatDistance=%d,yRepeatDistance=%d\r\n", g_datFile.pFileHead->fileHead.xRepeatNums,
|
||
g_datFile.pFileHead->fileHead.yRepeatNums, g_datFile.pFileHead->fileHead.xRepeatDistance, g_datFile.pFileHead->fileHead.yRepeatDistance);
|
||
}
|
||
|
||
//---------------------------------------------------------------------------------------------------------
|
||
// 判断文件是否有效
|
||
int IsDatFileAvailable(void)
|
||
{
|
||
if (g_datFile.enflag == DATA_VALID)
|
||
{
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
// 判断文件索引值是否有效
|
||
int IsDatIndexAvailable(u32 idx)
|
||
{
|
||
if (IsDatFileAvailable() == TRUE)
|
||
{
|
||
if (idx < (s32)g_datFile.pFileHead->fileHead.itemNums)
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
u32 GetFileItemNums(void)
|
||
{
|
||
return g_datFile.pFileHead->fileHead.itemNums;
|
||
}
|
||
|
||
s32 GetFileWide(void)//文件宽度
|
||
{
|
||
return (g_datFile.pFileHead->fileHead.maxX-g_datFile.pFileHead->fileHead.minX);
|
||
}
|
||
|
||
s32 GetFileHigh(void)//文件高度
|
||
{
|
||
return (g_datFile.pFileHead->fileHead.maxY-g_datFile.pFileHead->fileHead.minY);
|
||
}
|
||
|
||
// 文件失效
|
||
int InvalidDatFile(u32 idx)
|
||
{
|
||
printf("InvalidDatFile\r\n");
|
||
|
||
g_datFile.enflag = 0;
|
||
return TRUE;
|
||
}
|
||
|
||
int AvalidDatFile(u32 idx)
|
||
{
|
||
printf("AvalidDatFile\r\n");
|
||
|
||
g_datFile.enflag = DATA_VALID;
|
||
return TRUE;
|
||
}
|
||
|
||
// 数据块失效
|
||
void InvalidDatBlock(void)
|
||
{
|
||
printf("InvalidDatBlock\r\n");
|
||
|
||
memset(&(g_datFile.pDatExCtrl->exbufFlag[0]), 0, sizeof(int)*FILE_EXBUF_NUM); // 数据交换区域清空
|
||
}
|
||
|
||
void SetNewDatFlag(u32 idx, int en)
|
||
{
|
||
g_datFile.newFile = en;
|
||
}
|
||
|
||
int IsNewDatFile(u32 idx)
|
||
{
|
||
if (g_datFile.newFile != 0)
|
||
{
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
void ReSetFileParaOld(DataFilePara * pNewPara)
|
||
{
|
||
s32 tbx, tby;
|
||
tbx = pNewPara->beginX - g_datFile.pFileHead->fileHead.beginX;
|
||
tby = pNewPara->beginY - g_datFile.pFileHead->fileHead.beginY;
|
||
|
||
g_datFile.pFileHead->fileHead.minX += tbx;
|
||
g_datFile.pFileHead->fileHead.maxX += tbx;
|
||
g_datFile.pFileHead->fileHead.minY += tby;
|
||
g_datFile.pFileHead->fileHead.maxY += tby; // 起始点发生变化, 轮廓会跟着改变
|
||
|
||
g_datFile.pFileHead->fileHead.anchorX = pNewPara->anchorX;
|
||
g_datFile.pFileHead->fileHead.anchorY = pNewPara->anchorY;
|
||
g_datFile.pFileHead->fileHead.beginX = pNewPara->beginX;
|
||
g_datFile.pFileHead->fileHead.beginY = pNewPara->beginY;
|
||
|
||
SetNewDatFlag(0, TRUE);
|
||
}
|
||
|
||
|
||
void ReSetFilePara(DataFileHead * pNewPara)
|
||
{
|
||
printf("set new file para:\r\n\r\n");
|
||
|
||
#if (0)
|
||
printf("before set, filepara:\r\n");
|
||
OutFileInfo();
|
||
#endif
|
||
|
||
// 比较前面字节
|
||
|
||
// 拷贝参数部分
|
||
|
||
// 20210902 适配边框刺绣
|
||
//memcpy(g_datFile.pFileHead->headparts.fileparas, pNewPara->headparts.fileparas, sizeof(pNewPara->headparts.fileparas));
|
||
memcpy(g_datFile.pFileHead, pNewPara, sizeof(DataFileHead));
|
||
|
||
SetNewDatFlag(0, TRUE);
|
||
|
||
#if (0)
|
||
printf("after set, filepara:\r\n");
|
||
OutFileInfo();
|
||
#endif
|
||
}
|
||
|
||
// 文件参数校验
|
||
u16 GetFileParaCheckCrc(void)
|
||
{
|
||
u16 crc;
|
||
crc = 0;
|
||
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.anchorX, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.anchorY, sizeof(u32));
|
||
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginX, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginY, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginR, sizeof(u32));
|
||
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.minX, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.maxX, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.minY, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.maxY, sizeof(u32));
|
||
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.sizeX, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.sizeY, sizeof(u32));
|
||
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.anchorX2, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.anchorY2, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginX2, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginY2, sizeof(u32));
|
||
crc += CalcCrc16((u8*)&g_datFile.pFileHead->fileHead.beginR2, sizeof(u32));
|
||
|
||
return crc;
|
||
}
|
||
|
||
//-------------------------------------------------------------------------
|
||
|
||
void InitTempData(int type)
|
||
{
|
||
u8 * pData = NULL;
|
||
|
||
if (type == TEMP_DATA1)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA1_ADDR);
|
||
memset(pData, 0, TEMP_DATA1_SIZE);
|
||
}
|
||
else if (type == TEMP_DATA2)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA2_ADDR);
|
||
memset(pData, 0, TEMP_DATA2_SIZE);
|
||
}
|
||
else if (type == TEMP_DATA3)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA3_ADDR);
|
||
memset(pData, 0, TEMP_DATA3_SIZE);
|
||
}
|
||
else if (type == TEMP_DATA4)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA4_ADDR);
|
||
memset(pData, 0, TEMP_DATA4_SIZE);
|
||
}
|
||
}
|
||
|
||
u8 * GetTempData(int type)
|
||
{
|
||
u8 * pData = NULL;
|
||
|
||
if (type == TEMP_DATA1)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA1_ADDR);
|
||
}
|
||
else if (type == TEMP_DATA2)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA2_ADDR);
|
||
}
|
||
else if (type == TEMP_DATA3)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA3_ADDR);
|
||
}
|
||
else if (type == TEMP_DATA4)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA4_ADDR);
|
||
}
|
||
|
||
return pData;
|
||
}
|
||
|
||
int SetTempData(int type, int idx, u8 * pBuf)
|
||
{
|
||
if (pBuf == NULL)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
u8 * pData = NULL;
|
||
|
||
if (type == TEMP_DATA1)
|
||
{
|
||
if ((idx+1)*1024 <= TEMP_DATA1_SIZE)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA1_ADDR + idx*1024);
|
||
}
|
||
}
|
||
else if (type == TEMP_DATA2)
|
||
{
|
||
if ((idx+1)*1024 <= TEMP_DATA2_SIZE)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA2_ADDR + idx*1024);
|
||
}
|
||
}
|
||
else if (type == TEMP_DATA3)
|
||
{
|
||
if ((idx+1)*1024 <= TEMP_DATA3_SIZE)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA3_ADDR + idx*1024);
|
||
}
|
||
}
|
||
else if (type == TEMP_DATA4)
|
||
{
|
||
if ((idx+1)*1024 <= TEMP_DATA4_SIZE)
|
||
{
|
||
pData = (u8 *)(TEMP_DATA4_ADDR + idx*1024);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return -3;
|
||
}
|
||
|
||
if (pData != NULL)
|
||
{
|
||
memcpy(pData, pBuf, 1024);
|
||
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
return -2;
|
||
}
|
||
}
|
||
|
||
//-------------------------------------------------------------------------
|
||
int GetMinMaxFromFileDatWithAnchor(s32 * pminx, s32 * pmaxx, s32 * pminy, s32 * pmaxy)
|
||
{
|
||
return GetMinMaxFromFileDatBase(1, pminx, pmaxx, pminy, pmaxy);
|
||
}
|
||
|
||
int GetMinMaxFromFileDat(s32 * pminx, s32 * pmaxx, s32 * pminy, s32 * pmaxy)
|
||
{
|
||
return GetMinMaxFromFileDatBase(0, pminx, pmaxx, pminy, pmaxy);
|
||
}
|
||
|
||
int GetMinMaxFromFileDatBase(int point, s32 * pminx, s32 * pmaxx, s32 * pminy, s32 * pmaxy)
|
||
{
|
||
s32 minx, maxx, miny, maxy, actx, acty;
|
||
u32 idx, nums;
|
||
DataItem item;
|
||
int rslt;
|
||
|
||
if (IsDatFileAvailable() != TRUE)
|
||
{
|
||
minx = 0;
|
||
maxx = 0;
|
||
miny = 0;
|
||
maxy = 0;
|
||
}
|
||
else
|
||
{
|
||
nums = g_datFile.pFileHead->fileHead.itemNums;
|
||
|
||
if (point == 0)
|
||
{
|
||
actx = g_datFile.pFileHead->fileHead.beginX;
|
||
acty = g_datFile.pFileHead->fileHead.beginY;
|
||
}
|
||
else
|
||
{
|
||
actx = g_datFile.pFileHead->fileHead.anchorX;
|
||
acty = g_datFile.pFileHead->fileHead.anchorY;
|
||
}
|
||
|
||
minx = actx;
|
||
maxx = actx;
|
||
miny = acty;
|
||
maxy = acty;
|
||
|
||
if (point == 0)
|
||
{
|
||
printf("file info, begx=%d, begy=%d\r\n", actx, acty);
|
||
}
|
||
else
|
||
{
|
||
printf("file info, anchorX=%d, anchorY=%d\r\n", actx, acty);
|
||
}
|
||
|
||
for (idx = 0; idx < nums; idx++)
|
||
{
|
||
rslt = GetADataItemNoSqrt(0, idx, &item);
|
||
if (rslt != 0)
|
||
{
|
||
printf("get item error at GetMinMaxFromFileDatBase, rslt = %d\r\n", rslt);
|
||
break; // 结束
|
||
}
|
||
|
||
if (item.ctrl == DATA_END || // 结束码
|
||
item.ctrl == DATA_NULL || // 文件结束
|
||
item.ctrl == DATA_END_OLD || // 结束
|
||
0 )
|
||
{
|
||
idx++;
|
||
break;
|
||
}
|
||
|
||
if (item.ctrl == DATA_PAUSE || // 暂停功能码
|
||
item.ctrl == DATA_PAUSE_OLD || // 暂停功能码
|
||
item.ctrl == DATA_CHGND || // 换针功能码（换色）
|
||
item.ctrl == DATA_CUTTRD || // 剪线功能码
|
||
item.ctrl == DATA_CUT_OLD || // 剪线功能码
|
||
item.ctrl == DATA_ANGLE || // 拐点
|
||
item.ctrl == DATA_ANGLE_OLD || // 拐点
|
||
0 )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
actx += item.dx;
|
||
acty += item.dy;
|
||
|
||
if (actx < minx)
|
||
{
|
||
minx = actx;
|
||
}
|
||
if (actx > maxx)
|
||
{
|
||
maxx = actx;
|
||
}
|
||
|
||
if (acty < miny)
|
||
{
|
||
miny = acty;
|
||
}
|
||
if (acty > maxy)
|
||
{
|
||
maxy = acty;
|
||
}
|
||
}
|
||
g_datFile.pFileHead->fileHead.itemNums = idx;
|
||
}
|
||
|
||
printf("GetMinMaxFromFileDatBase, num=%d minx=%d, maxx=%d, miny=%d, maxy=%d \r\n", g_datFile.pFileHead->fileHead.itemNums, minx, maxx, miny, maxy);
|
||
|
||
*pminx = minx;
|
||
*pmaxx = maxx;
|
||
*pminy = miny;
|
||
*pmaxy = maxy;
|
||
|
||
return 0;
|
||
}
|
||
|
||
void InitDatFiles(void)
|
||
{
|
||
memset(&g_datFile, 0, sizeof(DatFileCtrl));
|
||
|
||
g_datFile.pFileHead = &g_fileHead1;
|
||
|
||
g_datFile.dataBuff1BegAddr = DATA_FILE_ADDR1; // 存放区域1
|
||
g_datFile.dataBuff1Len = DATA_FILE_SIZE1;
|
||
|
||
g_datFile.dataBuff2BegAddr = DATA_FILE_ADDR2; // 存放区域2
|
||
g_datFile.dataBuff2Len = DATA_FILE_SIZE2;
|
||
|
||
g_datFile.dataBuff3BegAddr = DATA3_BASE_ADDR; // 存放区域3,用于存放边框刺绣等类型的数据文件
|
||
g_datFile.dataBuff3Len = DATA_FILE_SIZE3;
|
||
|
||
g_datFile.pDatExCtrl = (DatExCtrl*)g_datFile.dataBuff1BegAddr;
|
||
g_datFile.enflag = 0;
|
||
|
||
InitNorSpi(); // 初始化 nor flash 访问 SPI
|
||
DatFlashInit(SetNorSpiNssOn, SetNorSpiNssOff, NorSpiReadByte, NorSpiWriteByte);
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------------------
|
||
// 生成数据文件的算法
|
||
|
||
#if (1)
|
||
|
||
// 支持ds8 和 ds16
|
||
#define DATA_ITEM Ds8Item // Ds16Item
|
||
#define SAVE_LEN 8 // 16
|
||
|
||
// 分割直线
|
||
int CalcLine(double x0, double y0, double x1, double y1, int * pactx, int * pacty, int stepSize, DATA_ITEM * pData, u8 type, s16 dr)
|
||
{
|
||
double length, tmp;
|
||
double stepx, stepy;
|
||
double sx, sy;
|
||
double xlk;
|
||
int i, count;
|
||
int actx, acty;
|
||
s32 sdx, sdy;
|
||
u8 attr;
|
||
|
||
attr = 0;
|
||
|
||
if (x0 == x1 && y0 == y1)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (x0 > x1)
|
||
{
|
||
sx = -1.0; // x反向
|
||
}
|
||
else
|
||
{
|
||
sx = 1.0;
|
||
}
|
||
|
||
if (y0 > y1)
|
||
{
|
||
sy = -1.0; // y反向
|
||
}
|
||
else
|
||
{
|
||
sy = 1.0;
|
||
}
|
||
|
||
// 开始分割针步
|
||
length = sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1));
|
||
tmp = length/stepSize; // 实际针步数
|
||
count = (int)(tmp); // 最少整针步数
|
||
|
||
if (tmp - count >= 0.5)
|
||
{
|
||
count += 1;
|
||
// printf("count++=%d\r\n", count);
|
||
}
|
||
|
||
if (count == 0 && length > 0) // 短直线
|
||
{
|
||
count = 1;
|
||
}
|
||
|
||
if (pData == NULL)
|
||
{
|
||
return count;
|
||
}
|
||
|
||
actx = *pactx;
|
||
acty = *pacty;
|
||
|
||
if (x1 != x0 && y1 == y0) // 横直线
|
||
{
|
||
// printf("H Line: \r\n");
|
||
sdy = 0;
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
tmp = ((i+1)*(length)/count)*sx + x0; // 实际坐标
|
||
|
||
stepx = (tmp - actx);
|
||
sdx = (s32)(stepx+0.5*sx);
|
||
|
||
pData[i].ctrl = type;
|
||
pData[i].attr = attr;
|
||
pData[i].dx = sdx;
|
||
pData[i].dy = sdy;
|
||
pData[i].dr = 0;
|
||
|
||
#if (SAVE_LEN == 16)
|
||
{
|
||
double len;
|
||
len = sqrt(1.0*sdx*sdx + 1.0*sdy*sdy);
|
||
pData[i].len = (u16)(len+0.9);
|
||
}
|
||
#endif
|
||
actx += sdx;
|
||
acty += sdy;
|
||
}
|
||
}
|
||
else if (x1 == x0 && y1 != y0) // 竖直线
|
||
{
|
||
// printf("v Line: \r\n");
|
||
|
||
sdx = 0;
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
tmp = ((i+1)*(length)/count)*sy + y0; // 实际针步
|
||
|
||
stepy = (tmp - acty);
|
||
sdy = (s32)(stepy+0.5*sy);
|
||
|
||
pData[i].ctrl = type;
|
||
pData[i].attr = attr;
|
||
pData[i].dx = sdx;
|
||
pData[i].dy = sdy;
|
||
pData[i].dr = 0;
|
||
|
||
#if (SAVE_LEN == 16)
|
||
len = sqrt(1.0*sdx*sdx + 1.0*sdy*sdy);
|
||
pData[i].len = (u16)(len+0.9);
|
||
#endif
|
||
actx += sdx;
|
||
acty += sdy;
|
||
}
|
||
}
|
||
else if(x1 != x0 && y1 != y0) // 任意斜线
|
||
{
|
||
// 斜率
|
||
xlk = (y1-y0)/(x1-x0);
|
||
// printf("any Line: k=%f\r\n", xlk);
|
||
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
tmp = ((i+1)*(length)/count); // 实际针步
|
||
|
||
stepx = fabs(tmp*cos(atan(xlk)))*sx + x0 - actx;
|
||
stepy = fabs(tmp*sin(atan(xlk)))*sy + y0 - acty;
|
||
|
||
sdx = (s32)(stepx+0.5*sx);
|
||
sdy = (s32)(stepy+0.5*sy);
|
||
|
||
pData[i].ctrl = type;
|
||
pData[i].attr = attr;
|
||
pData[i].dx = sdx;
|
||
pData[i].dy = sdy;
|
||
pData[i].dr = 0;
|
||
|
||
#if (SAVE_LEN == 16)
|
||
len = sqrt(1.0*sdx*sdx + 1.0*sdy*sdy);
|
||
pData[i].len = (u16)(len+0.9);
|
||
#endif
|
||
actx += sdx;
|
||
acty += sdy;
|
||
}
|
||
}
|
||
pData[0].dr = dr; // 第一段数据添加r变化量
|
||
|
||
*pactx = actx;
|
||
*pacty = acty;
|
||
|
||
return count;
|
||
}
|
||
|
||
//---------------------------------------------------------------------------------------------------------
|
||
// 圆弧
|
||
|
||
// 旋转坐标值
|
||
void Rotatec(double xin, double yin, double * px, double * py, double angle)
|
||
{
|
||
*px=xin*cos(angle)-yin*sin(angle);
|
||
*py=xin*sin(angle)+yin*cos(angle);
|
||
}
|
||
|
||
// 根据坐标确定增加方向
|
||
int ArcDir(const double x[], const double y[])
|
||
{
|
||
double k;
|
||
if(x[1] > x[0])
|
||
{
|
||
k = (y[1] - y[0]) / (x[1]-x[0]);
|
||
if (y[2] < (k*(x[2]-x[1]) + y[1]))
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
return 1;
|
||
}
|
||
}
|
||
else if (x[1] < x[0])
|
||
{
|
||
k = (y[1] - y[0]) / (x[1] - x[0]);
|
||
if (y[2] < (k * (x[2]-x[1]) + y[1]))
|
||
{
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
return -1;
|
||
}
|
||
}
|
||
else if ( (x[2]>x[1] && y[1]<y[0]) || (x[2]<x[1] && y[0]<y[1]) )
|
||
{
|
||
return 1;
|
||
}
|
||
else if ( (x[2]>x[1] && y[1]>y[0]) || (x[2]<x[1] && y[0]>y[1]) )
|
||
{
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
printf("1. what's this case?\r\n");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// 三点共线
|
||
int IsThreePointOnALine(const double threex[], const double threey[])
|
||
{
|
||
double k0,k1,k2;
|
||
|
||
if ((fabs(threex[0]-threex[1]) < 1e-6) &&
|
||
(fabs(threex[0]-threex[2]) < 1e-6) &&
|
||
(fabs(threex[2]-threex[1]) < 1e-6) &&
|
||
(fabs(threey[0]-threey[1]) < 1e-6) &&
|
||
(fabs(threey[0]-threey[2]) < 1e-6) &&
|
||
(fabs(threey[2]-threey[1]) < 1e-6) &&
|
||
1 )
|
||
{
|
||
// printf("1.IsThreePointOnALine\r\n");
|
||
return 1;
|
||
}
|
||
else if ( ((fabs(threex[0]-threex[1]) < 1e-6) && (fabs(threey[0]-threey[1]) < 1e-6)) ||
|
||
((fabs(threex[0]-threex[2]) < 1e-6) && (fabs(threey[0]-threey[2]) < 1e-6)) ||
|
||
((fabs(threex[2]-threex[1]) < 1e-6) && (fabs(threey[2]-threey[1]) < 1e-6)) ||
|
||
0 )
|
||
{
|
||
// printf("2.IsThreePointOnALine\r\n");
|
||
return 1;
|
||
}
|
||
else if ( (fabs(threex[0]-threex[1]) < 1e-6) &&
|
||
(fabs(threex[0]-threex[2]) < 1e-6) &&
|
||
(fabs(threex[2]-threex[1]) < 1e-6) &&
|
||
1 )
|
||
{
|
||
// printf("3.IsThreePointOnALine\r\n");
|
||
return 1;
|
||
}
|
||
else if ( (fabs(threey[0]-threey[1]) < 1e-6) &&
|
||
(fabs(threey[0]-threey[2]) < 1e-6) &&
|
||
(fabs(threey[2]-threey[1]) < 1e-6) &&
|
||
1 )
|
||
{
|
||
// printf("4.IsThreePointOnALine\r\n");
|
||
return 1;
|
||
}
|
||
else if ( (fabs(threex[2]-threex[1]) >= 1e-6) &&
|
||
(fabs(threex[2]-threex[0]) >= 1e-6) &&
|
||
(fabs(threex[1]-threex[0]) >= 1e-6) &&
|
||
(fabs(threey[2]-threey[1]) >= 1e-6) &&
|
||
(fabs(threey[2]-threey[0]) >= 1e-6) &&
|
||
(fabs(threey[1]-threey[0]) >= 1e-6) &&
|
||
1 )
|
||
{
|
||
k0 = (threey[2]-threey[1])/(threex[2]-threex[1]);
|
||
k1 = (threey[2]-threey[0])/(threex[2]-threex[0]);
|
||
k2 = (threey[1]-threey[0])/(threex[1]-threex[0]);
|
||
|
||
if(fabs(k0-k1) < 1e-6 && fabs(k1-k2) < 1e-6)
|
||
{
|
||
// printf("5.IsThreePointOnALine\r\n");
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
// printf("6.IsThreePointOnALine\r\n");
|
||
return 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// printf("7.IsThreePointOnALine\r\n");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// 得到圆心和半径
|
||
int GetArcCenter(const double x[], const double y[], double * pxc, double * pyc, double * pr)
|
||
{
|
||
long double a, b, c, d, e, f;
|
||
double xc, yc, r;
|
||
|
||
if (IsThreePointOnALine(x, y) == 1)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
a = 2 * (x[1]-x[0]);
|
||
b = 2 * (y[1]-y[0]);
|
||
c = x[1]*x[1] + y[1]*y[1] - x[0]*x[0] - y[0]*y[0];
|
||
d = 2 * (x[2]-x[1]);
|
||
e = 2 * (y[2]-y[1]);
|
||
f = x[2]*x[2] + y[2]*y[2] - x[1]*x[1] - y[1]*y[1];
|
||
|
||
xc = (b*f-e*c)/(b*d-e*a);
|
||
yc = (d*c-a*f)/(b*d-e*a);
|
||
r = sqrt((xc-x[0])*(xc-x[0])+(yc-y[0])*(yc-y[0]));
|
||
|
||
*pxc = xc;
|
||
*pyc = yc;
|
||
*pr = r;
|
||
|
||
return 0;
|
||
}
|
||
|
||
// 得到直线角度和角度差
|
||
|
||
s16 GetAngle(const double bx, const double by, const double ex, const double ey, int * pActAng)
|
||
{
|
||
double cosf, angle, length;
|
||
s32 dr;
|
||
|
||
length = sqrt((ex-bx)*(ex-bx) + (ey-by)*(ey-by));
|
||
if (length != 0)
|
||
{
|
||
// 计算直线角度（和x正方向的夹角。弧度表示，范围为 0--2PI）
|
||
cosf = (ex-bx)/length;
|
||
angle = acos(cosf);
|
||
if (ey < by)
|
||
{
|
||
angle = 2*PI - angle;
|
||
}
|
||
|
||
// 角度差
|
||
if ((angle*RADIAN_ACCURACY - *pActAng) > PI*RADIAN_ACCURACY) // 角度差大于180度，
|
||
{
|
||
dr = (s32)(angle*RADIAN_ACCURACY - *pActAng - 2*PI* RADIAN_ACCURACY); // 反向到达目标角度
|
||
*pActAng += (int)(2*PI*RADIAN_ACCURACY)+dr; // 实际位置
|
||
}
|
||
else if ((angle*RADIAN_ACCURACY - *pActAng) < (-1)*PI*RADIAN_ACCURACY) // 角度差大于180度
|
||
{
|
||
dr = (s32)(angle*RADIAN_ACCURACY - *pActAng + 2*PI* RADIAN_ACCURACY);
|
||
*pActAng += (int)(-2*PI*RADIAN_ACCURACY)+dr; // 实际位置
|
||
}
|
||
else
|
||
{
|
||
dr = (s32)(angle*RADIAN_ACCURACY - *pActAng); // 正向
|
||
*pActAng += dr;
|
||
}
|
||
|
||
while (*pActAng > 2*PI*RADIAN_ACCURACY)
|
||
{
|
||
*pActAng -= 2*PI*RADIAN_ACCURACY;
|
||
}
|
||
while (*pActAng < 0)
|
||
{
|
||
*pActAng += 2*PI*RADIAN_ACCURACY;
|
||
}
|
||
|
||
return dr;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 分割圆弧线
|
||
int CalcCurve(double threex[], double threey[], int * pactx, int * pacty, int * pActAng, int stepSize, DATA_ITEM * pData, u8 type)
|
||
{
|
||
u8 attr;
|
||
s16 dx, dy, dr;
|
||
|
||
double k, alph, increment;
|
||
double xc, yc, r;
|
||
double distance2;
|
||
double curx, cury, lastx, lasty;
|
||
double xrot, yrot;
|
||
int actx, acty;
|
||
int ddx, ddy;
|
||
int count = 0;
|
||
int i;
|
||
|
||
dx = 0;
|
||
dy = 0;
|
||
dr = 0;
|
||
// printf("Calc Curve x0=%.2f,y0=%.2f,x1=%.2f,\r\n\t y1=%.2f,x2=%.2f,y2=%.2f\r\n", threex[0],threey[0],threex[1],threey[1],threex[2],threey[2]);
|
||
|
||
if(IsThreePointOnALine(threex, threey) == 1) // 3点共线
|
||
{
|
||
// 直线和X坐标轴正方向的夹角, 公式: cosφ=∣A1A2+B1B2∣/[√(A1^2+B1^2)√(A2^2+B2^2)]
|
||
if (pData != NULL)
|
||
{
|
||
dr = GetAngle(threex[0], threey[0], threex[2], threey[2], pActAng);
|
||
}
|
||
return CalcLine(threex[0], threey[0], threex[2], threey[2], pactx, pacty, stepSize, pData, type, dr); // 作为直线分割
|
||
}
|
||
|
||
// 计算圆心和半径
|
||
GetArcCenter(threex, threey, &xc, &yc, &r);
|
||
|
||
printf("center=%f,%f,r=%f\r\n", xc, yc, r);
|
||
|
||
// 计算弦长和圆心角
|
||
distance2 = ((threex[0]-threex[2])*(threex[0]-threex[2])+(threey[0]-threey[2])*(threey[0]-threey[2])); // 两点间距离就是弦长
|
||
k = ((r*r+r*r)-distance2)/(2*r*r); // cosc = (a*a + b*b - c*c)/2*a*b
|
||
if (k < -1)
|
||
{
|
||
k = -1;
|
||
}
|
||
else if (k > 1)
|
||
{
|
||
k = 1;
|
||
}
|
||
|
||
#if (0)
|
||
distance2 = sqrt(distance2);
|
||
printf("distance=%f, k=%f\r\n", distance2, k);
|
||
#endif
|
||
|
||
// 圆心角
|
||
alph = acos(k);
|
||
#if (0)
|
||
printf("calc alph=%f\r\n", alph);
|
||
printf("long double size=%d\r\n", sizeof(long double));
|
||
#endif
|
||
// 区分象限和旋转方向
|
||
k = (threex[0]-threex[1])*(threex[2]-threex[1]) + (threey[0]-threey[1])*(threey[2]-threey[1]); // 向量 01 和 向量 21 的夹角的余弦的符号-- > 0 小于90度. < 0 大于90度 = 0, 90 度
|
||
|
||
if (k > 0) // 夹角小于90度, 说明弧是大于半圆
|
||
{
|
||
alph = 2*PI-alph;
|
||
}
|
||
else // 夹角大于等于90度, 说明弧是小于等于半圆, 不需要处理
|
||
{
|
||
}
|
||
#if (0)
|
||
printf("act alph=%f, arclen=%d\r\n", alph, alph*r);
|
||
#endif
|
||
|
||
// 计算每个针步对应的弧心角大小
|
||
if (fabsl(2*r*r-1.0*stepSize*stepSize)/(2*r*r) > 1)
|
||
{
|
||
increment = alph;
|
||
}
|
||
else
|
||
{
|
||
increment = (acos((2*r*r-1.0*stepSize*stepSize)/(r*r+r*r)));
|
||
}
|
||
|
||
// 计算分割针步数
|
||
count = (int)(alph/increment+0.5);
|
||
if (count == 0)
|
||
{
|
||
count++;
|
||
}
|
||
// printf("1.count=%d, increment=%f\r\n", count, increment);
|
||
|
||
if (pData == NULL) // 返回个数
|
||
{
|
||
return count;
|
||
}
|
||
|
||
// 重新计算每个针步弧心角
|
||
increment = alph/count;
|
||
|
||
// 确定针步增加的角度和方向
|
||
increment *= ArcDir(threex, threey);
|
||
printf("2.count=%d, increment=%f\r\n", count, increment);
|
||
|
||
// 起点
|
||
lastx = threex[0];
|
||
lasty = threey[0];
|
||
|
||
actx = *pactx;
|
||
acty = *pacty;
|
||
|
||
i = 0;
|
||
do
|
||
{
|
||
if (i == count-1)
|
||
{
|
||
// 最后一个针步
|
||
// printf("the last step\r\n");
|
||
curx = threex[2];
|
||
cury = threey[2];
|
||
}
|
||
else
|
||
{
|
||
// 点 (lastx, lasty) 在圆上旋转
|
||
// printf("before Rotatec point(%f, %f)\r\n", lastx, lasty);
|
||
Rotatec(lastx-xc, lasty-yc, &xrot, &yrot, increment);
|
||
curx = xrot + xc;
|
||
cury = yrot + yc;
|
||
}
|
||
|
||
ddx = curx-actx;
|
||
ddy = cury-acty;
|
||
|
||
dx = (s16)(curx-actx+(0.5*(ddx>=0?1:-1)));
|
||
dy = (s16)(cury-acty+(0.5*(ddy>=0?1:-1)));
|
||
dr = GetAngle(lastx, lasty, curx, cury, pActAng); // 计算直线 (lastx, lasty) 到（curx, cury）和上条直线的角度差
|
||
|
||
attr = 0;
|
||
|
||
pData[i].ctrl = type;
|
||
pData[i].attr = attr;
|
||
pData[i].dx = dx;
|
||
pData[i].dy = dy;
|
||
pData[i].dr = dr;
|
||
|
||
#if (SAVE_LEN == 16)
|
||
{
|
||
double len;
|
||
len = sqrt(1.0*dx*dx + 1.0*dy*dy);
|
||
pData[i].len = (u16)(len+0.9);
|
||
}
|
||
#endif
|
||
|
||
// printf("after Rotatec point(%f, %f)\r\n", lastx, lasty);
|
||
|
||
lastx = curx;
|
||
lasty = cury;
|
||
actx += dx;
|
||
acty += dy;
|
||
i++;
|
||
|
||
} while(i < count);
|
||
|
||
*pactx = actx;
|
||
*pacty = acty;
|
||
|
||
return count;
|
||
}
|
||
|
||
int CreateCommFile(SqrtInfo * pSqrt)
|
||
{
|
||
double threex[3], threey[3];
|
||
|
||
int begx, begy, begr, begflag;
|
||
|
||
// int begx2, begy2, begr2, begflag2;
|
||
|
||
int paraBLockNum, paraBLockTimes, paraBLockJumps;
|
||
int paraELockNum, paraELockTimes, paraELockJumps;
|
||
int blockNum, blockTimes;
|
||
int elockNum, elockTimes;
|
||
int blockjumps, elockjumps;
|
||
int stepSize, sqrtNum;
|
||
int actx, acty, actr;
|
||
int i, j, k, idx;
|
||
int stepNumber, curtNumber, totalNumber;
|
||
int n, cutflag;
|
||
|
||
u8 ctrl, oldctrl, attr;
|
||
|
||
DATA_ITEM * pSteps, * pData, * pTemp;
|
||
|
||
InitDatFiles();
|
||
g_datFile.storage = STORAGE_EXSRAM; // 存储在外部RAM中
|
||
|
||
pSteps = (DATA_ITEM*)(g_datFile.dataBuff1BegAddr); // 数据存放地址
|
||
|
||
if (pSqrt == NULL)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
if (pSqrt->sqrtNum <= 0)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
|
||
|
||
|
||
//------------------
|
||
#if (0)
|
||
printf("SqrtInfo para:\r\n");
|
||
|
||
printf("\t midy = %d\r\n", pSqrt->sqrtNum);
|
||
printf("\t stepSize = %d\r\n", pSqrt->stepSize);
|
||
printf("\t blockNum = %d\r\n", pSqrt->blockNum);
|
||
printf("\t blockTimes = %d\r\n", pSqrt->blockTimes);
|
||
printf("\t elockNum = %d\r\n", pSqrt->elockNum);
|
||
printf("\t elockTimes = %d\r\n", pSqrt->elockTimes);
|
||
printf("\t blockjumps = %d\r\n", pSqrt->blockjumps);
|
||
printf("\t elockjumps = %d\r\n", pSqrt->elockjumps);
|
||
#endif
|
||
|
||
sqrtNum = pSqrt->sqrtNum; // 图形个数
|
||
|
||
begx = pSqrt->sqrtItem[0].begx;
|
||
begy = pSqrt->sqrtItem[0].begy;
|
||
begr = 0;
|
||
|
||
actx = begx;
|
||
acty = begy;
|
||
actr = 0;
|
||
|
||
begflag = 0;
|
||
// begflag2 = 0;
|
||
totalNumber = 0;
|
||
oldctrl = 0;
|
||
ctrl = 0;
|
||
cutflag = 0;
|
||
|
||
//------------------
|
||
// 生成文件内容
|
||
|
||
for (idx = 0; idx < sqrtNum; idx++)
|
||
{
|
||
stepSize = pSqrt->sqrtItem[idx].stepSize; // 分割针步大小
|
||
|
||
if (stepSize == 0)
|
||
{
|
||
stepSize = pSqrt->stepSize; // 分割针步大小
|
||
}
|
||
|
||
paraBLockNum = pSqrt->sqrtItem[idx].blockNum;
|
||
paraBLockTimes = pSqrt->sqrtItem[idx].blockTimes;
|
||
paraBLockJumps = pSqrt->sqrtItem[idx].blockjumps;
|
||
paraELockNum = pSqrt->sqrtItem[idx].elockNum;
|
||
paraELockTimes = pSqrt->sqrtItem[idx].elockTimes;
|
||
paraELockJumps = pSqrt->sqrtItem[idx].elockjumps;
|
||
#if (0)
|
||
printf("SqrtInfo[%d] para:\r\n", idx);
|
||
|
||
printf("\t stepSize = %d\r\n", pSqrt->sqrtItem[idx].stepSize);
|
||
printf("\t blockNum = %d\r\n", pSqrt->sqrtItem[idx].blockNum);
|
||
printf("\t blockTimes = %d\r\n", pSqrt->sqrtItem[idx].blockTimes);
|
||
printf("\t blockjumps = %d\r\n", pSqrt->sqrtItem[idx].blockjumps);
|
||
printf("\t elockNum = %d\r\n", pSqrt->sqrtItem[idx].elockNum);
|
||
printf("\t elockTimes = %d\r\n", pSqrt->sqrtItem[idx].elockTimes);
|
||
printf("\t elockjumps = %d\r\n", pSqrt->sqrtItem[idx].elockjumps);
|
||
#endif
|
||
|
||
// 起始回针参数处理
|
||
if (paraBLockTimes > 0 && paraBLockNum > 0)
|
||
{
|
||
if (paraBLockJumps > paraBLockTimes*paraBLockNum)
|
||
{
|
||
paraBLockNum = 0;
|
||
paraBLockTimes = 0;
|
||
paraBLockJumps = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
paraBLockNum = 0;
|
||
paraBLockTimes = 0;
|
||
paraBLockJumps = 0;
|
||
}
|
||
while (paraBLockJumps >= paraBLockNum && paraBLockTimes > 1) // 保证jumps小于locknums
|
||
{
|
||
paraBLockJumps -= paraBLockNum;
|
||
paraBLockTimes--;
|
||
}
|
||
|
||
// 结束回针参数处理
|
||
if (paraELockTimes > 0 && paraELockNum > 0)
|
||
{
|
||
if (paraELockJumps > paraELockTimes*paraELockNum)
|
||
{
|
||
paraELockNum = 0;
|
||
paraELockTimes = 0;
|
||
paraELockJumps = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
paraELockNum = 0;
|
||
paraELockTimes = 0;
|
||
paraELockJumps = 0;
|
||
}
|
||
while (paraELockJumps >= paraELockNum && paraELockTimes > 1) // 保证jumps小于locknums
|
||
{
|
||
paraELockJumps -= paraELockNum;
|
||
paraELockTimes--;
|
||
}
|
||
//------------------
|
||
|
||
#if (0)
|
||
qDebug("calc para:\r\n");
|
||
|
||
qDebug("\t sqrtNum = %d\r\n", sqrtNum);
|
||
qDebug("\t stepSize = %d\r\n", stepSize);
|
||
qDebug("\t blockNum = %d\r\n", paraBLockNum);
|
||
qDebug("\t blockTimes = %d\r\n", paraBLockTimes);
|
||
qDebug("\t blockjumps = %d\r\n", paraBLockJumps);
|
||
qDebug("\t elockNum = %d\r\n", paraELockNum);
|
||
qDebug("\t elockTimes = %d\r\n", paraELockTimes);
|
||
qDebug("\t elockjumps = %d\r\n", paraELockJumps);
|
||
#endif
|
||
|
||
#if (0)
|
||
printf("\t begx = %f\r\n", pSqrt->sqrtItem[idx].begx);
|
||
printf("\t begy = %f\r\n", pSqrt->sqrtItem[idx].begy);
|
||
printf("\t endx = %f\r\n", pSqrt->sqrtItem[idx].endx);
|
||
printf("\t endy = %f\r\n", pSqrt->sqrtItem[idx].endy);
|
||
printf("\t midx = %f\r\n", pSqrt->sqrtItem[idx].midx);
|
||
printf("\t midy = %f\r\n", pSqrt->sqrtItem[idx].midy);
|
||
#endif
|
||
//------------------
|
||
if (begflag != 0) // 非起始，插入偏移数据
|
||
{
|
||
if (pSqrt->sqrtItem[idx].begx != pSqrt->sqrtItem[idx-1].endx ||
|
||
pSqrt->sqrtItem[idx].begy != pSqrt->sqrtItem[idx-1].endy ||
|
||
0 )
|
||
{
|
||
// 自动插入偏移数据
|
||
threex[0] = pSqrt->sqrtItem[idx-1].endx;
|
||
threey[0] = pSqrt->sqrtItem[idx-1].endy;
|
||
threex[1] = pSqrt->sqrtItem[idx].begx;
|
||
threey[1] = pSqrt->sqrtItem[idx].begy;
|
||
threex[2] = pSqrt->sqrtItem[idx].begx;
|
||
threey[2] = pSqrt->sqrtItem[idx].begy; // 三点共线，作为直线
|
||
|
||
stepNumber = CalcCurve(threex, threey, &actx, &acty, &actr, S16_MAX/2, pSteps, pSqrt->defofst);
|
||
pSteps += stepNumber;
|
||
totalNumber += stepNumber;
|
||
if (stepNumber != 0)
|
||
{
|
||
ctrl = pSqrt->defofst;
|
||
}
|
||
}
|
||
}
|
||
/*
|
||
if (begflag2 != 0) // 非起始，插入偏移数据
|
||
{
|
||
if (pSqrt->sqrtItem[idx].begx != pSqrt->sqrtItem[idx-1].endx ||
|
||
pSqrt->sqrtItem[idx].begy != pSqrt->sqrtItem[idx-1].endy ||
|
||
0 )
|
||
{
|
||
// 自动插入偏移数据
|
||
threex[0] = pSqrt->sqrtItem[idx-1].endx;
|
||
threey[0] = pSqrt->sqrtItem[idx-1].endy;
|
||
threex[1] = pSqrt->sqrtItem[idx].begx;
|
||
threey[1] = pSqrt->sqrtItem[idx].begy;
|
||
threex[2] = pSqrt->sqrtItem[idx].begx;
|
||
threey[2] = pSqrt->sqrtItem[idx].begy; // 三点共线，作为直线
|
||
|
||
stepNumber = CalcCurve(threex, threey, &actx, &acty, &actr, S16_MAX/2, pSteps, DATA_SECF_SEW);
|
||
pSteps += stepNumber;
|
||
totalNumber += stepNumber;
|
||
if (stepNumber != 0)
|
||
{
|
||
ctrl = DATA_SECF_SEW;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
oldctrl = ctrl;
|
||
ctrl = pSqrt->sqrtItem[idx].type;
|
||
|
||
blockNum = 0;
|
||
blockTimes = 0;
|
||
blockjumps = 0;
|
||
|
||
elockNum = 0;
|
||
elockTimes = 0;
|
||
elockjumps = 0;
|
||
cutflag = 0;
|
||
|
||
if (ctrl == DATA_SEWING ||
|
||
ctrl == DATA_SEWING_R ||
|
||
ctrl == DATA_SECF_SEW ||
|
||
ctrl == DATA_SECF_SEW_R ||
|
||
ctrl == DATA_SYNCSEW ||
|
||
0 )
|
||
{
|
||
if (oldctrl != ctrl)
|
||
{
|
||
blockNum = paraBLockNum; // 起始锁针针数
|
||
blockTimes = paraBLockTimes; // 起始锁针次数
|
||
blockjumps = paraBLockJumps; // 起针跳过针数
|
||
|
||
if ((blockTimes%2) != 0) // 使回针成为偶数
|
||
{
|
||
blockTimes++;
|
||
blockjumps += blockNum;
|
||
}
|
||
}
|
||
|
||
if ( idx+1 >= sqrtNum ||
|
||
(pSqrt->sqrtItem[idx+1].type != ctrl &&
|
||
((pSqrt->sqrtItem[idx+1].type == DATA_SEWING && ctrl != DATA_SYNCSEW) ||
|
||
(pSqrt->sqrtItem[idx+1].type == DATA_SECF_SEW && ctrl != DATA_SYNCSEW) ||
|
||
(pSqrt->sqrtItem[idx+1].type == DATA_SYNCSEW && ctrl != DATA_SEWING) ||
|
||
(pSqrt->sqrtItem[idx+1].type == DATA_SYNCSEW && ctrl != DATA_SECF_SEW) ||
|
||
0 ) &&
|
||
|
||
1 ) ||
|
||
pSqrt->sqrtItem[idx+1].begx != pSqrt->sqrtItem[idx].endx ||
|
||
pSqrt->sqrtItem[idx+1].begy != pSqrt->sqrtItem[idx].endy ||
|
||
0 )
|
||
{
|
||
elockNum = paraELockNum; // 结束锁针针数
|
||
elockTimes = paraELockTimes; // 结束锁针次数
|
||
elockjumps = paraELockJumps; // 结束跳过针数
|
||
if ((elockTimes%2) != 0) // 使回针成为偶数
|
||
{
|
||
elockTimes++;
|
||
elockjumps += elockNum;
|
||
}
|
||
|
||
cutflag = 1;
|
||
}
|
||
}
|
||
|
||
threex[0] = pSqrt->sqrtItem[idx].begx;
|
||
threey[0] = pSqrt->sqrtItem[idx].begy;
|
||
threex[1] = pSqrt->sqrtItem[idx].midx;
|
||
threey[1] = pSqrt->sqrtItem[idx].midy;
|
||
threex[2] = pSqrt->sqrtItem[idx].endx;
|
||
threey[2] = pSqrt->sqrtItem[idx].endy;
|
||
|
||
stepNumber = CalcCurve(threex, threey, NULL, NULL, NULL, stepSize, NULL, ctrl);
|
||
curtNumber = stepNumber + blockNum*blockTimes - blockjumps + elockNum*elockTimes; // 直接跳过起始跳过针数
|
||
// printf("stepNumber = %d, cur totalNumber=%d:\r\n", stepNumber, curtNumber);
|
||
|
||
pData = pSteps + (blockNum*blockTimes) - blockjumps; // 直接跳过起始跳过针数，不给跳过针数预留位置
|
||
n = CalcCurve(threex, threey, &actx, &acty, &actr, stepSize, pData, ctrl);
|
||
if (n != stepNumber)
|
||
{
|
||
printf("create number =%d, is not equal to stepNumber=%d:\r\n", n, stepNumber);
|
||
}
|
||
|
||
#if (0)
|
||
// 起始锁针信息
|
||
printf("before add lock:\r\n");
|
||
for (i = 0; i < curtNumber; i++)
|
||
{
|
||
printf("DataItem %d:ctrl=0x%x, attr=0x%x, dx=%d, dy=%d\r\n", i, pSteps[i].ctrl, pSteps[i].attr, pSteps[i].dx, pSteps[i].dy);
|
||
}
|
||
#endif
|
||
|
||
// 倒序添加起针锁针
|
||
pTemp = pData - 1;
|
||
k = blockTimes*blockNum;
|
||
for (i = 0; i < blockTimes; i++)
|
||
{
|
||
if (i%2 == 0) // 奇数锁针
|
||
{
|
||
// printf("ji shu:\r\n");
|
||
for (j = 0; j < blockNum; j++)
|
||
{
|
||
// 拷贝针步
|
||
k--;
|
||
if (k < blockjumps) // 跳过计数器
|
||
{
|
||
// pTemp->ctrl = pSqrt->defofst; // 转换为offset
|
||
}
|
||
else
|
||
{
|
||
memcpy(pTemp, &(pData[j]), sizeof(DATA_ITEM));
|
||
pTemp->dx *= (-1);
|
||
pTemp->dy *= (-1); // 方向取反
|
||
pTemp->dr *= (-1); // 方向取反
|
||
attr = pTemp->attr;
|
||
attr |= ATTR_RESEW; // 回针标志
|
||
pTemp->attr = attr;
|
||
pTemp--;
|
||
|
||
if (begflag == 0) // 改变起点坐标
|
||
{
|
||
begx += pData[j].dx * 1;
|
||
begx += pData[j].dy * 1;
|
||
begx += pData[j].dr * 1;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
else // 偶数锁针
|
||
{
|
||
// printf("ou shu:\r\n");
|
||
for (j = blockNum-1; j >= 0; j--)
|
||
{
|
||
// 拷贝针步
|
||
k--;
|
||
if (k < blockjumps) // 跳过计数器
|
||
{
|
||
// pTemp->ctrl = pSqrt->defofst; // 转换为offset
|
||
}
|
||
else
|
||
{
|
||
memcpy(pTemp, &(pData[j]), sizeof(DATA_ITEM));
|
||
attr = pTemp->attr;
|
||
attr |= ATTR_RESEW; // 回针标志
|
||
pTemp->attr = attr;
|
||
pTemp--;
|
||
|
||
if (begflag == 0) // 改变起点坐标
|
||
{
|
||
begx += pData[j].dx * (-1);
|
||
begx += pData[j].dy * (-1);
|
||
begx += pData[j].dr * (-1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
/**/
|
||
// 正向扫描，修正起针回针中的dr
|
||
k = blockTimes*blockNum;
|
||
pTemp = pData - k;
|
||
if(blockTimes != 0 )
|
||
{
|
||
for (i = 0; i <= blockTimes; i++) // 跳过第一次锁针(偶数)，且
|
||
{
|
||
if (i%2 == 0) // 偶数锁针
|
||
{
|
||
if (i == 0) // 第一针, 这里不做处理，后面添加单独运动dr的offset
|
||
{
|
||
}
|
||
else
|
||
{
|
||
pTemp->dr = 0;
|
||
}
|
||
pTemp += blockNum;
|
||
}
|
||
else // 奇数锁针
|
||
{
|
||
pTemp += blockNum - 1 ;
|
||
pTemp->dr = 0;
|
||
pTemp++;
|
||
}
|
||
}
|
||
}
|
||
|
||
#if (0)
|
||
// 结束锁针信息
|
||
printf("after add begin lock:\r\n");
|
||
for (i = 0; i < curtNumber; i++)
|
||
{
|
||
printf("DataItem %d:ctrl=0x%x, attr=0x%x, dx=%d, dy=%d\r\n", i, pData[i].ctrl, pData[i].attr, pData[i].dx, pData[i].dy);
|
||
}
|
||
#endif
|
||
|
||
// 顺序添加末针锁针
|
||
pTemp = pData + stepNumber;
|
||
k = 0;
|
||
for (i = 0; i < elockTimes; i++)
|
||
{
|
||
if (i%2 == 0) // 奇数锁针
|
||
{
|
||
for (j = 0; j < elockNum; j++)
|
||
{
|
||
// 拷贝针步
|
||
memcpy(pTemp, &(pData[stepNumber-1-j]), sizeof(DATA_ITEM));
|
||
pTemp->dx *= -1;
|
||
pTemp->dy *= -1; // 方向取反
|
||
pTemp->dr *= -1; // 方向取反
|
||
|
||
k++;
|
||
if (k > elockTimes*elockNum - elockjumps) // 结束跳过计数器
|
||
{
|
||
pTemp->ctrl = pSqrt->defofst; // 转换为offset
|
||
}
|
||
else
|
||
{
|
||
attr = pTemp->attr;
|
||
attr |= ATTR_RESEW; // 回针标志
|
||
pTemp->attr = attr;
|
||
}
|
||
pTemp++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (j = elockNum-1; j >= 0; j--)
|
||
{
|
||
// 拷贝针步
|
||
memcpy(pTemp, &(pData[stepNumber-1-j]), sizeof(DATA_ITEM));
|
||
k++;
|
||
if (k > elockTimes*elockNum - elockjumps) // 结束跳过计数器
|
||
{
|
||
pTemp->ctrl = pSqrt->defofst; // 转换为offset
|
||
}
|
||
else
|
||
{
|
||
attr = pTemp->attr;
|
||
attr |= ATTR_RESEW; // 回针标志
|
||
pTemp->attr = attr;
|
||
}
|
||
pTemp++;
|
||
}
|
||
}
|
||
}
|
||
|
||
#if (0)
|
||
printf("after add end lock:\r\n");
|
||
for (i = 0; i < curtNumber; i++)
|
||
{
|
||
printf("DataItem %d:ctrl=0x%x, attr=0x%x, dx=%d, dy=%d\r\n", i, pData[i].ctrl, pData[i].attr, pData[i].dx, pData[i].dy);
|
||
}
|
||
#endif
|
||
|
||
stepNumber = curtNumber;
|
||
|
||
if (cutflag != 0) // 缝纫针步添加剪线码
|
||
{
|
||
// 添加剪线码
|
||
pSteps[stepNumber].ctrl = DATA_CUTTRD;
|
||
pSteps[stepNumber].attr = 0;
|
||
pSteps[stepNumber].dx = 0;
|
||
pSteps[stepNumber].dy = 0;
|
||
pSteps[stepNumber].dr = 0;
|
||
stepNumber++;
|
||
}
|
||
|
||
#if (0)
|
||
printf("after jump lock:\r\n");
|
||
for (i = 0; i < curtNumber; i++)
|
||
{
|
||
printf("DataItem %d:ctrl=0x%x, attr=0x%x, dx=%d, dy=%d\r\n", i, pSteps[i].ctrl, pSteps[i].attr, pSteps[i].dx, pSteps[i].dy);
|
||
}
|
||
#endif
|
||
|
||
pSteps += stepNumber;
|
||
totalNumber += stepNumber;
|
||
begflag = 1;
|
||
|
||
} // end of for(idx......
|
||
|
||
// 最后一针添加结束码
|
||
pData = (DATA_ITEM*)(g_datFile.dataBuff1BegAddr); // 源
|
||
|
||
pData[totalNumber].ctrl = DATA_END;
|
||
pData[totalNumber].attr = 0;
|
||
pData[totalNumber].dx = 0;
|
||
pData[totalNumber].dy = 0;
|
||
pData[totalNumber].dr = 0;
|
||
totalNumber++;
|
||
|
||
#if (0)
|
||
printf("after calc, begx=%d, begy=%d, stepNumber=%d\r\n", begx, begy, totalNumber);
|
||
#endif
|
||
|
||
#if (1)
|
||
|
||
pData = (DATA_ITEM*)(g_datFile.dataBuff1BegAddr); // 源
|
||
begflag = 0;
|
||
|
||
// 剪线数据移到缝纫之后
|
||
for (i = 0; i < totalNumber; i++)
|
||
{
|
||
if ((pData->ctrl == DATA_SEWING || pData->ctrl == DATA_SYNCSEW))
|
||
{
|
||
begflag = 1;
|
||
}
|
||
else if (pData->ctrl == pSqrt->defofst)
|
||
{
|
||
if (begflag == 1)
|
||
{
|
||
pSteps = pData;
|
||
begflag = 2;
|
||
}
|
||
else if (begflag != 2)
|
||
{
|
||
begflag = 0;
|
||
}
|
||
}
|
||
else if (pData->ctrl == DATA_CUTTRD)
|
||
{
|
||
if (begflag == 2)
|
||
{
|
||
// 交换 pSteps 和 pData
|
||
DATA_ITEM tmpItem;
|
||
memcpy(&tmpItem, pData, sizeof(DATA_ITEM));
|
||
memcpy(pData, pSteps, sizeof(DATA_ITEM));
|
||
memcpy(pSteps, &tmpItem, sizeof(DATA_ITEM));
|
||
}
|
||
begflag = 0;
|
||
}
|
||
else
|
||
{
|
||
begflag = 0;
|
||
}
|
||
pData++;
|
||
}
|
||
#endif // 剪线移到缝纫之后
|
||
|
||
pData = (DATA_ITEM*)(g_datFile.dataBuff1BegAddr); // 源
|
||
pSteps = pData; // 目标
|
||
// 扫描生成数据，确定起点坐标，合并offset数据
|
||
// 起点坐标
|
||
|
||
begr = pData[0].dr; // 第一个针步，dr是从0开始的变化量
|
||
pData[0].dr = 0; // 设置第一个针步的变化量为0
|
||
|
||
i = 0;
|
||
#if (0)
|
||
for (i = 0; i < totalNumber; i++)
|
||
{
|
||
if (pData->ctrl != pSqrt->defofst) // 起始的offset合并到起点坐标
|
||
{
|
||
break;
|
||
}
|
||
|
||
begx += pData->dx;
|
||
begy += pData->dy;
|
||
begr += pData->dr; // 改变起针位置
|
||
pData++; // 源后移
|
||
}
|
||
#endif
|
||
|
||
#if (0)
|
||
{
|
||
int offsetdr = 0;
|
||
|
||
begflag = 0;
|
||
actr = begr;
|
||
// 继续扫描生成数据，合并offset数据
|
||
for (i = i, j = 0; i < totalNumber; i++)
|
||
{
|
||
if (pData->ctrl == pSqrt->defofst)
|
||
{
|
||
if (begflag == 0)
|
||
{
|
||
// 初始化offset计数
|
||
threex[0] = 0;
|
||
threey[0] = 0;
|
||
threex[1] = 0;
|
||
threey[1] = 0;
|
||
threex[2] = 0;
|
||
threey[2] = 0;
|
||
offsetdr = 0;
|
||
begflag = 1;
|
||
}
|
||
|
||
threex[2] += pData->dx;
|
||
threey[2] += pData->dy;
|
||
offsetdr += pData->dr;
|
||
|
||
}
|
||
else
|
||
{
|
||
if (begflag != 0 && pData->ctrl != DATA_END) // 可以删除结束前的offset
|
||
{
|
||
// 重新插入偏移数据
|
||
actx = 0;
|
||
acty = 0;
|
||
stepNumber = CalcCurve(threex, threey, &actx, &acty, &actr, S16_MAX/2, pSteps, pSqrt->defofst);
|
||
pSteps->dr = offsetdr ;
|
||
|
||
pSteps += stepNumber;
|
||
j += stepNumber;
|
||
begflag = 0;
|
||
}
|
||
if (pSteps != pData)
|
||
{
|
||
memcpy(pSteps, pData, sizeof(DATA_ITEM));
|
||
}
|
||
j++;
|
||
actr += pSteps->dr;
|
||
pSteps++;
|
||
}
|
||
|
||
pData++;
|
||
}
|
||
|
||
totalNumber = j;
|
||
}
|
||
#endif
|
||
|
||
#if (0)
|
||
// 删除结束前的offset
|
||
begflag = 0;
|
||
pData = (DATA_ITEM*)(g_datFile.dataBuff1BegAddr); // 源
|
||
pData += totalNumber;
|
||
|
||
// 继续扫描生成数据，合并offset数据
|
||
for (i = i, j = 0; i < totalNumber; i++)
|
||
{
|
||
if (pData->ctrl == pSqrt->defofst || pData->ctrl == DATA_END)
|
||
{
|
||
pData->ctrl = DATA_END;
|
||
totalNumber--;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
pData--;
|
||
}
|
||
#endif
|
||
|
||
|
||
#if (1)
|
||
printf("before write begx=%d, begy=%d, stepNumber=%d\r\n", begx, begy, totalNumber);
|
||
#endif
|
||
|
||
|
||
#if (1)
|
||
// 写文件头
|
||
strcpy(g_datFile.pFileHead->fileHead.fileName, "test.dsr"); // 文件名称
|
||
g_datFile.pFileHead->fileHead.dataSize = totalNumber*sizeof(DATA_ITEM); // 文件长度
|
||
g_datFile.pFileHead->fileHead.itemNums = totalNumber; // 有效针数
|
||
g_datFile.pFileHead->fileHead.bytesPerItem = sizeof(DATA_ITEM); // 每针占的字节数
|
||
g_datFile.pFileHead->fileHead.bytesPerBlk = 1024; // 文件内容划分块大小
|
||
|
||
g_datFile.pFileHead->fileHead.dataChecksum = CalcCrc16((u8*)(g_datFile.dataBuff1BegAddr), g_datFile.pFileHead->fileHead.dataSize); // 花样数据累加校验和
|
||
g_datFile.pFileHead->fileHead.checkCrc = CalcCrc16((u8*)&(g_datFile.pFileHead), 48);
|
||
|
||
// 前6个字段CRC校验，文件名称，文件长度，有效针数，每针字节数，数据累加和的CRC校验值
|
||
g_datFile.pFileHead->fileHead.anchorX = begx; // pSqrt->startx;
|
||
g_datFile.pFileHead->fileHead.anchorY = begy; // pSqrt->starty; // 定位点
|
||
|
||
g_datFile.pFileHead->fileHead.beginX = begx; // pSqrt->startx;
|
||
g_datFile.pFileHead->fileHead.beginY = begy; // pSqrt->starty;
|
||
g_datFile.pFileHead->fileHead.beginR = begr; // 起始点坐标
|
||
|
||
g_datFile.pFileHead->fileHead.anchorX2 = pSqrt->startx2;
|
||
g_datFile.pFileHead->fileHead.anchorY2 = pSqrt->starty2; // 定位点
|
||
|
||
g_datFile.pFileHead->fileHead.beginX2 = pSqrt->startx2;
|
||
g_datFile.pFileHead->fileHead.beginY2 = pSqrt->starty2;
|
||
g_datFile.pFileHead->fileHead.beginR2 = 0; // 起始点坐标
|
||
|
||
g_datFile.enflag = DATA_VALID;
|
||
|
||
{
|
||
s32 minx, miny, maxx, maxy;
|
||
|
||
GetMinMaxFromFileDat(&minx, &maxx, &miny, &maxy);
|
||
|
||
g_datFile.pFileHead->fileHead.minX = minx;
|
||
g_datFile.pFileHead->fileHead.maxX = maxx;
|
||
g_datFile.pFileHead->fileHead.minY = miny;
|
||
g_datFile.pFileHead->fileHead.maxY = maxy;
|
||
}
|
||
|
||
#if (0)
|
||
printf("finial write:\r\n");
|
||
for (i = 0; i < stepNumber; i++)
|
||
{
|
||
printf("DataItem %d:ctrl=0x%x, attr=0x%x, dx=%d, dy=%d\r\n", i, pData[i].ctrl, pData[i].attr, pData[i].dx, pData[i].dy);
|
||
}
|
||
#endif
|
||
|
||
#endif // 写文件头
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
#if (1)
|
||
|
||
//#include "motos.h"
|
||
|
||
int WriteTestFile(int sel, int cx, int cy, int sx, int sy, int dex, int dey, u16 type, int stepSize)
|
||
{
|
||
SqrtInfo info;
|
||
|
||
memset(&info, 0, sizeof(SqrtInfo));
|
||
|
||
printf("sizeof(SqrtItem)=%d, sizeof(SqrtInfo)=%d\r\n", sizeof(SqrtItem), sizeof(SqrtInfo));
|
||
info.defofst = DATA_OFFSET;
|
||
|
||
if (sel == 0)
|
||
{
|
||
// 方框
|
||
info.sqrtItem[0].begx = cx-sx/2;
|
||
info.sqrtItem[0].begy = cy-sy/2;
|
||
info.sqrtItem[0].midx = cx-sx/2;
|
||
info.sqrtItem[0].midy = cy+sy/2;
|
||
info.sqrtItem[0].endx = cx-sx/2;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx-sx/2;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx+sx/2;
|
||
info.sqrtItem[1].midy = cy+sy/2;
|
||
info.sqrtItem[1].endx = cx+sx/2;
|
||
info.sqrtItem[1].endy = cy+sy/2;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtItem[2].begx = cx+sx/2;
|
||
info.sqrtItem[2].begy = cy+sy/2;
|
||
info.sqrtItem[2].midx = cx+sx/2;
|
||
info.sqrtItem[2].midy = cy-sy/2;
|
||
info.sqrtItem[2].endx = cx+sx/2;
|
||
info.sqrtItem[2].endy = cy-sy/2;
|
||
info.sqrtItem[2].type = type;
|
||
|
||
info.sqrtItem[3].begx = cx+sx/2;
|
||
info.sqrtItem[3].begy = cy-sy/2;
|
||
info.sqrtItem[3].midx = cx-sx/2;
|
||
info.sqrtItem[3].midy = cy-sy/2;
|
||
info.sqrtItem[3].endx = cx-sx/2;
|
||
info.sqrtItem[3].endy = cy-sy/2;
|
||
info.sqrtItem[3].type = type;
|
||
|
||
/* info.sqrtItem[4].begx = cx-sx;
|
||
info.sqrtItem[4].begy = cy-sy;
|
||
info.sqrtItem[4].midx = cx;
|
||
info.sqrtItem[4].midy = cy;
|
||
info.sqrtItem[4].endx = cx;
|
||
info.sqrtItem[4].endy = cy;
|
||
info.sqrtItem[4].type = DATA_OFFSET;*/
|
||
|
||
info.sqrtNum = 4;
|
||
}
|
||
else if (sel == 1)
|
||
{
|
||
// 圆
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy-sy/2;
|
||
info.sqrtItem[0].midx = cx-sx/2;
|
||
info.sqrtItem[0].midy = cy;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx+sx/2;
|
||
info.sqrtItem[1].midy = cy;
|
||
info.sqrtItem[1].endx = cx;
|
||
info.sqrtItem[1].endy = cy-sy/2;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtNum = 2;
|
||
}
|
||
else if (sel == 2)
|
||
{
|
||
int idx;
|
||
idx = 0;
|
||
while(idx < MAX_SQRT-1)
|
||
{
|
||
sx -= dex;
|
||
sy -= dey;
|
||
idx += 2;
|
||
}
|
||
|
||
idx = 0;
|
||
while(idx < MAX_SQRT-1)
|
||
{
|
||
// 同心圆
|
||
info.sqrtItem[idx+0].begx = cx;
|
||
info.sqrtItem[idx+0].begy = cy-sy/2;
|
||
info.sqrtItem[idx+0].midx = cx-sx/2;
|
||
info.sqrtItem[idx+0].midy = cy;
|
||
info.sqrtItem[idx+0].endx = cx;
|
||
info.sqrtItem[idx+0].endy = cy+sy/2;
|
||
info.sqrtItem[idx+0].type = type;
|
||
|
||
info.sqrtItem[idx+1].begx = cx;
|
||
info.sqrtItem[idx+1].begy = cy+sy/2;
|
||
info.sqrtItem[idx+1].midx = cx+sx/2;
|
||
info.sqrtItem[idx+1].midy = cy;
|
||
info.sqrtItem[idx+1].endx = cx;
|
||
info.sqrtItem[idx+1].endy = cy-sy/2;
|
||
info.sqrtItem[idx+1].type = type;
|
||
|
||
sx += dex;
|
||
sy += dey;
|
||
idx += 2;
|
||
}
|
||
info.sqrtNum = idx;
|
||
}
|
||
else if (sel == 3)
|
||
{
|
||
int idx;
|
||
idx = 0;
|
||
while(idx < MAX_SQRT-1)
|
||
{
|
||
// 同心圆
|
||
info.sqrtItem[idx+0].begx = cx-sx/2;
|
||
info.sqrtItem[idx+0].begy = cy;
|
||
info.sqrtItem[idx+0].midx = cx;
|
||
info.sqrtItem[idx+0].midy = cy+sy/2;
|
||
info.sqrtItem[idx+0].endx = cx+sx/2;
|
||
info.sqrtItem[idx+0].endy = cy;
|
||
info.sqrtItem[idx+0].type = type;
|
||
|
||
info.sqrtItem[idx+1].begx = cx+sx/2;
|
||
info.sqrtItem[idx+1].begy = cy;
|
||
info.sqrtItem[idx+1].midx = cx;
|
||
info.sqrtItem[idx+1].midy = cy-sy/2;
|
||
info.sqrtItem[idx+1].endx = cx-sx/2;
|
||
info.sqrtItem[idx+1].endy = cy;
|
||
info.sqrtItem[idx+1].type = type;
|
||
|
||
sx -= dex;
|
||
sy -= dey;
|
||
idx += 2;
|
||
}
|
||
info.sqrtNum = idx;
|
||
}
|
||
else if (sel == 4)
|
||
{
|
||
// 遮阳帘裁片
|
||
info.sqrtItem[0].begx = cx-sx/2;
|
||
info.sqrtItem[0].begy = cy-sy/2;
|
||
info.sqrtItem[0].midx = cx-sx/2;
|
||
info.sqrtItem[0].midy = cy+sy/2;
|
||
info.sqrtItem[0].endx = cx-sx/2;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx-sx/2;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx-sx/32;
|
||
info.sqrtItem[1].midy = cy+sy/2;
|
||
info.sqrtItem[1].endx = cx-sx/32;
|
||
info.sqrtItem[1].endy = cy+sy/2;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtItem[2].begx = cx-sx/32;
|
||
info.sqrtItem[2].begy = cy+sy/2;
|
||
info.sqrtItem[2].midx = cx;
|
||
info.sqrtItem[2].midy = cy+sy/2-sy/24;
|
||
info.sqrtItem[2].endx = cx;
|
||
info.sqrtItem[2].endy = cy+sy/2-sy/24;
|
||
info.sqrtItem[2].type = type;
|
||
|
||
info.sqrtItem[3].begx = cx;
|
||
info.sqrtItem[3].begy = cy+sy/2-sy/24;
|
||
info.sqrtItem[3].midx = cx+sx/32;
|
||
info.sqrtItem[3].midy = cy+sy/2;
|
||
info.sqrtItem[3].endx = cx+sx/32;
|
||
info.sqrtItem[3].endy = cy+sy/2;
|
||
info.sqrtItem[3].type = type;
|
||
|
||
info.sqrtItem[4].begx = cx+sx/32;
|
||
info.sqrtItem[4].begy = cy+sy/2;
|
||
info.sqrtItem[4].midx = cx+sx/2;
|
||
info.sqrtItem[4].midy = cy+sy/2;
|
||
info.sqrtItem[4].endx = cx+sx/2;
|
||
info.sqrtItem[4].endy = cy+sy/2;
|
||
info.sqrtItem[4].type = type;
|
||
|
||
info.sqrtItem[5].begx = cx+sx/2;
|
||
info.sqrtItem[5].begy = cy+sy/2;
|
||
info.sqrtItem[5].midx = cx+sx/2;
|
||
info.sqrtItem[5].midy = cy-sy/2;
|
||
info.sqrtItem[5].endx = cx+sx/2;
|
||
info.sqrtItem[5].endy = cy-sy/2;
|
||
info.sqrtItem[5].type = type;
|
||
|
||
info.sqrtItem[6].begx = cx+sx/2;
|
||
info.sqrtItem[6].begy = cy-sy/2;
|
||
info.sqrtItem[6].midx = cx+sx/2-sx*1/8+sx/24;
|
||
info.sqrtItem[6].midy = cy-sy/2-sy*1/8+sy/12;
|
||
info.sqrtItem[6].endx = cx+sx/2-sx*1/8;
|
||
info.sqrtItem[6].endy = cy-sy/2-sy*1/8;
|
||
info.sqrtItem[6].type = type;
|
||
|
||
info.sqrtItem[7].begx = cx+sx/2-sx*1/8;
|
||
info.sqrtItem[7].begy = cy-sy/2-sy*1/8;
|
||
info.sqrtItem[7].midx = cx-sx/2+sx*1/8;
|
||
info.sqrtItem[7].midy = cy-sy/2-sy*1/8;
|
||
info.sqrtItem[7].endx = cx-sx/2+sx*1/8;
|
||
info.sqrtItem[7].endy = cy-sy/2-sy*1/8;
|
||
info.sqrtItem[7].type = type;
|
||
|
||
info.sqrtItem[8].begx = cx-sx/2+sx*1/8;
|
||
info.sqrtItem[8].begy = cy-sy/2-sy*1/8;
|
||
info.sqrtItem[8].midx = cx-sx/2+sx*1/8-sx/24;
|
||
info.sqrtItem[8].midy = cy-sy/2-sy*1/8+sy/12;
|
||
info.sqrtItem[8].endx = cx-sx/2;
|
||
info.sqrtItem[8].endy = cy-sy/2;
|
||
info.sqrtItem[8].type = type;
|
||
|
||
info.sqrtItem[9].begx = cx-sx/2;
|
||
info.sqrtItem[9].begy = cy-sy/2;
|
||
info.sqrtItem[9].midx = cx;
|
||
info.sqrtItem[9].midy = cy;
|
||
info.sqrtItem[9].endx = cx;
|
||
info.sqrtItem[9].endy = cy;
|
||
info.sqrtItem[9].type = DATA_OFFSET;
|
||
|
||
info.sqrtNum = 10;
|
||
}
|
||
else if (sel == 5)
|
||
{
|
||
// Y向曲线
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy;
|
||
info.sqrtItem[0].midx = cx+sx/2;
|
||
info.sqrtItem[0].midy = cy+sy/4;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx-sx/2;
|
||
info.sqrtItem[1].midy = cy+sy*3/4;
|
||
info.sqrtItem[1].endx = cx;
|
||
info.sqrtItem[1].endy = cy+sy;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtNum = 2;
|
||
}
|
||
else if (sel == 6)
|
||
{
|
||
// Y向曲线
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy;
|
||
info.sqrtItem[0].midx = cx-sx/2;
|
||
info.sqrtItem[0].midy = cy+sy/4;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx+sx/2;
|
||
info.sqrtItem[1].midy = cy+sy*3/4;
|
||
info.sqrtItem[1].endx = cx;
|
||
info.sqrtItem[1].endy = cy+sy;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtNum = 2;
|
||
}
|
||
else if (sel == 7)
|
||
{
|
||
// Y向直线
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy;
|
||
info.sqrtItem[0].midx = cx;
|
||
info.sqrtItem[0].midy = cy;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtNum = 1;
|
||
}
|
||
else if (sel == 8)
|
||
{// 格子图, dex 个x向格子 dey 个y向格子，格子大小是sx, sy
|
||
int i,j;
|
||
|
||
info.startx = cx;
|
||
info.starty = cy;
|
||
|
||
for (i = 0; i <= dey; i++) // x线条
|
||
{
|
||
if ((i%2) == 0)
|
||
{
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy+i*sy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy+i*sy;
|
||
info.sqrtItem[i].endx = cx+dex*sx;
|
||
info.sqrtItem[i].endy = cy+i*sy;
|
||
info.sqrtItem[i].type = type;
|
||
}
|
||
else
|
||
{
|
||
info.sqrtItem[i].begx = cx+dex*sx;
|
||
info.sqrtItem[i].begy = cy+i*sy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy+i*sy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+i*sy;
|
||
info.sqrtItem[i].type = type;
|
||
}
|
||
}
|
||
for (j = 0; j <= dex; j++,i++) // y线条
|
||
{
|
||
if ((i%2) == 0)
|
||
{
|
||
info.sqrtItem[i].begx = cx+(j)*sx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx+(j)*sx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx+(j)*sx;
|
||
info.sqrtItem[i].endy = cy+dey*sy;
|
||
info.sqrtItem[i].type = type;
|
||
}
|
||
else
|
||
{
|
||
info.sqrtItem[i].begx = cx+(j)*sx;
|
||
info.sqrtItem[i].begy = cy+dey*sy;
|
||
info.sqrtItem[i].midx = cx+(j)*sx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx+(j)*sx;
|
||
info.sqrtItem[i].endy = cy;
|
||
info.sqrtItem[i].type = type;
|
||
}
|
||
}
|
||
info.sqrtNum = i;
|
||
}
|
||
else if (sel == 10)
|
||
{
|
||
// 螺旋线
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy-sy*12/24;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy*10/24;
|
||
info.sqrtItem[0].midx = cx+sy*11/24;
|
||
info.sqrtItem[0].midy = cy-sy*1/24;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx;
|
||
info.sqrtItem[1].begy = cy+sy*10/24;
|
||
info.sqrtItem[1].endx = cx;
|
||
info.sqrtItem[1].endy = cy-sy*8/24;
|
||
info.sqrtItem[1].midx = cx-sy*9/24;
|
||
info.sqrtItem[1].midy = cy+sy*1/24;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtItem[2].begx = cx;
|
||
info.sqrtItem[2].begy = cy-sy*8/24;
|
||
info.sqrtItem[2].endx = cx;
|
||
info.sqrtItem[2].endy = cy+sy*6/24;
|
||
info.sqrtItem[2].midx = cx+sy*7/24;
|
||
info.sqrtItem[2].midy = cy-sy*1/24;
|
||
info.sqrtItem[2].type = type;
|
||
|
||
info.sqrtItem[3].begx = cx;
|
||
info.sqrtItem[3].begy = cy+sy*6/24;
|
||
info.sqrtItem[3].endx = cx;
|
||
info.sqrtItem[3].endy = cy-sy*4/24;
|
||
info.sqrtItem[3].midx = cx-sy*5/24;
|
||
info.sqrtItem[3].midy = cy+sy*1/24;
|
||
info.sqrtItem[3].type = type;
|
||
|
||
info.sqrtItem[4].begx = cx;
|
||
info.sqrtItem[4].begy = cy-sy*4/24;
|
||
info.sqrtItem[4].endx = cx;
|
||
info.sqrtItem[4].endy = cy;
|
||
info.sqrtItem[4].midx = cx+sy*2/24;
|
||
info.sqrtItem[4].midy = cy-sy*2/24;
|
||
info.sqrtItem[4].type = type;
|
||
|
||
info.sqrtItem[5].begx = cx;
|
||
info.sqrtItem[5].begy = cy;
|
||
info.sqrtItem[5].endx = cx;
|
||
info.sqrtItem[5].endy = cy+sy*4/24;
|
||
info.sqrtItem[5].midx = cx-sy*2/24;
|
||
info.sqrtItem[5].midy = cy+sy*2/24;
|
||
info.sqrtItem[5].type = type;
|
||
|
||
info.sqrtItem[6].begx = cx;
|
||
info.sqrtItem[6].begy = cy+sy*4/24;
|
||
info.sqrtItem[6].endx = cx;
|
||
info.sqrtItem[6].endy = cy-sy*6/24;
|
||
info.sqrtItem[6].midx = cx+sy*5/24;
|
||
info.sqrtItem[6].midy = cy-sy*1/24;
|
||
info.sqrtItem[6].type = type;
|
||
|
||
info.sqrtItem[7].begx = cx;
|
||
info.sqrtItem[7].begy = cy-sy*6/24;
|
||
info.sqrtItem[7].endx = cx;
|
||
info.sqrtItem[7].endy = cy+sy*8/24;
|
||
info.sqrtItem[7].midx = cx-sy*7/24;
|
||
info.sqrtItem[7].midy = cy+sy*1/24;
|
||
info.sqrtItem[7].type = type;
|
||
|
||
info.sqrtItem[8].begx = cx;
|
||
info.sqrtItem[8].begy = cy+sy*8/24;
|
||
info.sqrtItem[8].endx = cx;
|
||
info.sqrtItem[8].endy = cy-sy*10/24;
|
||
info.sqrtItem[8].midx = cx+sy*9/24;
|
||
info.sqrtItem[8].midy = cy-sy*1/24;
|
||
info.sqrtItem[8].type = type;
|
||
|
||
info.sqrtItem[9].begx = cx;
|
||
info.sqrtItem[9].begy = cy-sy*10/24;
|
||
info.sqrtItem[9].endx = cx;
|
||
info.sqrtItem[9].endy = cy+sy*12/24;
|
||
info.sqrtItem[9].midx = cx-sy*11/24;
|
||
info.sqrtItem[9].midy = cy+sy*1/24;
|
||
info.sqrtItem[9].type = type;
|
||
|
||
info.sqrtNum = 10;
|
||
}
|
||
else if (sel == 11)
|
||
{
|
||
// 逆时针圆
|
||
info.sqrtItem[0].begx = cx;
|
||
info.sqrtItem[0].begy = cy-sy/2;
|
||
info.sqrtItem[0].midx = cx+sx/2;
|
||
info.sqrtItem[0].midy = cy;
|
||
info.sqrtItem[0].endx = cx;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx-sx/2;
|
||
info.sqrtItem[1].midy = cy;
|
||
info.sqrtItem[1].endx = cx;
|
||
info.sqrtItem[1].endy = cy-sy/2;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtNum = 2;
|
||
}
|
||
else if (sel == 12)
|
||
{
|
||
// 方套圆
|
||
info.sqrtItem[0].begx = cx-sx/2;
|
||
info.sqrtItem[0].begy = cy-sy/2;
|
||
info.sqrtItem[0].midx = cx-sx/2;
|
||
info.sqrtItem[0].midy = cy+sy/2;
|
||
info.sqrtItem[0].endx = cx-sx/2;
|
||
info.sqrtItem[0].endy = cy+sy/2;
|
||
info.sqrtItem[0].type = type;
|
||
|
||
info.sqrtItem[1].begx = cx-sx/2;
|
||
info.sqrtItem[1].begy = cy+sy/2;
|
||
info.sqrtItem[1].midx = cx+sx/2;
|
||
info.sqrtItem[1].midy = cy+sy/2;
|
||
info.sqrtItem[1].endx = cx+sx/2;
|
||
info.sqrtItem[1].endy = cy+sy/2;
|
||
info.sqrtItem[1].type = type;
|
||
|
||
info.sqrtItem[2].begx = cx+sx/2;
|
||
info.sqrtItem[2].begy = cy+sy/2;
|
||
info.sqrtItem[2].midx = cx+sx/2;
|
||
info.sqrtItem[2].midy = cy-sy/2;
|
||
info.sqrtItem[2].endx = cx+sx/2;
|
||
info.sqrtItem[2].endy = cy-sy/2;
|
||
info.sqrtItem[2].type = type;
|
||
|
||
info.sqrtItem[3].begx = cx+sx/2;
|
||
info.sqrtItem[3].begy = cy-sy/2;
|
||
info.sqrtItem[3].midx = cx-sx/2;
|
||
info.sqrtItem[3].midy = cy-sy/2;
|
||
info.sqrtItem[3].endx = cx-sx/2;
|
||
info.sqrtItem[3].endy = cy-sy/2;
|
||
info.sqrtItem[3].type = type;
|
||
|
||
info.sqrtItem[4].begx = cx;
|
||
info.sqrtItem[4].begy = cy-sy/2;
|
||
info.sqrtItem[4].midx = cx+sx/2;
|
||
info.sqrtItem[4].midy = cy;
|
||
info.sqrtItem[4].endx = cx;
|
||
info.sqrtItem[4].endy = cy+sy/2;
|
||
info.sqrtItem[4].type = type;
|
||
|
||
info.sqrtItem[5].begx = cx;
|
||
info.sqrtItem[5].begy = cy+sy/2;
|
||
info.sqrtItem[5].midx = cx-sx/2;
|
||
info.sqrtItem[5].midy = cy;
|
||
info.sqrtItem[5].endx = cx;
|
||
info.sqrtItem[5].endy = cy-sy/2;
|
||
info.sqrtItem[5].type = type;
|
||
|
||
info.sqrtNum = 6;
|
||
}
|
||
else if (sel == 100) // 冲缝绣360测试
|
||
{
|
||
int idx, n, bx;
|
||
double temp;
|
||
idx = 0;
|
||
|
||
// 方套圆缝纫
|
||
info.sqrtItem[idx].begx = cx-sx/2;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy+sy/2;
|
||
info.sqrtItem[idx].endx = cx-sx/2;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx-sx/2;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy+sy/2;
|
||
info.sqrtItem[idx].endx = cx+sx/2;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx+sx/2;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy-sy/2;
|
||
info.sqrtItem[idx].endx = cx+sx/2;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx+sx/2;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy-sy/2;
|
||
info.sqrtItem[idx].endx = cx-sx/2;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy;
|
||
info.sqrtItem[idx].endx = cx;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy;
|
||
info.sqrtItem[idx].endx = cx;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_SEWING;
|
||
idx++;
|
||
|
||
temp = sx;
|
||
temp /= sqrt(2);
|
||
sx = (int)(temp + 0.5);
|
||
|
||
temp = sy;
|
||
temp /= sqrt(2);
|
||
sy = (int)(temp + 0.5);
|
||
|
||
// 方套圆绣花
|
||
info.sqrtItem[idx].begx = cx-sx/2;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy+sy/2;
|
||
info.sqrtItem[idx].endx = cx-sx/2;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx-sx/2;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy+sy/2;
|
||
info.sqrtItem[idx].endx = cx+sx/2;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx+sx/2;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy-sy/2;
|
||
info.sqrtItem[idx].endx = cx+sx/2;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx+sx/2;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy-sy/2;
|
||
info.sqrtItem[idx].endx = cx-sx/2;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = cx+sx/2;
|
||
info.sqrtItem[idx].midy = cy;
|
||
info.sqrtItem[idx].endx = cx;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
info.sqrtItem[idx].begx = cx;
|
||
info.sqrtItem[idx].begy = cy+sy/2;
|
||
info.sqrtItem[idx].midx = cx-sx/2;
|
||
info.sqrtItem[idx].midy = cy;
|
||
info.sqrtItem[idx].endx = cx;
|
||
info.sqrtItem[idx].endy = cy-sy/2;
|
||
info.sqrtItem[idx].type = DATA_EMB;
|
||
idx++;
|
||
|
||
// 冲孔填充方框
|
||
temp = sx;
|
||
temp /= sqrt(2);
|
||
sx = (int)(temp + 0.5);
|
||
|
||
temp = sy;
|
||
temp /= sqrt(2);
|
||
sy = (int)(temp + 0.5);
|
||
|
||
n = sx / stepSize;
|
||
bx = cx - sx/2;
|
||
if (n > 0)
|
||
{
|
||
temp = sx;
|
||
temp /= n;
|
||
}
|
||
while (n > 0)
|
||
{
|
||
info.sqrtItem[idx].begx = bx;
|
||
info.sqrtItem[idx].begy = cy-sy/2;
|
||
info.sqrtItem[idx].midx = bx;
|
||
info.sqrtItem[idx].midy = cy+sy/2;
|
||
info.sqrtItem[idx].endx = bx;
|
||
info.sqrtItem[idx].endy = cy+sy/2;
|
||
info.sqrtItem[idx].type = DATA_PUNCH;
|
||
|
||
idx++;
|
||
n--;
|
||
bx += temp;
|
||
}
|
||
info.sqrtNum = idx;
|
||
}
|
||
else if (sel == 201 || sel == 202 || sel == 203) // 双头直线绗缝机测试花版
|
||
{
|
||
int i;
|
||
int curtype, curofst;
|
||
|
||
int mistep, normalstep;
|
||
|
||
s32 begx, begy, endy;
|
||
// s32 endx;
|
||
s32 temp1, temp2;
|
||
|
||
begx = cx;
|
||
begy = cy;
|
||
|
||
// endx = cx;
|
||
endy = sy;
|
||
|
||
if (sel == 201)
|
||
{
|
||
curtype = DATA_SEWING;
|
||
curofst = DATA_OFFSET;
|
||
|
||
info.startx = begx;
|
||
info.starty = begy;
|
||
info.startx2 = 0;
|
||
info.starty2 = begy;
|
||
}
|
||
else if (sel == 202)
|
||
{
|
||
curtype = DATA_SECF_SEW;
|
||
curofst = DATA_SECF_OFST;
|
||
|
||
info.startx = 266600;
|
||
info.starty = begy;
|
||
info.startx2 = begx;
|
||
info.starty2 = begy;
|
||
}
|
||
else if (sel == 203)
|
||
{
|
||
curtype = DATA_SECF_SEW;
|
||
curofst = DATA_SECF_OFST;
|
||
|
||
info.startx = begx;
|
||
info.starty = begy;
|
||
info.startx2 = begx + 20000;
|
||
info.starty2 = begy;
|
||
}
|
||
|
||
info.defofst = curofst;
|
||
|
||
mistep = 400;
|
||
normalstep = 1200;
|
||
|
||
temp1 = begy + 5000;
|
||
temp2 = endy - 5000;
|
||
|
||
i = 0;
|
||
// A机头或B机头缝纫数据 密针
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = begy;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = begy;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = temp1;
|
||
info.sqrtItem[i].stepSize = mistep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
// A机头或B机头缝纫数据 普通针步
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = temp1;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = temp1;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = temp2;
|
||
info.sqrtItem[i].stepSize = normalstep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
// A机头或B机头缝纫数据 密针
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = temp2;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = temp2;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = endy;
|
||
info.sqrtItem[i].stepSize = mistep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
// 越框
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = endy;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = endy;
|
||
info.sqrtItem[i].endx = begx+10000;
|
||
info.sqrtItem[i].endy = endy;
|
||
info.sqrtItem[i].stepSize = S16_MAX/2;
|
||
info.sqrtItem[i].type = curofst;
|
||
|
||
begx += 10000;
|
||
|
||
// A机头或B机头缝纫数据 密针
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = endy;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = endy;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = temp2;
|
||
info.sqrtItem[i].stepSize = mistep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
// A机头或B机头缝纫数据 普通针步
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = temp2;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = temp2;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = temp1;
|
||
info.sqrtItem[i].stepSize = normalstep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
// A机头或B机头缝纫数据 密针
|
||
info.sqrtItem[i].begx = begx;
|
||
info.sqrtItem[i].begy = temp1;
|
||
info.sqrtItem[i].midx = begx;
|
||
info.sqrtItem[i].midy = temp1;
|
||
info.sqrtItem[i].endx = begx;
|
||
info.sqrtItem[i].endy = begy;
|
||
info.sqrtItem[i].stepSize = mistep;
|
||
info.sqrtItem[i].type = curtype;
|
||
i++;
|
||
|
||
info.sqrtNum = i;
|
||
}
|
||
else if (sel == 204)
|
||
{
|
||
int i;
|
||
|
||
#define MIZHEN_LEN 5000
|
||
#define NMZHEN1_LEN 10000
|
||
#define NMZHEN2_LEN 100000
|
||
|
||
i = 0;
|
||
|
||
// AB 机头移动数据
|
||
// A机头移动数据
|
||
// B机头移动数据
|
||
|
||
// A机头缝纫数据 密针 50mm
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+MIZHEN_LEN;
|
||
info.sqrtItem[i].stepSize = 400;
|
||
info.sqrtItem[i].type = DATA_SEWING;
|
||
i++;
|
||
|
||
cy += MIZHEN_LEN;
|
||
// A机头缝纫数据 普通针步100mm
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+NMZHEN1_LEN;
|
||
info.sqrtItem[i].stepSize = 1000;
|
||
info.sqrtItem[i].type = DATA_SEWING;
|
||
i++;
|
||
|
||
cy += NMZHEN1_LEN;
|
||
// AB机头缝纫数据 密针 50mm
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+5000;
|
||
info.sqrtItem[i].stepSize = 400;
|
||
info.sqrtItem[i].type = DATA_SYNCSEW;
|
||
i++;
|
||
|
||
// AB机头缝纫数据 普通针步 100000
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+NMZHEN2_LEN;
|
||
info.sqrtItem[i].stepSize = 1000;
|
||
info.sqrtItem[i].type = DATA_SYNCSEW;
|
||
i++;
|
||
|
||
cy += NMZHEN2_LEN;
|
||
|
||
// AB机头缝纫数据 密针
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+5000;
|
||
info.sqrtItem[i].stepSize = 400;
|
||
info.sqrtItem[i].type = DATA_SYNCSEW;
|
||
i++;
|
||
|
||
// A机头缝纫数据 普通针步 100mm
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+NMZHEN1_LEN;
|
||
info.sqrtItem[i].stepSize = 1000;
|
||
info.sqrtItem[i].type = DATA_SEWING;
|
||
i++;
|
||
|
||
// A机头缝纫数据 密针 50mm
|
||
info.sqrtItem[i].begx = cx;
|
||
info.sqrtItem[i].begy = cy;
|
||
info.sqrtItem[i].midx = cx;
|
||
info.sqrtItem[i].midy = cy;
|
||
info.sqrtItem[i].endx = cx;
|
||
info.sqrtItem[i].endy = cy+MIZHEN_LEN;
|
||
info.sqrtItem[i].stepSize = 400;
|
||
info.sqrtItem[i].type = DATA_SEWING;
|
||
i++;
|
||
|
||
// AB 机头移动数据
|
||
// A机头移动数据
|
||
// B机头移动数据
|
||
|
||
// B机头缝纫数据 密针
|
||
// B机头缝纫数据 普通针步
|
||
|
||
// AB机头缝纫数据 密针
|
||
// AB机头缝纫数据 普通针步
|
||
|
||
// AB机头缝纫数据 密针
|
||
// B机头缝纫数据 普通针步
|
||
// B机头缝纫数据 密针
|
||
|
||
// A机头移动数据
|
||
// B机头移动数据
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (stepSize <= 0 || stepSize >= 65536)
|
||
{
|
||
stepSize = 100;
|
||
printf("stepsize is not support, use default\r\n");
|
||
}
|
||
|
||
info.stepSize = stepSize;
|
||
info.blockNum = 0;
|
||
info.blockTimes = 0;
|
||
info.elockNum = 0;
|
||
info.elockTimes = 0;
|
||
|
||
info.blockjumps = 0;
|
||
info.elockjumps = 0;
|
||
|
||
return CreateCommFile(&info);
|
||
}
|
||
|
||
#endif
|
||
|
||
|
||
|
||
#endif // 生成数据文件的算法
|
||
|
||
|
||
//---------------------------------------------------------------------------------------------------------
|
||
|
||
|
||
|
||
#endif
|
||
|
||
|
||
|
||
|