/bin 二进制可执行命令
/dev 设备特殊文件
/etc 系统管理和配置文件
/etc/rc.d 启动的配置文件和脚本
/home 用户主目录的基点，比如用户user的主目录就是/home/user，可以用~user表示
/lib 标准程序设计库，又叫动态链接共享库，作用类似windows里的.dll文件
/sbin 系统管理命令，这里存放的是系统管理员使用的管理程序
/tmp 公用的临时文件存储点
/root 系统管理员的主目录
/mnt 系统提供这个目录是让用户临时挂载其他的文件系统。
/lost+found 这个目录平时是空的，系统非正常关机而留下“无家可归”的文件（windows下叫什么.chk）就在这里
/proc 虚拟的目录，是系统内存的映射。可直接访问这个目录来获取系统信息。

/opt 存放可选程序的目录，比如我想安装firefox的最新beta版，可以放在这里。卸载的话删除那个文件夹好了
/var 某些大文件的溢出区，比方说各种服务的日志文件
/usr 最庞大的目录，要用到的应用程序和文件几乎都在这个目录。其中包含：
/usr/x11r6 存放x window的目录
/usr/bin 众多的应用程序
/usr/sbin 超级用户的一些管理程序
/usr/doc linux文档
/usr/include linux下开发和编译应用程序所需要的头文件
/usr/lib 常用的动态链接库和软件包的配置文件
/usr/man 帮助文档
/usr/src 源代码，linux内核的源代码就放在/usr/src/linux里
/usr/local/bin 本地增加的命令
/usr/local/lib 本地增加的库

#include <stdio.h>

#define M 4     //事件个数
#define N 3     //状态个数

#define S1 0    //状态1  没有结束符
#define S2 1    //状态2  有3了
#define S3 2    //状态3	 文件结束

#define EVENT_3          0   //事件1  出现数字3
#define EVENT_5          1   //事件2  出现数字5
#define EVENT_NOT3       2   //事件3  不是数字3
#define EVENT_NOT3NOT5   3   //事件4  不是数字3或者5

int save(char num);												// 存入缓存
int logerror(char num);													// 没有响应事件的行为
int getEvent(int event, char cc, int currentState);			// 获取事件

// 定义一个矩阵表类型
typedef struct matrix{
    int (*Action)(char num);
    int nextState;
} matrix_t;

// 矩阵表
matrix_t Set[M][N] = {
    {{save, S2}, {save, S2}},
    {{logerror, S1}, {save, S3}},
    {{save, S1}, {logerror, S2}},
    {{logerror, S1}, {save, S1}},
};

int save(char num){
    printf("here is save num : %c!\n", num);
    return 0;
}

int logerror(char num){
    printf("logerror\n");
}

int getEvent(int event, char cc, int currentState){
    if (cc == '3')
		event = EVENT_3;
	else if (cc == '5')
		event = EVENT_5;
	else if (cc != '3' && currentState == S1)
		event = EVENT_NOT3;
	else if (cc != '3' && cc != '5' && currentState == S2)
		event = EVENT_NOT3NOT5;
	return event;
}

int main(int argc, char *argv[]){
    int currentState = 0;
    int EVENT = -1;
	  char cc = '3';
    int i = 5;

    while (i--){
		    cc = '3';
        EVENT = getEvent(EVENT, cc, currentState);
        printf("Now state is %d, event is %d, ", currentState+1, EVENT+1);
        Set[EVENT][currentState].Action(cc);
        currentState=Set[EVENT][currentState].nextState;

		    cc = '5';
        EVENT = getEvent(EVENT, cc, currentState);
        printf("Now state is %d, event is %d, ", currentState+1, EVENT+1);
        Set[EVENT][currentState].Action(cc);
        currentState=Set[EVENT][currentState].nextState;

        if (currentState == S3){
          printf("File received!");
          break;
        }
    }
}

#define MAVLINK_MAX_PACKET_LEN	 // 帧总长 = 载荷字节 + 非载荷字节
	(MAVLINK_MAX_PAYLOAD_LEN + MAVLINK_NUM_NON_PAYLOAD_BYTES)
#define  MAVLINK_NUM_NON_PAYLOAD_BYTES 　// 非载荷字节
	 (MAVLINK_NUM_HEADER_BYTES　+　MAVLINK_NUM_CHECKSUM_BYTES )
#define  MAVLINK_NUM_HEADER_BYTES 　// 非载荷字节 – 首部
	 (1 +  MAVLINK_CORE_HEADER_LEN)

#define  MAVLINK_CORE_HEADER_LEN  		5
#define  MAVLINK_NUM_CHECKSUM_BYTES 	2
#define  MAVLINK_MAX_PAYLOAD_LEN		255


