/*********************************************************************/
/* macro.h: Head file for Flexem studio Macro                                                       */
/*********************************************************************/
/* This file is part of the Flexem Studio tools.                                                        */
/* Copyright (c) 2010-2015 Flexem technology. All rights reserved.                        */
/* This software may only be used under the terms of a valid, current,                    */
/* end user licence from Flexem for a compatible version of Flexem studio software */
/* Nothing else gives you the right to use this software.                                          */
/**********************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>   /* Time structures for select() */
#include     <sys/types.h>  
#include     <sys/stat.h>   
#include     <fcntl.h>      /*文件控制定义*/
#ifndef WIN32
	#include <sys/ioctl.h>
#endif

#define MAX_BYTES (64000)

#define DIR char

typedef int(*MacroOper)(const char* cmd, void *param, int* errno);
typedef enum { FALSE = 0, TRUE = !FALSE } bool;
#define  MacroMain()  _macro_main(MacroOper macroOper)


int g_Errno;
// Function to get error code 
int GetError(void)
{
	return g_Errno;
}

enum DataType
{
	DATA_INT16 = 1,
	DATA_INT32 = 2,
	DATA_FLOAT = 3
};

#define ByteOrder(data, macId, addrID, offset, nBytes, dataType) _ByteOrder(data, macId, addrID, offset, nBytes, dataType, macroOper)
int _ByteOrder(void *pDat, const char* macId, const char* addrID, unsigned int offset, unsigned int nBytes, int dataType, MacroOper macroOper)
{
	int param[] = { (int)pDat, (int)macId, (int)addrID, (int)offset, (int)nBytes, (int)dataType };
	return macroOper("ByteOrder", param, &g_Errno);
}
/* return:
1--success(TRUE)
0--other error(FALSE, include timeout,comerror,undone,byte order failed)
(-4)--bypass	(add list failed)*/
#define GetMemEx(data, macId, addrID, offset, nBytes, dataType)  _GetMemEX(data, macId, addrID, offset, nBytes, dataType, macroOper)
int _GetMemEX(void *pDat, const char* macId, const char* addrID, unsigned int offset, unsigned int nBytes, int dataType, MacroOper macroOper)
{
	int ret = _GetMem(pDat, macId, addrID, offset, nBytes, macroOper);
	if(TRUE != (ret))
	{
		return ret;
	}
	else 
	{
		return (_ByteOrder(pDat, macId, addrID, offset, nBytes, dataType, macroOper));
	}
}

/* return:
1--success(TRUE)
0--other error(FALSE, include timeout,comerror,undone)
(-4)--bypass	(add list failed)*/
#define GetMem(data, macId, addrID, offset, nBytes)  _GetMem(data, macId, addrID, offset, nBytes, macroOper)
int _GetMem(void *pDat, const char* macId, const char* addrID, unsigned int offset, unsigned int nBytes, MacroOper macroOper)
{
	if (nBytes > MAX_BYTES)
	{
		int regInfs[8] = { 0 };
		int infPrm[8] = { (int)regInfs, (int)macId, (int)addrID };
		macroOper("LoadRegInfo", infPrm, &g_Errno);

		int ret = TRUE;
		int iBytes = 0;
		while (iBytes < nBytes)
		{
			int leftBytes = nBytes - iBytes;
			if (leftBytes > MAX_BYTES)
			{
				leftBytes = MAX_BYTES;
			}
			int param[] = { (int)pDat + iBytes, (int)macId, (int)addrID, (int)offset + iBytes / regInfs[0], (int)leftBytes };
			if (!macroOper("GetMem", param, &g_Errno))
			{
				if(g_Errno == 4)
					ret = (-g_Errno);
				else
					ret = FALSE;
				break;
			}
			iBytes += leftBytes;
		}
		return ret;
	}
	int param[] = { (int)pDat, (int)macId, (int)addrID, (int)offset, (int)nBytes };
	
	if (!macroOper("GetMem", param, &g_Errno))
	{
		if(g_Errno == 4)
			return (-g_Errno);
		else
			return FALSE;
	}
	return TRUE;
}

