添加esp8266 tcp

TEST_Prj/esp8266tcp/tcp/tcp.ino

@@ -0,0 +1,1184 @@
+#include <ESP8266WiFi.h>
+#include "string.h"
+#include <string.h>
+#include <stdio.h>
+
+#include <SoftwareSerial.h>
+//串口缓存区改C:\Users\liuhao\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.7.4\cores\esp8266\HardwareSerial.cpp
+#ifndef D5
+#if defined(ESP8266)
+#define D5 (14)
+#define D6 (12)
+#define D7 (13)
+#define D8 (15)
+#define TX (1)
+#elif defined(ESP32)
+#define D5 (18)
+#define D6 (19)
+#define D7 (23)
+#define D8 (5)
+#define TX (1)
+#endif
+#endif
+
+#ifdef ESP32
+#define BAUD_RATE 9600
+#else
+#define BAUD_RATE 9600
+#endif
+
+// Reminder: the buffer size optimizations here, in particular the isrBufSize that only accommodates
+// a single 8N1 word, are on the basis that any char written to the loopback SoftwareSerial adapter gets read
+// before another write is performed. Block writes with a size greater than 1 would usually fail. 
+SoftwareSerial swSer;
+
+//定义可连接的客户端数目最大值
+#define MAX_SRV_CLIENTS 3
+
+#define Serial_RX_MAXSIZE  256
+#define TCP_RX_MAXSIZE     256
+
+const char* ssid = "ESP8266";
+const char* password = "12345678";
+
+WiFiServer server(60000);
+WiFiClient serverClients[MAX_SRV_CLIENTS];
+
+unsigned char Serial_Buffer[Serial_RX_MAXSIZE]={0};
+
+uint32_t timeTick = 0;
+unsigned int  buffUartIndex = 0;
+unsigned long preUartTick = 0;
+int LED_PIN=2;//GPIO2--D0 模块自带的led
+int connectedCnt=0;
+String Rxstr="";
+char getflag=0;
+char SendBuff[20]={0};
+int openCnt=0;
+int volt=0;
+
+/*****************使用摄像头发送宏开关*************************/
+#ifndef USING_CAMERA_FOR_MMS
+#define  USING_CAMERA_FOR_MMS    1
+#endif
+
+/******************使用SD卡存储图片宏开关*************************/
+#ifndef USING_SAVE_SD
+#define USING_SAVE_SD              0
+#endif
+
+
+
+
+typedef unsigned char u8;
+typedef unsigned short int u16;
+typedef unsigned int u32;
+
+#define  USART1_RECEIVE_BUFSIZE     100
+#define  USART1_MAX_SIZE            96
+
+#define  USART2_RECEIVE_BUFSIZE     2048
+#define  USART2_MAX_SIZE            4996
+
+#define  second   1000000
+
+#define  L_TIME  (1*second)
+#define  Z_TIME  (10*second)
+#define  HH_TIME (90*second)
+#define  H_TIME  (30*second) //设置串口接收的等待时间
+
+
+//硬件引脚定义
+#define  camer_pwerH()    GPIO_SetBits(GPIOA,GPIO_Pin_1)
+#define  camer_pwerL()    GPIO_ResetBits(GPIOA,GPIO_Pin_1)
+
+//用户自定义宏变量
+//#define N_BYTE  512        //每次读取N_BYTE字节，N_BYTE必须是8的倍数
+
+#define N_BYTE  1024        //每次读取N_BYTE字节，N_BYTE必须是8的倍数
+
+//#define N_BYTE  224        //每次读取N_BYTE字节，N_BYTE必须是8的倍数/
+#define IMAGE_SIZE_160X120     0x22
+#define IMAGE_SIZE_320X240     0x11
+#define IMAGE_SIZE_640X480     0x00
+
+
+#define COMPRESS_RATE_36       0x36   //该压缩率是默认压缩率，160x120和320x240可用此压缩率
+
+#define COMPRESS_RATE_60       0x60   //640X480尺寸，默认压缩率36会占用45K左右的空间
+                                      //选择60压缩率可将45K压缩到20K左右
+
+
+
+typedef enum
+{
+    SERIAL_NUM_0 = 0x00,
+    SERIAL_NUM_1,
+    SERIAL_NUM_2,
+    SERIAL_NUM_3,
+    SERIAL_NUM_5,
+    SERIAL_NUM_6,
+    SERIAL_NUM_7,
+    SERIAL_NUM_8,
+    SERIAL_NUM_9,
+    SERIAL_NUM_10
+}nSerialNum;
+//extern const nSerialNum SerialNum_Byte;
+//
+//extern u8 g_SerialNumber;
+//extern volatile u8 cameraReady;
+//extern u32 picLen;//图片长度
+
+//串口驱动接口函数，移植时需要修改接口函数
+void cam_write(const u8 *buf,u8 len);
+u16 cam_receiver( u8 *buf,u16 send_len);
+
+void server_sendByte(u8 *data,u32 len);
+// 应用实例函数
+u8 CameraDemoApp(u8 Serialnumber,u8 nCameraImageSize);
+
+u8 camera_init(u8 Serialnumber,u8 nSetImageSize);
+u8 send_cmd(const u8 *cmd,u8 n0,const u8 *rev,u8 n1);
+void SetSerailNumber(u8 *DstCmd, const u8 *SrcCmd, u8 SrcCmdLength,
+                     u8 *DstRcv, const u8 *SrcRcv, u8 SrcRcvLength,u8 nID);
+
+//摄像头属性设置：复位/图片尺寸大小/图片压缩率
+u8 send_reset(u8 Serialnumber);
+u8 current_photo_size(u8 Serialnumber,u8 * nImageSize);
+u8 send_photo_size(u8 Serialnumber,u8 nImageSize);
+u8 send_compress_rate(u8 Serialnumber,u8 nCompressRate);
+void UART1Write(char *data,u32 len) ;
+//移动侦测控制函数
+u8 send_motion_sensitivity(u8 Serialnumber);
+u8 send_open_motion(u8 Serialnumber);
+u8 send_close_motion(u8 Serialnumber);
+u8 Motion_Detecte_Idle(u8 *pSerialnumber);
+//拍照处理函数
+u8 send_photoBuf_cls(u8 Serialnumber);
+u8 send_start_photo(u8 Serialnumber);
+u32 send_read_len(u8 Serialnumber);
+u8 send_get_photo(u16 add,u16 read_len,u8 *buf,u8 Serialnumber);
+
+
+
+
+#define CLEAR_FRAME            1     //去掉返回图片数据携带的协议头和尾76 00 32 00
+#define ECHO_CMD_DEBUG_INFO    0     //1，开启指令调试；0，关闭
+
+#define ID_SERIAL_NUM       1        //序号在数组的所在位置
+
+//复位指令与复位回复
+const u8 reset_rsp[] = {0x76,0x00,0x26,0x00};
+const u8 reset_cmd[] = {0x56,0x00,0x26,0x00};
+
+
+//清除图片缓存指令与回复
+const u8 photoBufCls_cmd [] = {0x56,0x00,0x36,0x01,0x02};
+const u8 photoBufCls_rsp[] = {0x76,0x00,0x36,0x00,0x00};    
+
+//拍照指令与回复
+const u8 start_photo_cmd[] = {0x56,0x00,0x36,0x01,0x00};    
+const u8 start_photo_rsp[] = {0x76,0x00,0x36,0x00,0x00};   
+
+//读图片长度指令与回复
+//图片长度指令回复的前7个字节是固定的，最后2个字节表示图片的长度
+//如0xA0,0x00,10进制表示是40960,即图片长度(大小)为40K
+const u8 read_len_cmd[] = {0x56,0x00,0x34,0x01,0x00};
+const u8 read_len_rsp[] = {0x76,0x00,0x34,0x00,0x04,0x00,0x00};
+
+//读图片数据指令与回复
+//get_photo_cmd前6个字节是固定的，
+//第9,10字节是图片的起始地址
+//第13,14字节是图片的末尾地址，即本次读取的长度
+
+//如果是一次性读取，第9,10字节的起始地址是0x00,0x00;
+//第13,14字节是图片长度的高字节，图片长度的低字节(如0xA0,0x00)
+
+//如果是分次读取，每次读N字节(N必须是8的倍数)长度，
+//则起始地址最先从0x00,0x00读取N长度(即N & 0xff00, N & 0x00ff)，
+//后几次读的起始地址就是上一次读取数据的末尾地址
+const u8 get_photo_cmd [] = {0x56,0x00,0x32,0x0C,0x00,0x0A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF }; 
+const u8 get_photo_rsp []  = {0x76,0x00,0x32,0x00,0x00};
+
+//设置压缩率指令与回复，最后1个字节为压缩率选项
+//范围是：00 - FF
+//默认压缩率是36
+const u8 set_compress_cmd [] = {0x56,0x00,0x31,0x05,0x01,0x01,0x12,0x04,0x36};
+const u8 compress_rate_rsp [] = {0x76,0x00,0x31,0x00,0x00};
+
+//设置图片尺寸指令与回复
+//set_photo_size_cmd最后1个字节的意义
+//0x22 - 160X120
+//0x11 - 320X240
+//0x00 - 640X480
+const u8 set_photo_size_cmd [] = {0x56,0x00,0x31,0x05,0x04,0x01,0x00,0x19,0x11};
+const u8 set_photo_size_rsp [] = {0x76,0x00,0x31,0x00,0x00 };
+
+//读取图片尺寸指令与回复
+//read_photo_size_rsp最后1个字节的意义
+//0x22 - 160X120
+//0x11 - 320X240
+//0x00 - 640X480
+const u8 read_photo_size_cmd [] = {0x56,0x00,0x30,0x04,0x04,0x01,0x00,0x19};
+const u8 read_photo_size_rsp [] = {0x76,0x00,0x30,0x00,0x01,0x00};
+
+
+
+//移动侦测指令
+//motion_enable_cmd 打开移动侦测
+//motion_disable_cmd 关闭移动侦测
+const u8 motion_enable_cmd [] = {0x56,0x00,0x37,0x01,0x01};
+const u8 motion_disable_cmd [] = {0x56,0x00,0x37,0x01,0x00};
+const u8 motion_rsp [] = {0x76,0x00,0x37,0x00,0x00};
+
+//当系统检测到有移动时，自动从串口输出motio_detecte
+const u8 motion_detecte [] = {0x76,0x00,0x39,0x00,0x00};
+
+//移动侦测灵敏度设置
+const u8 motion_sensitivity_cmd [] = {0x56,0x00,0x31,0x05,0x01,0x01,0x1A,0x6E,0x03};
+const u8 motion_sensitivity_rsp [] = {0x76,0x00,0x31,0x00,0x00};
+volatile u8 cameraReady = 0;
+u32 picLen = 0;   //数据长度
+//CommandPacket和ResponsePacket用于拷贝只读区的指令及应答到内存
+u8 CommandPacket[16];
+u8 ResponsePacket[7];
+//const nSerialNum SerialNum_Byte;//序列号枚举变量
+u8 g_SerialNumber = 0;//串口上报移动侦测时保存的当前序列号
+u8 usa1_buf[USART1_RECEIVE_BUFSIZE] = {0};
+u8 gprs_buf[USART2_RECEIVE_BUFSIZE] = {0};
+void UART3Write(u8 *data,u32 len)   //发送n个字符
+{
+  Serial.write(&data[0],len);
+}
+void UART1Write(char *data,u32 len)   //发送n个字符
+{ 
+    u16 i;
+    if( len == 0) 
+    { 
+        for(i = 0;data[i] != '\0';i++)
+        {
+           swSer.write(data[i]);
+        }
+    }
+
+    else
+    {   
+        for(i = 0;i < len;i++)
+        {
+           swSer.write(data[i]);
+        }
+    }
+
+}
+//等待接收数据 接收到的数据，接收到的个数等待接收的时间
+u16 UART3_Receiver_buf(u8 *data,u32 len,u32 time)  
+{
+  u16 i=0;
+  u32 time0=0;
+  while(1)
+  {
+     if(Serial.available() > 0) {
+     data[i]=Serial.read();
+     time0 = 0;
+     i++;
+     if( i == len && (len != 0) )
+     { 
+                break; 
+     }
+    yield();
+    }else
+    {
+         if( time0 > 10000 )
+                break;
+         else 
+               time0++;
+    }
+  }
+   return i;
+//    u16 i=0;
+//    u32 time0=0;
+//    i = USART_ReceiveData(USART1);
+//    while((USART_GetFlagStatus(USART1,USART_FLAG_RXNE)) == RESET)
+//    {   
+//        delay_us(1);
+//        time0++;
+//        if( time0 > time)
+//        {
+//            return 0;
+//        } 
+//    }
+//    data[0] = USART_ReceiveData(USART1);
+//    i = 1;
+//    time0 = 0;
+//    while(1)
+//    { 
+//        if(USART_GetFlagStatus(USART1,USART_FLAG_RXNE) != RESET)
+//        {
+//            time0 = 0;
+//            data[i] = USART_ReceiveData(USART1);
+//            i++;
+//            if( i == len && (len != 0) )
+//            { 
+//                break; 
+//            }
+//        }
+//        else 
+//        {
+//            if( time0 > 10000 )
+//                break;
+//            else 
+//                time0++;
+//        }
+//    }
+//    return i;
+}
+
+/****************************************************************
+函数名：SetSerailNumber
+函数描述: 修改协议中的序号
+输入参数：目标指令缓存首地址，源指令首地址，源指令长度，
+          目标应答缓存首地址，源应答首地址，源应答长度，需要修改的
+          序号值
+返回:无
+******************************************************************/   
+void SetSerailNumber(u8 *DstCmd, const u8 *SrcCmd, u8 SrcCmdLength,
+                     u8 *DstRsp, const u8 *SrcRsp, u8 SrcRspLength,u8 nID)
+{
+    memset(&CommandPacket,0,sizeof(CommandPacket));
+    memset(&ResponsePacket,0,sizeof(ResponsePacket));
+    
+    memcpy(DstCmd,SrcCmd,SrcCmdLength);
+    memcpy(DstRsp,SrcRsp,SrcRspLength);
+    
+    DstCmd[ID_SERIAL_NUM] = nID & 0xFF;
+    DstRsp[ID_SERIAL_NUM] = nID & 0xFF;
+
+}
+
+/****************************************************************
+函数名：cam_write
+函数描述: 接口函数，写入控制摄像头的串口
+输入参数：数据的首地址，长度
+返回:无
+******************************************************************/   
+void cam_write(const u8 *buf,u8 len)
+{ 
+    
+    //需要调试时开启，观察打印的数据,这里使用串口2调试
+    #if ECHO_CMD_DEBUG_INFO
+    
+    UART1Write("\r\n",0);
+    UART1Write((u8 *)buf,len);
+    UART1Write("\r\n",0);     
+    #endif
+    
+    //写串口驱动函数
+    UART3Write((u8 *)buf,len);
+    
+}
+
+/****************************************************************
+函数名：cam_receiver
+函数描述：接口函数，读取控制摄像头的串口
+输出参数：接收数据的地址，长度
+返回:接收到数据个数
+******************************************************************/   
+u16 cam_receiver(u8 *buf,u16 send_len)
+{ 
+    u16 i = 0;
+    
+    i = UART3_Receiver_buf(buf,send_len,L_TIME);
+    
+    #if ECHO_CMD_DEBUG_INFO
+    
+    UART1Write("\r\n",0);
+    UART1Write(buf,send_len);
+    UART1Write("\r\n",0);
+    
+    #endif
+    return i;
+}
+
+/****************************************************************
+函数名：camera_init
+函数描述：摄像头初始化
+输入参数：序列号，需要设置的图片尺寸
+返回:初始化成功返回1，初始化失败返回0
+******************************************************************/   
+u8 camera_init(u8 Serialnumber,u8 nSetImageSize)
+{    
+    u8 CurrentImageSize = 0xFF;
+    u8 CurrentCompressRate = COMPRESS_RATE_36;
+    
+    //读取当前的图片尺寸到currentImageSize
+    if ( !current_photo_size(Serialnumber,&CurrentImageSize))
+    {
+        UART1Write("\r\nread_photo_size error\r\n",0);
+        return 0;
+    }
+    
+    //判断是否需要修改图片尺寸
+    if(nSetImageSize != CurrentImageSize)
+    {
+        //设置图片尺寸，设置后复位生效，该项设置后会永久保存
+        if ( !send_photo_size(Serialnumber,nSetImageSize))
+        {
+            UART1Write("\r\nset_photo_size error\r\n",0);
+            return 0;
+        }
+        else
+        {
+            //复位生效
+            if ( !send_reset(Serialnumber))
+            {
+                UART1Write("\r\reset error\r\n",0);
+                return 0;
+            }
+            delay(1000);
+            CurrentImageSize = nSetImageSize;
+        }
+        
+    }
+    
+    //给不同图片尺寸设置适当的图片压缩率
+    if(nSetImageSize == CurrentImageSize)
+    {
+        switch(CurrentImageSize)
+        {
+            case IMAGE_SIZE_160X120:
+            case IMAGE_SIZE_320X240:
+                 CurrentCompressRate = COMPRESS_RATE_36;
+                 break;
+            case IMAGE_SIZE_640X480:
+                 CurrentCompressRate = COMPRESS_RATE_60;
+                 break;
+            default:
+                break;
+        }
+    }
+    //设置图片压缩率，该项不保存，每次上电后需重新设置
+    if ( !send_compress_rate(Serialnumber,CurrentCompressRate))
+    {
+        UART1Write("\r\nsend_compress_rate error\r\n",0);
+        return 0;
+    }
+    //这里要注意,设置压缩率后要延时
+    delay(100);
+
+    return 1;
+    
+}
+
+/****************************************************************
+ 函数名：send_cmd
+ 函数描述：发送指令并识别指令返回
+ 输入参数：指令的首地址，指令的长度，匹配指令的首地址，需验证的个数
+ 返回：成功返回1,失败返回0
+******************************************************************/ 
+u8 send_cmd( const u8 *cmd,u8 n0,const u8 *rev,u8 n1)
+{
+    u8  i;
+    u8  tmp[5] = {0x00,0x00,0x00,0x00,0x00};
+
+  
+    cam_write(cmd, n0);
+
+    if ( !cam_receiver(tmp,5) ) 
+    {
+        return 0;
+    }
+   
+    //检验数据
+    for (i = 0; i < n1; i++)
+    {  
+        if (tmp[i] != rev[i]) 
+        {
+            return 0;
+        }
+    }
+    
+    return 1;
+
+}
+
+
+/****************************************************************
+函数名：current_photo_size
+函数描述:读取当前设置的图片尺寸
+输入参数：Serialnumber序列号，nImageSize传递图片尺寸的引用变量
+返回:成功返回1,失败返回0
+******************************************************************/ 
+u8 current_photo_size(u8 Serialnumber,u8 * nImageSize)
+{  
+    u8  i;
+    u8  tmp[6] = {0x00,0x00,0x00,0x00,0x00,0x00};
+
+    SetSerailNumber( CommandPacket,
+                     read_photo_size_cmd,
+                     sizeof(read_photo_size_cmd),
+                     ResponsePacket,
+                     read_photo_size_rsp,
+                     sizeof(read_photo_size_rsp),
+                     Serialnumber );
+      
+    cam_write(CommandPacket, sizeof(read_photo_size_cmd));
+
+    if ( !cam_receiver(tmp,6) ) 
+    {
+        return 0;
+    }
+   
+    //检验数据,对比前5个字节
+    for (i = 0; i < 5; i++)
+    {  
+        if (tmp[i] != ResponsePacket[i]) 
+        {
+            return 0;
+        }
+    }
+    
+    //最后一个字节表示当前的图片大小
+    *nImageSize = tmp[5];
+    return 1;
+}
+
+
+/****************************************************************
+函数名：send_photo_size
+函数描述：设置拍照的图片尺寸（可选择：160X120,320X240,640X480）
+输入参数：序列号，需要设置的图片尺寸
+返回:成功返回1,失败返回0
+******************************************************************/ 
+u8 send_photo_size(u8 Serialnumber,u8 nImageSize)
+{  
+    u8  i;
+    
+    SetSerailNumber( CommandPacket,
+                     set_photo_size_cmd,
+                     sizeof(set_photo_size_cmd),
+                     ResponsePacket,
+                     set_photo_size_rsp,
+                     sizeof(set_photo_size_rsp),
+                     Serialnumber );
+    
+    CommandPacket [sizeof(set_photo_size_cmd) - 1] = nImageSize;
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(set_photo_size_cmd),
+                  ResponsePacket,
+                  sizeof(set_photo_size_rsp) );
+    return i;
+}
+
+
+/****************************************************************
+函数名：send_reset
+函数描述：发送复位指令复位后要延时1-2秒
+输入参数：序列号
+返回:成功返回1 失败返回0
+******************************************************************/   
+u8 send_reset(u8 Serialnumber)
+{  
+    u8 i;
+    //复制命令与应答，修改序号
+    SetSerailNumber( CommandPacket,
+                     reset_cmd,
+                     sizeof(reset_cmd),
+                     ResponsePacket,
+                     reset_rsp,
+                     sizeof(reset_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(reset_cmd),
+                  ResponsePacket,
+                  sizeof(reset_rsp) );
+    
+    return i;
+
+}
+
+/****************************************************************
+函数名：send_stop_photo
+函数描述：清空图片缓存
+输入参数：序列号
+返回:成功返回1,失败返回0
+******************************************************************/    
+u8 send_photoBuf_cls(u8 Serialnumber)
+{ 
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     photoBufCls_cmd,
+                     sizeof(photoBufCls_cmd),
+                     ResponsePacket,
+                     photoBufCls_rsp,
+                     sizeof(photoBufCls_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(photoBufCls_cmd),
+                  ResponsePacket,
+                  sizeof(photoBufCls_rsp) );
+    return i;
+}  
+
+
+/****************************************************************
+函数名：send_compress_rate
+函数描述：发送设置图片压缩率
+输入参数：序列号
+返回:成功返回1,失败返回0
+******************************************************************/    
+u8 send_compress_rate(u8 Serialnumber,u8 nCompressRate)
+{
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     set_compress_cmd,
+                     sizeof(set_compress_cmd),
+                     ResponsePacket,
+                     compress_rate_rsp,
+                     sizeof(compress_rate_rsp),
+                     Serialnumber );
+    
+    if(nCompressRate > 0x36)
+    {
+        //最后一个字节表示压缩率
+        CommandPacket [sizeof(set_compress_cmd) - 1] = nCompressRate;
+    }
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(set_compress_cmd),
+                  ResponsePacket,
+                  sizeof(compress_rate_rsp) );
+    return i;
+}
+
+
+/****************************************************************
+函数名：send_start_photo
+函数描述：发送开始拍照的指令
+输入参数：序列号
+返回:识别成功返回1 失败返回0
+******************************************************************/   
+u8 send_start_photo(u8 Serialnumber)
+{
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     start_photo_cmd,
+                     sizeof(start_photo_cmd),
+                     ResponsePacket,
+                     start_photo_rsp,
+                     sizeof(start_photo_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(start_photo_cmd),
+                  ResponsePacket,
+                  sizeof(start_photo_rsp) );
+    return i;
+}   
+
+
+/****************************************************************
+函数名：send_read_len
+函数描述：读取拍照后的图片长度，即图片占用空间大小
+输入参数：序列号
+返回:图片的长度
+******************************************************************/ 
+u32 send_read_len(u8 Serialnumber)
+{
+    u8 i;
+    u32 len;
+    u8 tmp[9];  
+    
+    SetSerailNumber( CommandPacket,
+                     read_len_cmd,
+                     sizeof(read_len_cmd),
+                     ResponsePacket,
+                     read_len_rsp,
+                     sizeof(read_len_rsp),
+                     Serialnumber );
+    
+    //发送读图片长度指令
+    cam_write(CommandPacket, 5);
+
+    if ( !cam_receiver(tmp,9)) 
+    {
+        return 0;
+    }
+
+    //检验数据
+    for (i = 0; i < 7; i++)
+    {
+        if ( tmp[i] != ResponsePacket[i]) 
+        {
+            return 0;
+        }
+    }
+    
+    len = (u32)tmp[7] << 8;//高字节
+    len |= tmp[8];//低字节
+    
+    return len;
+}
+
+
+/****************************************************************
+函数名：send_get_photo
+函数描述：读取图片数据
+输入参数：读图片起始地址StaAdd, 
+          读取的长度readLen ，
+          接收数据的缓冲区buf
+          序列号
+返回:成功返回1，失败返回0
+FF D8 ... FF D9 是JPG的图片格式
+
+1.一次性读取的回复格式：76 00 32 00 00 FF D8 ... FF D9 76 00 32 00 00
+
+2.分次读取，每次读N字节,循环使用读取图片数据指令读取M次或者(M + 1)次读取完毕：
+如第一次执行后回复格式
+76 00 32 00 <FF D8 ... N> 76 00 32 00
+下次执行读取指令时，起始地址需要偏移N字节，即上一次的末尾地址，回复格式
+76 00 32 00 <... N> 76 00 32 00
+......
+76 00 32 00 <... FF D9> 76 00 32 00 //lastBytes <= N
+
+Length = N * M 或 Length = N * M + lastBytes
+
+******************************************************************/ 
+u8 send_get_photo(u16 staAdd,u16 readLen,u8 *buf,u8 Serialnumber)
+{
+    u8 i = 0;
+    u8 *ptr = NULL;
+    
+    
+    SetSerailNumber( CommandPacket,
+                     get_photo_cmd,
+                     sizeof(get_photo_cmd),
+                     ResponsePacket,
+                     get_photo_rsp,
+                     sizeof(get_photo_rsp),
+                     Serialnumber );
+    
+    //装入起始地址高低字节
+    CommandPacket[8] = (staAdd >> 8) & 0xff;
+    CommandPacket[9] = staAdd & 0xff;
+    //装入末尾地址高低字节
+    CommandPacket[12] = (readLen >> 8) & 0xff;
+    CommandPacket[13] = readLen & 0xff;
+    
+    //执行指令
+    cam_write(CommandPacket,16);
+    
+    //等待图片数据存储到buf，超时或无数据回复则返回0
+    if ( !cam_receiver(buf,readLen + 10))
+    {
+        return 0;
+    }
+    
+    //检验帧头76 00 32 00 00
+    for (i = 0; i < 5; i++)
+    {
+        if ( buf[i] != ResponsePacket[i] )
+        {
+            return 0;
+        }
+    }
+
+    //检验帧尾76 00 32 00 00
+    for (i = 0; i < 5; i++)
+    {
+        if ( buf[i + 5 + readLen] != ResponsePacket[i] )
+        {
+            return 0;
+        }
+    }
+    
+    
+    //宏开关选择丢弃/保留 帧头帧尾76 00 32 00 00
+    #if CLEAR_FRAME
+//    memcpy(buf,buf + 5,read_len);
+    ptr = buf;
+    
+    for (; readLen > 0; ++ptr)
+    {
+        *(ptr) = *(ptr + 5);
+        readLen--;
+    }
+    #endif
+    
+    return 1;
+}
+
+/****************************************************************
+函数名：send_open_motion
+函数描述：发送打开移动侦测指令
+输入参数：序列号
+返回:识别成功返回1 失败返回0
+******************************************************************/   
+u8 send_motion_sensitivity(u8 Serialnumber)
+{
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     motion_sensitivity_cmd,
+                     sizeof(motion_sensitivity_cmd),
+                     ResponsePacket,
+                     motion_sensitivity_rsp,
+                     sizeof(motion_sensitivity_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(motion_sensitivity_cmd),
+                  ResponsePacket,
+                  sizeof(motion_sensitivity_rsp) );
+    return i;
+}
+
+/****************************************************************
+函数名：send_open_motion
+函数描述：发送打开移动侦测指令
+输入参数：序列号
+返回:识别成功返回1 失败返回0
+******************************************************************/   
+u8 send_open_motion(u8 Serialnumber)
+{
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     motion_enable_cmd,
+                     sizeof(motion_enable_cmd),
+                     ResponsePacket,
+                     motion_rsp,
+                     sizeof(motion_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(motion_enable_cmd),
+                  ResponsePacket,
+                  sizeof(motion_rsp) );
+    return i;
+}
+
+/****************************************************************
+函数名：send_close_motion
+函数描述：发送关闭移动侦测指令
+输入参数：序列号
+返回:识别成功返回1 失败返回0
+******************************************************************/   
+u8 send_close_motion(u8 Serialnumber)
+{
+    u8 i;
+    
+    SetSerailNumber( CommandPacket,
+                     motion_disable_cmd,
+                     sizeof(motion_disable_cmd),
+                     ResponsePacket,
+                     motion_rsp,
+                     sizeof(motion_rsp),
+                     Serialnumber );
+    
+    i = send_cmd( CommandPacket,
+                  sizeof(motion_disable_cmd),
+                  ResponsePacket,
+                  sizeof(motion_rsp) );
+    return i;
+}
+
+/****************************************************************
+函数名：Motion_Detecte_Idle
+函数描述: 等待移动侦测事件,该函数可在RS485同时接多个摄像头时，传递
+          当前是第几个序列号上报移动侦测
+输入参数：传递一个指针变量
+返回:成功返回1 失败返回0
+******************************************************************/   
+u8 Motion_Detecte_Idle(u8 *pSerialnumber)
+{
+    u8  tmp[5] = {0x00,0x00,0x00,0x00,0x00};
+    
+    if ( !cam_receiver(tmp,5) ) 
+    {
+        return 0;
+    }
+    
+    //检验数据
+    //全部有5个数据，只校验4个，其中数组下标为1是序列号
+    if(!(tmp[0] == motion_detecte[0] && 
+         tmp[2] == motion_detecte[2] &&
+         tmp[3] == motion_detecte[3] &&
+         tmp[4] == motion_detecte[4] ))
+    {
+        return 0;
+    }
+    
+    //取出序列号
+    *pSerialnumber = tmp[1];
+    return 1;
+
+}
+
+u8 sendComBuff[8]={0};
+
+/****************************************************************
+函数名：CameraDemoApp
+函数描述：摄像头应用实例
+输入参数：序列号,图片尺寸
+返回:成功返回1，失败返回0
+******************************************************************/   
+u8 CameraDemoApp(u8 Serialnumber,u8 nCameraImageSize)
+{
+    u16 cntM = 0,lastBytes = 0,i = 0;
+    
+    #if USING_SAVE_SD
+    FRESULT res;
+    u8 pname[20];
+    u8 Issuccess = 0;
+    u32 defaultbw = 1;
+    #endif
+    
+    
+    //初始化摄像头
+    cameraReady = camera_init(Serialnumber,nCameraImageSize);
+    if(!cameraReady)
+    {
+        return 0;
+    }
+    //清空图片缓存
+    if( !send_photoBuf_cls(Serialnumber) )
+    {
+        return 0;
+    }
+    //开始拍照
+    if( !send_start_photo(Serialnumber) )
+    {
+        return 0;
+    }
+    else
+    {
+        //读取拍照后的图片长度
+        picLen = send_read_len(Serialnumber);
+    }
+    
+    if( !picLen )
+    {
+        return 0;
+    }
+    else
+    {
+        cntM = picLen / N_BYTE;
+        lastBytes = picLen % N_BYTE;
+    }
+    sendComBuff[0]=0xaa;
+    sendComBuff[5]=0x05; //图像命令
+    sendComBuff[6]=0xaf;
+    sendComBuff[1]=picLen>>24;
+    sendComBuff[2]=picLen>>16;
+    sendComBuff[3]=picLen>>8;
+    sendComBuff[4]=picLen;
+    //UART2Write(sendComBuff,7);
+    server_sendByte(sendComBuff,7);
+    delay(100);
+    //分M次，每次读N_BYTE字节
+    if( cntM )
+    {
+        for( i = 0; i < cntM; i++)
+        {  
+            memset(gprs_buf, 0, sizeof(gprs_buf));
+            //按图片长度读取数据
+            if( !send_get_photo( i * N_BYTE,
+                               N_BYTE,
+                               gprs_buf,
+                               Serialnumber) )
+            {
+                return 0;
+            }
+            else
+            {
+                //此分支可将图片数据输出到指定的串口
+                //如接口函数，将图片数据写入到串口2
+                //uart1_putchar(0x15);//发送标识符
+               server_sendByte(gprs_buf,N_BYTE);
+                
+            }
+            delay(50);
+        }
+    }
+    //剩余图片长度
+    if(lastBytes)
+    {
+
+        memset(gprs_buf, 0, sizeof(gprs_buf));  
+        
+        //读取剩余长度
+        if( !send_get_photo( i * N_BYTE,
+                            lastBytes,
+                            gprs_buf,
+                            Serialnumber) )
+        {
+        
+            return 0;
+        }
+        else
+        {
+           // uart1_putchar(0x15);//发送标识符
+            //UART2Write(gprs_buf,lastBytes);//发送图片数据
+            server_sendByte(gprs_buf,lastBytes);
+        }
+        delay(50);
+    }
+    
+   
+    return 1;
+}
+
+
+    
+
+void  function_Star(){
+  static int led_State=0;  
+  digitalWrite(LED_PIN,led_State);
+  led_State=(~led_State);
+}
+
+
+/*
+  检查串口是否有数据
+*/
+void Usart_RxTask(void)
+{
+  unsigned char i =0;
+  if (Serial.available() > 0)
+  {
+    uint8_t t = Serial.read();
+    Serial_Buffer[buffUartIndex++] = t;
+    preUartTick = millis();
+    if (buffUartIndex >= Serial_RX_MAXSIZE - 1) {
+      buffUartIndex = Serial_RX_MAXSIZE - 2;
+      preUartTick = preUartTick - 10;
+    }
+  }
+  if (buffUartIndex > 0 && (millis() - preUartTick >= 10))
+  { //data ready
+    Serial_Buffer[buffUartIndex] = 0x00;
+          if(strstr((char*)&Serial_Buffer[0],"esp_get")!=NULL) 
+          {
+                getflag=1;
+          }
+          if(strstr((char*)&Serial_Buffer[0],"esp_close")!=NULL) 
+          {
+                getflag=0;
+          }
+    // 将UART端口数据推送到所有已连接的telnet客户端，实现双向通信
+       for(i = 0; i < MAX_SRV_CLIENTS; i++){
+          if (serverClients[i] && serverClients[i].connected()){
+          serverClients[i].write(&Serial_Buffer[0], buffUartIndex);
+            delay(1);
+         }
+       }
+    buffUartIndex = 0;
+  }
+}
+
+
+void server_sendByte(u8 *data,u32 len)
+{
+  int i=0;
+  for(i = 0; i < MAX_SRV_CLIENTS; i++){
+            if (serverClients[i] && serverClients[i].connected()){
+             serverClients[i].write(&data[0], len);
+                delay(1);
+     }
+  }
+}
+
+
+void setup() {
+  
+  swSer.begin(BAUD_RATE, SWSERIAL_8N1, D5, D6, false, 95, 11);
+  for (char ch = ' '; ch <= 'z'; ch++) {
+    swSer.write(ch);
+  }
+  swSer.println("");
+  WiFi.softAP(ssid, password);
+  swSer.println();
+  swSer.print("IP address: ");
+  swSer.println(WiFi.softAPIP());
+  pinMode(LED_PIN,OUTPUT);//设置对应引脚为输出模式
+  digitalWrite(LED_PIN,HIGH);
+  //启动UART传输和服务器
+  server.begin();
+  server.setNoDelay(true);//停止小包合并发送
+  swSer.print("Ready! Use 'telnet ");
+  swSer.print(WiFi.localIP());//获得服务器本地IP
+
+  Serial.begin(115200);
+  //摄像头模块初始化  
+  if (!camera_init(SERIAL_NUM_0,IMAGE_SIZE_160X120))
+  {
+      while(1)
+      {
+        swSer.println("\r\nCamera Init fail!\r\n");
+        delay(1000);     //
+      }       
+  }
+  else
+  {
+        swSer.println("\r\nCamera Init Success!\r\n");
+//        GPIO_ResetBits(GPIOC,GPIO_Pin_13);
+//        delay_ms(200);     //在上电复位后要等1-2秒摄像头才能接收指令
+//        GPIO_SetBits(GPIOC,GPIO_Pin_13);//初始化成功短鸣一声并亮灯
+//        delay_ms(200);     //在上电复位后要等1-2秒摄像头才能接收指令
+//        GPIO_SetBits(GPIOC,GPIO_Pin_13);//初始化成功 亮灯
+  }
+}
+
+
+void loop() {
+  uint8_t i;
+  //检测服务器端是否有活动的客户端连接
+  if (server.hasClient()){
+    for(i = 0; i < MAX_SRV_CLIENTS; i++){
+      //查找空闲或者断开连接的客户端，并置为可用
+      if (!serverClients[i] || !serverClients[i].connected()){
+        if(serverClients[i]) serverClients[i].stop();
+        serverClients[i] = server.available();
+         swSer.print("New client: "); swSer.println(i);
+        continue;
+      }
+    }
+    //若没有可用客户端，则停止连接
+    WiFiClient serverClient = server.available();
+    serverClient.stop();
+  }
+  //检查客户端的数据
+  for(i = 0; i < MAX_SRV_CLIENTS; i++){
+    if (serverClients[i] && serverClients[i].connected()){
+      if(serverClients[i].available()){
+        //从Telnet客户端获取数据，并推送到URAT端口
+       while(serverClients[i].available()) 
+       {
+          Rxstr = serverClients[i].readStringUntil('\r\n');
+          if(Rxstr.indexOf("esp_get")!=-1) 
+          {
+                getflag=1;
+          }
+          if(Rxstr.indexOf("esp_close")!=-1) 
+          {
+                getflag=0;
+          }
+          swSer.println(Rxstr);
+       }
+      }
+    }
+  }
+  //Usart_RxTask();
+  if(getflag==1)
+  {
+    CameraDemoApp(SERIAL_NUM_0,IMAGE_SIZE_160X120); 
+    getflag=0; 
+  }
+  delay(1);
+}