typedef struct __mavlink_message {
  uint16_t	checksum;	    ///< sent at end of packet	 (最后发送)
  uint8_t	magic;   		///< protocol magic marker	标记 (发送时第一字节)
  uint8_t	len;     		///< Length of payload  载荷长度
  uint8_t	seq;     		///< Sequence of packet  数据包的顺序
  uint8_t	sysid;   		///< ID of message sender system/aircraft  消息发送方系统/飞机的ID
  uint8_t	compid;  		///< ID of the message sender component 消息发送方组件的ID
  uint8_t	msgid;   		///< ID of message in payload 载荷中消息的ID
  uint64_t	payload64[(MAVLINK_MAX_PAYLOAD_LEN + 9) / 8];  // 载荷，8字节为单位
} mavlink_message_t

typedef struct __mavlink_heartbeat_t {
    uint32_t 	custom_mode;	/*  标志位  */ 
    uint8_t 	type; 			/*  飞行器类型  */ 
    uint8_t 	autopilot; 		/* 自动驾驶类别  */ 
    uint8_t 	base_mode		/* 飞行器模式位图 */
    uint8_t 	system_status; 	/* 飞行器状态 */
    uint8_t 	mavlink_version;/* 版本 */
}  mavlink_heartbeat_t

// lflserial.c

//接收串口数据
//串口接收,返回接收数
int serRev(int fd,char *buff,int len)
{
	if (fd>0)
	{
		return(read(fd,buff,len));
	}else
	{
		return(0);
	}
}

//串口发送数据
//串口发送,返回发送数
int serSend(int fd,char *buff,int len)
{
	if (fd>0)
	{
		return(write(fd,buff,len));
	}else
	{
		return(0);
	}
}

// 对外接口 Dev为设备
//打开COM：DEV：设备名,Speed：速度,DataBits：位数,StopBits：停止位,Parity：校验位
//例:"dev/ttyS1",115200,8,1,'N'
int serOpenCOM(char *DEV,int Speed,int DataBits,int StopBits,int Parity)
{
	int fd;
	fd = serOpenDev(DEV);

	if (fd>0) {
		if (serSetSpeed(fd,Speed)) {
			if (serSetParity(fd,DataBits,StopBits,Parity))
				return(fd);
			return(0);
		} else
			return(0);
	} else
		return(0);
}

// 关闭串口
int serCloseCOM(int fd)
{
	return(serCloseDev(fd));
}

// tty_send_file.c

while (1) {
    s_len = read(fd, buff, 1024);
    if (s_len <= 0) break;
    serSend(tty_fd, buff, s_len);						//串口接收,返回接收数
}

// tty_recv_file.c

char r_buffer[1024];
bzero(r_buffer, sizeof r_buffer);
while (1) { // 循环读取数据
    r_len = serRev(r_fd, r_buffer, sizeof r_buffer); // 串口接收,返回接收数
    write(rd, r_buffer, r_len);
}

// test-packet-struct-sizeof.c

#include <stdio.h>

// ★
typedef  unsigned char   u_int8_t;	// 8位
typedef  unsigned short  u_short; 	// 16位
typedef  unsigned int   u_int32_t; // 32位
// ★
struct ip_addr {
	u_int32_t 	IP_addr; //IP地址，占32位
};
// ★
struct in6_addr {
	union {
		u_int8_t 	Byte[16];
		u_short 	Word[8];
	} u;				// 只要是128位都是对的
};

struct packet_t {
	u_int8_t			Ver:4; 
	u_int8_t			Com:4;
	u_int8_t			ComArg;
	u_short			PacketDataLength;
	struct ip_addr		IPv4Address;
//	u_int8_t			PacketData[1];					// 不定义或定义为1个字节算对
};

typedef struct _PacketHdr_t
{
u_int32_t			Ver:4; 
u_int32_t			Class:8; 
u_int32_t			FlowLabel:20; 
u_short			PayloadLength; 
u_short			Reverse; 
struct in6_addr	IPv6Address; 
} PacketHdr_t;



struct ip_hdr
{
	unsigned short int	IP_v:4; 	// 版本号码
	unsigned short int	IP_hl:4; 	// 首部长度
	u_int8_t		IP_tos; 	// 服务类型
	u_short		IP_len; 	// 数据报文总长度
	u_short		IP_id;		// 标识
	u_short 		IP_off; 	// 分段偏移
	u_int8_t		IP_ttl; 		// 存活时间
	u_int8_t		IP_p; 		// 协议号码
	u_short		IP_sum; 	// 检验和
	struct ip_addr	IP_src,	IP_dst;	
		// 源IP地址和目的IP地址
};