#define GetBit(macroID, addrID, offset) _GetBit(macroID, addrID, offset, macroOper)
bool  _GetBit(const char* macroID, const char* addrID, unsigned int offset, MacroOper macroOper)
{
	int bDat = 0;
	GetMem(&bDat, macroID, addrID, offset, 1);
	return !!(bDat & 0xff);
}

#define GetWord(macroID, addrID, offset) _GetWord(macroID, addrID, offset, macroOper)
unsigned short _GetWord(const char* macroID, const char * addrID, unsigned int offset, MacroOper macroOper)
{
	unsigned short wDat = 0;
	GetMem(&wDat, macroID, addrID, offset, sizeof(wDat));
	ByteOrder(&wDat, macroID, addrID, offset, sizeof(wDat), DATA_INT16);
	return wDat;
}

#define GetDWord(macroID, addrID, offset) _GetDWord(macroID, addrID, offset, macroOper)
unsigned int _GetDWord(const char* macroID, const char *  addrID, unsigned int offset, MacroOper macroOper)
{
	unsigned int dwDat = 0;
	GetMem(&dwDat, macroID, addrID, offset, sizeof(dwDat));
	ByteOrder(&dwDat, macroID, addrID, offset, sizeof(dwDat), DATA_INT32);
	return dwDat;
}

#define GetFloat(macroID, addrID, offset) _GetFloat(macroID, addrID, offset, macroOper)
float _GetFloat(const char* macroID, const char *  addrID, unsigned int offset, MacroOper macroOper)
{
	float fDat = 0;
	GetMem(&fDat, macroID, addrID, offset, sizeof(fDat));
	ByteOrder(&fDat, macroID, addrID, offset, sizeof(fDat), DATA_FLOAT);
	return fDat;
}

#define SetMemEx(data, macId, addrID, offset, nBytes, dataType)  _SetMemEX(data, macId, addrID, offset, nBytes, dataType, macroOper)
int _SetMemEX(void *pDat, const char* macId, const char* addrID, unsigned int offset, unsigned int nBytes, int dataType, MacroOper macroOper)
{
	if(1 != (_ByteOrder(pDat, macId, addrID, offset, nBytes, dataType, macroOper)))
		return 0;
	else 
		return (_SetMem(pDat, macId, addrID, offset,  nBytes, macroOper));
}

#define SetMem(data, macId, addrID, offset,  nBytes)  _SetMem(data, macId, addrID, offset, nBytes, macroOper)
int _SetMem(void* pDat, const char* macId, const char* addrID, int offset, unsigned int nBytes, MacroOper macroOper)
{
	if (nBytes > MAX_BYTES)
	{
		int regInfs[8] = { 0 };
		int infPrm[8] = { (int)regInfs, (int)macId, (int)addrID };
		macroOper("LoadRegInfo", infPrm, &g_Errno);

		int ret = TRUE;
		int iBytes = 0;
		while (iBytes < nBytes)
		{
			int leftBytes = nBytes - iBytes;
			if (leftBytes > MAX_BYTES)
			{
				leftBytes = MAX_BYTES;
			}
			int param[] = { (int)pDat + iBytes, (int)macId, (int)addrID, (int)offset + iBytes / regInfs[0], (int)leftBytes };
			if (!macroOper("SetMem", param, &g_Errno))
			{
				if(g_Errno == 4)
					ret = (-g_Errno);
				else
					ret = FALSE;
				break;
			}
			iBytes += leftBytes;
		}
		return ret;
	}
	int param[] = { (int)pDat, (int)macId, (int)addrID, (int)offset, (int)nBytes };
	
	if (!macroOper("SetMem", param, &g_Errno))
	{
		if(g_Errno == 4)
			return (-g_Errno);
		else
			return FALSE;
	}
	return TRUE;
}

#define SetBit(macroID, addrID, offset,value) _SetBit(macroID, addrID, offset, value, macroOper)
int _SetBit(const char* macroID, const char* addrID, unsigned int offset, bool value, MacroOper macroOper)
{
	return SetMem(&value, macroID, addrID, offset, 1);
}

#define SetWord(macroID, addrID, offset,value) _SetWord(macroID, addrID, offset,value, macroOper)
int _SetWord(const char* macroID, const char *  addrID, unsigned int offset, short value, MacroOper macroOper)
{
	ByteOrder(&value, macroID, addrID, offset, sizeof(short), DATA_INT16);
	return SetMem(&value, macroID, addrID, offset, sizeof(short));
}

#define SetDWord(macroID, addrID, offset, value) _SetDWord(macroID, addrID, offset,value, macroOper)
int _SetDWord(const char* macroID, const char *  addrID, unsigned int offset, int value, MacroOper macroOper)
{
	ByteOrder(&value, macroID, addrID, offset, sizeof(int), DATA_INT32);
	return SetMem(&value, macroID, addrID, offset, sizeof(int));
}

#define SetFloat(macroID, addrID, offset, value) _SetFloat(macroID, addrID, offset,value, macroOper)
int _SetFloat(const char* macroID, const char *  addrID, unsigned int offset, float value, MacroOper macroOper)
{
	ByteOrder(&value, macroID, addrID, offset, sizeof(float), DATA_FLOAT);
	return SetMem(&value, macroID, addrID, offset, sizeof(float));
}

#define CallMacro(macroID) _CallMacro(macroID, macroOper)
int _CallMacro(const char * macroID, MacroOper macroOper)
{
	int param[] = { (int)macroID };
	return macroOper("CallMacro", param, &g_Errno);
}

#define Delay(mS) _Delay(mS,macroOper)
void _Delay(unsigned int mS, MacroOper macroOper)
{
	int param[] = { (int)mS };
	macroOper("Delay", param, &g_Errno);
	return;
}

#define Outport(Port, buff, data_count) _Outport(Port, buff, data_count, macroOper)
int _Outport(unsigned int Port, void * buff, unsigned int data_count, MacroOper macroOper)
{
	int param[] = { (int)Port, (int)buff, (int)data_count };
	return macroOper("Outport", param, &g_Errno);
}

#define Inport(Port, buff, data_count, waitMs) _Inport(Port, buff, data_count, waitMs, macroOper)
int _Inport(unsigned int Port, void * buff, unsigned int data_count, unsigned int waitMs, MacroOper macroOper)
{
	int param[] = { (int)Port, (int)buff, (int)data_count, (int)waitMs };
	return macroOper("Inport", param, &g_Errno);
}


#define OpenSocket(dstIp, dstPort, flag) _OpenSocket(dstIp, dstPort, flag, macroOper)
int _OpenSocket(const char* dstIp, unsigned int dstPort, unsigned int flag, MacroOper macroOper)
{
int param[]={(int)dstIp, (int)dstPort, (int)flag};
return macroOper("OpenSocket",param,&g_Errno);
}


#define Listen_TCP(dstPort) _OpenSocket("TCP", dstPort, 0x3, macroOper)

#define Listen_UDP(dstPort) _OpenSocket("UDP", dstPort, 2, macroOper)


#define AcceptSocket(listenRet) _AcceptSocket(listenRet, macroOper)
int _AcceptSocket(int listenRet, MacroOper macroOper)
{
int param[]={(int) listenRet };
return macroOper("AcceptSocket",param,&g_Errno);
}

#define SendSocket(sockNo, buff, data_count) _SendSocket(sockNo, buff, data_count, macroOper)
int _SendSocket(int sockNo, void * buff, unsigned int data_count, MacroOper macroOper)
{
int param[]={(int)sockNo, (int)buff, (int)data_count};
return macroOper("SendSocket",param,&g_Errno);
}
#define RecvSocket(sockNo, buff, data_count, waitMs) _RecvSocket(sockNo, buff, data_count, waitMs, macroOper)
int _RecvSocket(int sockNo, void * buff, unsigned int data_count, unsigned int waitMs, MacroOper macroOper)
{
int param[]={(int)sockNo, (int)buff, (int)data_count, (int)waitMs};
return macroOper("RecvSocket",param,&g_Errno);
}
#define CloseSocket(sockNo) _CloseSocket(sockNo, macroOper)
int _CloseSocket(int sockNo, MacroOper macroOper)
{
int param[]={(int)sockNo};
return macroOper("CloseSocket",param,&g_Errno);
}

#define SetComParam(Port, baudRate, dataBits, stopBits, parity, workMode) _SetComParam(Port, baudRate, dataBits, stopBits, parity, workMode, macroOper)
int _SetComParam(unsigned int Port, int baudRate, int dataBits, int stopBits, int parity, int workMode, MacroOper macroOper)
{
	int param[] = { (int)Port, (int)baudRate, (int)dataBits, (int)stopBits, (int)parity, (int)workMode };
	return macroOper("SetComParam", param, &g_Errno);
}