struct ip_hdr_c
{
	u_int8_t	IP_v:4; 	// 版本号码
	u_int8_t	IP_hl:4; 	// 首部长度
	u_int8_t		IP_tos; 	// 服务类型
	u_short		IP_len; 	// 数据报文总长度
	u_short		IP_id;		// 标识
	u_short 		IP_off; 	// 分段偏移
	u_int8_t		IP_ttl; 		// 存活时间
	u_int8_t		IP_p; 		// 协议号码
	u_short		IP_sum; 	// 检验和
	struct ip_addr	IP_src,	IP_dst;	
		// 源IP地址和目的IP地址
};

struct ip_hdr_l
{
	unsigned long	IP_v:4; 	// 版本号码
	unsigned long	IP_hl:4; 	// 首部长度
	u_int8_t		IP_tos; 	// 服务类型
	u_short		IP_len; 	// 数据报文总长度
	u_short		IP_id;		// 标识
	u_short 		IP_off; 	// 分段偏移
	u_int8_t		IP_ttl; 		// 存活时间
	u_int8_t		IP_p; 		// 协议号码
	u_short		IP_sum; 	// 检验和
	struct ip_addr	IP_src,	IP_dst;	
		// 源IP地址和目的IP地址
};

main()
{
	PacketHdr_t Packet6;
	struct packet_t Packet4;
	struct ip_hdr IP_Head;
	struct ip_hdr_c IP_Head_c;
	struct ip_hdr_l IP_Head_l;

	printf("\n");
	printf("\nsizeof  struct ip_addr = %d\n", sizeof (struct ip_addr));  // 24
	printf("\nsizeof  PacketHdr_t = %d\n", sizeof Packet6);  // 24
	printf("\nsizeof  packet_t = %d\n", sizeof Packet4);  // 8
	printf("\nsizeof  IP_Head_t = %d\n", sizeof IP_Head);  // 20
	printf("\nsizeof  IP_Head_t_c = %d\n", sizeof IP_Head_c);  // 20
	printf("\nsizeof  IP_Head_t_l = %d\n", sizeof IP_Head_l);  // 20
}

// 帧首类型
typedef  struct  frame_head {
	char     cFlag[2]; // 头标识 + 长度 = 帧头
	short    shortLength;
} t_frame_head;

// 帧类型
typedef  struct  frame {
	t_frame_head frameHead;
	char   			 frameData[0]; // 数据
} t_frame;

#define MAX_DATA_LENGTH   1500 // 需要发送的数据总长
// 帧总长 = 帧头 + 数据长度
#define MAX_FRAME_LENGTH (sizeof (t_frame_head *) + MAX_DATA_LENGTH)

void length_framePack(t_frame *framePoint, char *dataP, int dataLength);
void length_frameUnpack(t_frame *framePoint, char *dataP, int *data_lengthP);
void length_frameRecognition(int fd, t_frame *framePoint);

// length-frame-send-file.c
while (1) {
    s_len = read(fd, buff, N);
    if (s_len <= 0) break;
    length_framePack((t_frame *)&frame[0], buff, s_len);
    serSend(tty_fd, frame, s_len + sizeof (t_frame_head));
}

// length-frame-recv-file.c
while (1) {
    length_frameRecognition(tty_fd, (t_frame *)&frame[0]);
    length_frameUnpack((t_frame *)&frame[0], buff, &s_len);  // 帧指针赋值
    if (s_len <= 0) break;
    write(fd, buff, s_len);
}

// length-frame-recognition.c

// 帧的识别
void length_frameRecognition(int fd, t_frame *framePoint)
{
	char cc[2], tc;
	short len;

again:
	cc[0] = 0;	cc[1] = 0;
	while (cc[0] != 0x7e || cc[1] != 0x7e)
		readFromUART(fd, &cc[0], 2);
	readFromUART(fd, (char *)&len, 2);
	
	if (len > MAX_DATA_LENGTH)
		goto again;
	// 阻塞式读取len长度的字节
	readFromUART(fd, framePoint->frameData, len); // 读len字节
	// 帧封装
	framePoint->frameHead.cFlag[0] = 0x7e;
	framePoint->frameHead.cFlag[1] = 0x7e;	// 这两句意义不大了
	framePoint->frameHead.shortLength = len;
}

// length-frame-recognition.c

// 帧封装（发）
void length_framePack(t_frame *framePoint, char *dataP, int dataLength)
{
	framePoint->frameHead.cFlag[0] = 0x7e;
	framePoint->frameHead.cFlag[1] = 0x7e;
	framePoint->frameHead.shortLength = dataLength;
	memcpy(framePoint->frameData, dataP, dataLength);
}

// 帧解封（收）
void length_frameUnpack(t_frame *framePoint, char *dataP, int *data_lengthP)
{
	register int l;
	l = framePoint->frameHead.shortLength;
	memcpy(dataP, framePoint->frameData, l);
	*data_lengthP = l;
}