#define Debug(Port, format, arg...) do{char debugBuf[4096] = {0};\
									sprintf(debugBuf, format, ##arg);\
									_Debug(Port, debugBuf, strlen(debugBuf), macroOper);}while(0)
int _Debug(unsigned int Port, void * buff, unsigned int data_count, MacroOper macroOper)
{
	int param[] = { (int)Port, (int)buff, (int)data_count };
	return macroOper("Debug", param, &g_Errno);
}

#define SqlCmdEx(dbFile, cmd)  _SqlCmdEx(dbFile, cmd, macroOper)
int _SqlCmdEx(char* dbFile, const char* cmd, MacroOper macroOper)
{
	int param[] = { (int)dbFile, (int)cmd };
	macroOper("SqlCmdEx", param, &g_Errno);
	return g_Errno;
}

#define SqlSelectEx(dbFile, cmd, pRet, nRow, nCol)  _SqlSelectEx(dbFile, cmd, &pRet, &nRow, &nCol, macroOper)
int _SqlSelectEx(char* dbFile, const char* cmd, char ***pResult, int *nRow, int *nCol, MacroOper macroOper)
{
	int param[] = { (int)dbFile, (int)cmd, (int)pResult, (int)nRow, (int)nCol };
	macroOper("SqlSelectEx", param, &g_Errno);
	return g_Errno;
}
#define SqlCmd(dataNo, cmd)  _SqlCmd(dataNo, cmd, macroOper)
int _SqlCmd(int dataNo, const char* cmd, MacroOper macroOper)
{
	int param[] = { (int)dataNo, (int)cmd };
	macroOper("SqlCmd", param, &g_Errno);
	return g_Errno;
}

#define SqlSelect(dataNo, cmd, pRet, nRow, nCol)  _SqlSelect(dataNo, cmd, &pRet, &nRow, &nCol, macroOper)
int _SqlSelect(int dataNo, const char* cmd, char ***pResult, int *nRow, int *nCol, MacroOper macroOper)
{
	int param[] = { (int)dataNo, (int)cmd, (int)pResult, (int)nRow, (int)nCol };
	macroOper("SqlSelect", param, &g_Errno);
	return g_Errno;
}

#define SqlFree(pRet)  _SqlFree((const char**)pRet, macroOper)
int _SqlFree(const char** pRet, MacroOper macroOper)
{
	int param[] = { (int)pRet };
	macroOper("SqlFree", param, &g_Errno);
	return g_Errno;
}

#define Utf16Strlen(utf16Str)  _Utf16Strlen(utf16Str, macroOper)
int _Utf16Strlen(const unsigned short * utf16Str, MacroOper macroOper)
{
	int param[] = { (int)utf16Str };
	return macroOper("Utf16Strlen", param, &g_Errno);
}

#define Utf8Str2Utf16Str(srcUtf8Str, dstUtf16Str)  _Utf8Str2Utf16Str(srcUtf8Str, dstUtf16Str, macroOper)
int _Utf8Str2Utf16Str(const char* srcUtf8Str, unsigned short * dstUtf16Str, MacroOper macroOper)
{
	int param[] = { (int)srcUtf8Str, (int)dstUtf16Str };
	return macroOper("Utf8-Utf16", param, &g_Errno);
}

#define Utf16Str2Utf8Str(srcUtf16Str, dstUtf8Str)  _Utf16Str2Utf8Str(srcUtf16Str, dstUtf8Str, macroOper)
int _Utf16Str2Utf8Str(const unsigned short * srcUtf16Str, char* dstUtf8Str, MacroOper macroOper)
{
	int param[] = { (int)srcUtf16Str, (int)dstUtf8Str };
	return macroOper("Utf16-Utf8", param, &g_Errno);
}

#define Utf16Str2GbStr(srcUtf16Str, dstGb2312Str)  _Utf16Str2GbStr(srcUtf16Str, dstGb2312Str, macroOper)
int _Utf16Str2GbStr(const unsigned short * srcUtf16Str, char* dstGb2312Str, MacroOper macroOper)
{
	int param[] = { (int)srcUtf16Str, (int)dstGb2312Str };
	return macroOper("Utf16-Gb", param, &g_Errno);
}

#define GbStr2Utf16Str(srcGb2312Str, dstUtf16Str)  _GbStr2Utf16Str(srcGb2312Str, dstUtf16Str, macroOper)
int _GbStr2Utf16Str(const char* srcGb2312Str, unsigned short * dstUtf16Str, MacroOper macroOper)
{
	int param[] = { (int)srcGb2312Str, (int)dstUtf16Str };
	return macroOper("Gb-Utf16", param, &g_Errno);
}

unsigned short CRC16(unsigned char *Data, unsigned int len)
{
	unsigned short crc = 0xFFFF;
	unsigned char j, Tmp = 0;
	unsigned int i;
	unsigned int nLength = len;
	unsigned char buf[8] = { 0 };
	for (i = 0; i<nLength; i++)
	{
		crc ^= Data[i];
		for (j = 0; j<8; j++)
		{
			Tmp = crc & 0x0001;
			crc = crc >> 1;
			if (Tmp)crc = (crc ^ 0xA001);
		}
	}
	return crc;
}

typedef struct
{
	short angle1;
	short angle2;
}FArc;

typedef struct
{
	short x;
	short y;
}FPoint;

typedef struct
{
	short x1;
	short y1;
	short x2;
	short y2;
}FRect;

typedef struct
{
	unsigned short flag;		//bit0~7(����)-(0-������,1-ʵ��,2-����,...)
	unsigned short width;		//���
	unsigned int 	color;
}FPen;

typedef struct
{
	unsigned int flag;		//bit0~3(������)-(0-�����,1-ͼ�����,2-�������,3-�Զ���ͼ��)
						//bit8~15(������)-(0-������,1-��ˢ��ɫ���,...)
	unsigned int colors[2];
}FBrush;

#define HmiColorBits  _HmiColorBits(macroOper)
int _HmiColorBits(MacroOper macroOper)
{
	int inf[16] = { 0 };
	int param[] = { (int)inf };
	macroOper("LoadSysInfo", param, &g_Errno);
	return inf[2];
}

#define FRgb(r, g, b) _FRgb(r, g, b, macroOper)
unsigned int _FRgb(unsigned char r, unsigned char g, unsigned char b, MacroOper macroOper)
{
	int inf[16] = { 0 };
	int param[] = { (int)inf };
	macroOper("LoadSysInfo", param, &g_Errno);
	unsigned int ret = 0;
	if (inf[3] == 16)
	{
		if (inf[0] & 0x1)
		{
			ret = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r >> 3) & 0x1f);
		}
		else
		{
			ret = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b >> 3) & 0x1f);
		}
	}
	else
	{
		if (inf[0] & 0x1)
		{
			ret = (b << 16) | (g << 8) | r;
		}
		else
		{
			ret = (r << 16) | (g << 8) | b;
		}
	}
	return ret;
}

#define CreateCanvas(w, h)  _CreateCanvas(w, h, macroOper)
int _CreateCanvas(int w, int h, MacroOper macroOper)
{
	int param[] = { (int)w, (int)h };
	return macroOper("CreateCanvas", param, &g_Errno);
}

#define FreeCanvas(canvasNo)  _FreeCanvas(canvasNo, macroOper)
int _FreeCanvas(int canvasNo, MacroOper macroOper)
{
	int param[] = { (int)canvasNo };
	return macroOper("FreeCanvas", param, &g_Errno);
}

#define DrawLines(pts, n, pen, canvasNo)  _DrawLines(pts, n, &pen, canvasNo, macroOper)
int _DrawLines(const FPoint pts[], int n, const FPen *pPen, int canvasNo, MacroOper macroOper)
{
	int param[] = { (int)pts, (int)n, (int)pPen, (int)canvasNo };
	return macroOper("DrawLine", param, &g_Errno);
}

#define DrawPolygon(pts, n, brush, canvasNo)  _DrawPolygon(pts, n, &brush, canvasNo, macroOper)
int _DrawPolygon(const FPoint pts[], int n, const FBrush*pBrush, int canvasNo, MacroOper macroOper)
{
	int param[] = { (int)pts, (int)n, (int)pBrush, (int)canvasNo };
	return macroOper("DrawPolygon", param, &g_Errno);
}

#define LoadArcPt(rt, arc, pts, ccw)  _LoadArcPt(&rt, &arc, pts, ccw, macroOper)
int _LoadArcPt(const FRect *rt, const FArc *arc, FPoint pts[], int ccw, MacroOper macroOper)
{
	int param[] = { (int)rt, (int)arc, (int)pts, (int)ccw };
	return macroOper("LoadArcPt", param, &g_Errno);
}

#define DrawCycle(rt, pPen, pBrush, canvasNo)  _DrawCycle(&rt, pPen, pBrush, canvasNo, macroOper)
int _DrawCycle(const FRect *rt, const FPen *pPen, const FBrush*pBrush, int canvasNo, MacroOper macroOper)
{
	int ret = FALSE;
	FPoint pts[8192];
	FArc arc = {0, 360};
	int n = LoadArcPt(*rt, arc, pts, 0);
	if (pBrush)
	{
		ret = DrawPolygon(pts, n, *pBrush, canvasNo);
	}
	if (pPen)
	{
		pts[n] = pts[0];
		++n;
		ret = DrawLines(pts, n, *pPen, canvasNo);
	}
	return ret;
}

#define RenderCanvas(canvasNo, winNo, x, y)  _RenderCanvas(canvasNo, winNo, x, y, macroOper)
int _RenderCanvas(int canvasNo, int winNo, int x, int y, MacroOper macroOper)
{
	int param[] = { (int)canvasNo, (int)winNo, (int)x, (int)y };
	return macroOper("Render", param, &g_Errno);
}

//scale-扇环内外径比例，范围0~99，0表示扇形
#define DrawPie(rt, arc, scale, pPen, pBrush, canvasNo)  _DrawPie(&rt, &arc, scale, pPen, pBrush, canvasNo, macroOper)
int _DrawPie(const FRect *rt, const FArc *arc, int scale, const FPen *pPen, const FBrush*pBrush, int canvasNo, MacroOper macroOper)
{
int param[] = { (int)rt, (int)arc, (int)scale, (int)pPen, (int)pBrush, (int)canvasNo };
return macroOper("DrawPie", param, &g_Errno);
}

#define DrawArc(rt, arc, pen, canvasNo)  _DrawArc(&rt, &arc, &pen, canvasNo, macroOper)
int _DrawArc(const FRect *rt, const FArc *arc, const FPen *pPen, int canvasNo, MacroOper macroOper)
{
FPoint pts[8192];
int n = LoadArcPt(*rt, *arc, pts, 0);
return DrawLines(pts, n, *pPen, canvasNo);
}

#define SetCanParam(baudRate, workMode) _SetCanParam(baudRate, workMode)
int _SetCanParam(int baudRate, unsigned int workMode)
{
	char ch[100];
	if(workMode>0)	
	{
		sprintf(ch,"/bin/cantools/ip link set can0 type can bitrate %d triple-sampling on",baudRate);
		system(ch);
		system("/bin/cantools/ip link set can0 up ");
		system("/bin/cantools/candump2 can0 ");
		// printf("setcan \n");
	}
	else
	{
		system("/bin/cantools/ip link set can0 down ");
	}
	return 0;
}

void Uint8_to_HexString(char InputData, char *OutputString)
{
	char TmpData = 0;

	TmpData = InputData / 16;
	if(TmpData < 10)
		OutputString[0] = '0' + TmpData;
	else if(TmpData < 16)
		OutputString[0] = 'A' + (TmpData - 10);

	TmpData = InputData % 16;
	if(TmpData < 10)
		OutputString[1] = '0' + TmpData;
	else if(TmpData < 16)
		OutputString[1] = 'A' + (TmpData - 10);

	return;
}

#define CanSend(id,buff,data_count,flag) _CanSend(id, buff,data_count,flag)
int _CanSend(unsigned int id, char * buff, unsigned int data_count, unsigned int flag)
{
	int i;
	char str[100];
	char ch[50];
	char ptr=0; 
	
	memset(str,0,100);
	if(flag>0)
	{
		sprintf(str,"/bin/cantools/cansend2 can0 %08x#",id);	
	}
	else
	{
		sprintf(str,"/bin/cantools/cansend2 can0 %03x#",id);
	
	}
	printf("cansend can0 %s \n",str);
	for(i=0;i<data_count;i++) Uint8_to_HexString(buff[i],ch+i*2);
	while(str[ptr]!='#')
	{
		ptr++;	 
	}
	memcpy(str+ptr+1,ch,data_count*2);
	system(str);
	return 0;
}

#define CanDump(id,buff,flag) _CanDump(id, buff,flag)
unsigned int _CanDump(unsigned int id, char * buff,unsigned int flag)
{
	FILE *file;	
	unsigned char err=0;
	typedef struct
	{
	 unsigned short Data_Flag;//是否有数据
	 unsigned short	 can_dlc; /* data length code: 0 .. 8 */
	 unsigned int  can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
	 unsigned char 	 data[8];
	}Can_Struct_Tmp_File;
	Can_Struct_Tmp_File can_struct_tmp;
	can_struct_tmp.can_id=id;
	if(flag==0)
	{
		file=fopen( "/tmp/can0_tmp.data","rb+");
		if(file==NULL)
		{
			file=fopen( "/tmp/can0_tmp.data","wb+");
			if(file==NULL) return 0;
		}
	 fseek(file,sizeof(Can_Struct_Tmp_File)*can_struct_tmp.can_id,SEEK_SET);
	 fread(&can_struct_tmp,1,sizeof(Can_Struct_Tmp_File),file);
	 if(1==can_struct_tmp.Data_Flag)
	 {
		memcpy(buff,can_struct_tmp.data,8);
		can_struct_tmp.Data_Flag=0;
		fseek(file,sizeof(Can_Struct_Tmp_File)*can_struct_tmp.can_id,SEEK_SET);
		fwrite(&can_struct_tmp,1,sizeof(Can_Struct_Tmp_File),file);
		fclose(file);
		return can_struct_tmp.can_dlc;
	 }
	 fclose(file);
	 return 0;
	}
	else
	{
		file=fopen( "/tmp/can0_tmp_kz.data","rb+");
		if(file==NULL)
		{
			file=fopen( "/tmp/can0_tmp.data_kz","wb+");
			if(file==NULL) return 0;
		}
		
		unsigned int i=0;
		fseek(file,0,SEEK_END);
		int size=ftell(file);
		while(i*16<size)
		{
			fseek(file,sizeof(Can_Struct_Tmp_File)*i,SEEK_SET);
			fread(&can_struct_tmp,sizeof(Can_Struct_Tmp_File),1,file);
			if(can_struct_tmp.can_id==id)
			{
				if(1==can_struct_tmp.Data_Flag)
				{
					memcpy(buff,can_struct_tmp.data,8);
					can_struct_tmp.Data_Flag=0;
					fseek(file,sizeof(Can_Struct_Tmp_File)*i,SEEK_SET);
					fwrite(&can_struct_tmp,1,sizeof(Can_Struct_Tmp_File),file);
					fclose(file);
					return can_struct_tmp.can_dlc;
				 }
			}
			i++;
		}
		fclose(file);
		return 0;
	}
}

#ifdef CTL_CODE
#undef CTL_CODE
#endif
#define CTL_CODE(function, method) ( (4<< 16) | ((function) << 2) | (method) )
#define IOCTL_FE_MISC_Beep                 CTL_CODE(4,0)
#define BeepOut(times,beep_delay) _BeepOut(times,beep_delay)
int _BeepOut(unsigned int times,unsigned int beep_delay)
{
	int fd;
	struct timeval timeout;
    struct  {
		int times;
    int beep_delay;
    }beepioctl;
 
    if( (fd=open("/dev/femisc",O_RDWR)) == -1)
    {
    	printf("failed to open file /dev/femisc\r\n");
    	return -1;
    }
	if((times>100)||(beep_delay<20)||(beep_delay>5000))
	{
		close(fd);
		return 0;
	}

	beepioctl.times=times;
	beepioctl.beep_delay=beep_delay;
  
#ifndef WIN32
    ioctl(fd, IOCTL_FE_MISC_Beep, &beepioctl);
#endif
  
	close(fd);	
	return 1;
}