Arduino TTL jpeg串行摄像头和esp8266 wifi无线模块

我正在写一个代码，在测量距离后，如果距离超过了一定的距离，就可以拍照

并将距离数据发送到Thingspeak，将照片存储在SD卡上

<>但是，程序在中间停止。

距离测量和Thingspeak服务器数据传输/摄像机拍摄分别开发

这两个源代码正常独立工作

但当这两个代码组合在一起时，会出现错误

使用部件：Arduino Uno、esp8266 wifi模块、带有NTSC视频的TTL串行JPEG摄像头、2Y0A21红外距离传感器、Micro SD卡适配器

#include <SoftwareSerial.h>
#include <stdlib.h>
#include <Adafruit_VC0706.h>
#include <SPI.h>
#include <SD.h>

#define DEBUG true
#define chipSelect 10

const int distancePin = 0;

String apiKey = "39R00EYW0BTKK5JJ";

SoftwareSerial esp8266(2, 3); //TX/RX 

#if ARDUINO >= 100

SoftwareSerial cameraconnection = SoftwareSerial(4, 5); //TX/RX

#else
NewSoftSerial cameraconnection = NewSoftSerial(4, 5);
#endif

Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);

int defaultDistance = 0;
int temp = 0;

void ThingspeakSendData(String alarmData);
void Snapshots();

void setup() {
    #if !defined(SOFTWARE_SPI)
    #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
        if (chipSelect != 53) pinMode(53, OUTPUT); // SS on Mega
    #else
        if (chipSelect != 10) pinMode(10, OUTPUT); // SS on Uno, etc.
    #endif
    #endif

    Serial.begin(9600);
    Serial.println("VC0706 Camera snapshot test");//the program keeps stopping in the middle.

    if (cam.begin()) {
        Serial.println("Camera Found:");
    }
    else {
        Serial.println("No camera found?");
        return;
    }

    char *reply = cam.getVersion();
    if (reply == 0) {
        Serial.print("Failed to get version");
    }
    else {
        Serial.println("-----------------");
        Serial.print(reply);
        Serial.println("-----------------");
    }

    cam.setImageSize(VC0706_640x480);

    uint8_t imgsize = cam.getImageSize();
    Serial.print("Image size: ");
    if (imgsize == VC0706_640x480) Serial.println("640x480");
    if (imgsize == VC0706_320x240) Serial.println("320x240");
    if (imgsize == VC0706_160x120) Serial.println("160x120");

    esp8266.begin(9600);

    sendData("AT+RST\r\n", 2000, DEBUG); //reset module
    sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //dual mode로 설정
    sendData("AT+CWJAP=\"0sangsiljangnim\",\"123456788\"\r\n", 5000, DEBUG); 

    // 2Y0A21
    analogReference(DEFAULT);
    pinMode(distancePin, INPUT);

    // distancePin 2Y0A21
    int raw = analogRead(distancePin);
    int volt = map(raw, 0, 1023, 0, 5000);
    int distance = (21.61 / (volt - 0.1696)) * 1000;
    defaultDistance = distance;
    Serial.println("Default : " + defaultDistance);
}

void loop() {
    // distancePin 2Y0A21 
    int raw = analogRead(distancePin);
    int volt = map(raw, 0, 1023, 0, 5000);
    int distance = (21.61 / (volt - 0.1696)) * 1000;
    Serial.println(distance);

    if (distance < defaultDistance)
    {
        String alarmData = "1";
        esp8266.listen();
        ThingspeakSendData(alarmData);

        cameraconnection.listen();
        Snapshots();
    }
    else if (distance == defaultDistance)
    {
        String alarmData = "0";
        esp8266.listen();
        ThingspeakSendData(alarmData);
    }

    delay(3000);
}

void ThingspeakSendData(String alarmData) {
    String cmd = "AT+CIPSTART=\"TCP\",\"";
    cmd += "184.106.153.149"; 
    cmd += "\",80";           
    esp8266.println(cmd);

    if (esp8266.find("Error")) {
        Serial.println("AT+CIPSTART error");
        return;
    }

    String getStr = "GET /update?api_key=";
    getStr += apiKey;
    getStr += "&field1=";
    getStr += String(alarmData);
    getStr += "\r\n\r\n";

    // Send Data
    cmd = "AT+CIPSEND=";
    cmd += String(getStr.length());
    esp8266.println(cmd);

    if (esp8266.find(">")) {
        esp8266.print(getStr);
    }
    else {
        esp8266.println("AT+CIPCLOSE");
        // alert uesp8266
        Serial.println("AT+CIPCLOSE");
    }
}

String sendData(String command, const int timeout, boolean debug) {
    String response = "";
    esp8266.print(command); 
    long int time = millis();

    while ((time + timeout) > millis()) {
        while (esp8266.available()) {

            char c = esp8266.read(); 
            response += c;
        }
    }
    if (debug) {
        Serial.print(response);
    }

    return response;
}

void Snapshots() {
    Serial.println("Snap in 3 secs...");
    delay(3000);

    if (!cam.takePicture())
        Serial.println("Failed to snap!");
    else
        Serial.println("Picture taken!");

    if (!SD.begin(chipSelect)) {
        Serial.println("Card failed, or not present");
        return;
    }

    char filename[13];
    strcpy(filename, "IMAGE00.JPG");
    for (int i = 0; i < 100; i++) {
        filename[5] = '0' + i / 10;
        filename[6] = '0' + i % 10;

        if (!SD.exists(filename)) {
            break;
        }
    }

    File imgFile = SD.open(filename, FILE_WRITE);

    uint16_t jpglen = cam.frameLength();
    Serial.print("Storing ");
    Serial.print(jpglen, DEC);
    Serial.print(" byte image.");

    int32_t time = millis();
    pinMode(8, OUTPUT);

    byte wCount = 0; 
    while (jpglen > 0) {

        uint8_t *buffer;
        uint8_t bytesToRead = min(32, jpglen); 
        buffer = cam.readPicture(bytesToRead);
        imgFile.write(buffer, bytesToRead);
        if (++wCount >= 64) { 
            Serial.print('.');
            wCount = 0;
        }

        jpglen -= bytesToRead;
    }
    imgFile.close();

    time = millis() - time;
    Serial.println("done!");
    Serial.print(time); Serial.println(" ms elapsed");
}

#包括
#包括
#包括
#包括
#包括
#定义调试为真
#定义芯片选择10
常数int distancePin=0；
字符串apiKey=“39R00EYW0BTKK5JJ”；
软件系列esp8266（2,3）//发送/接收
#如果ARDUINO>=100
SoftwareSerial cameraconnection=SoftwareSerial（4,5）//发送/接收
#否则
NewSoftSerial cameraconnection=NewSoftSerial（4,5）；
#恩迪夫
Adafruit_VC0706凸轮=Adafruit_VC0706（&cameraconnection）；
int defaultDistance=0；
内部温度=0；
无效ThingspeakSendData（字符串报警数据）；
无效快照（）；
无效设置（）{
#如果！已定义（软件\u SPI）
#如果已定义（uu AVR_ATmega1280_uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuATMEGA2560_uuuuuuuuuuu）
if（chipSelect！=53）pinMode（53，输出）；///SS on Mega
#否则
如果（chipSelect！=10）pinMode（10，输出）；//Uno上的SS等。
#恩迪夫
#恩迪夫
Serial.begin（9600）；
串行打印（“VC0706相机快照测试”）；和/或程序在中间停止。
if（cam.begin（））{
Serial.println（“摄像头发现：”）；
}
否则{
Serial.println（“未找到摄像头？”）；
返回；
}
char*reply=cam.getVersion（）；
如果（回复==0）{
Serial.print（“获取版本失败”）；
}
否则{
Serial.println（“------------------------”）；
连续打印（回复）；
Serial.println（“------------------------”）；
}
凸轮设置图像尺寸（VC0706_640x480）；
uint8_t imgsize=cam.getImageSize（）；
串行打印（“图像大小：”）；
如果（imgsize==VC0706_640x480）Serial.println（“640x480”）；
如果（imgsize==VC0706_320x240）Serial.println（“320x240”）；
如果（imgsize==VC0706_160x120）Serial.println（“160x120”）；
esp8266.贝京（9600）；
sendData（“AT+RST\r\n”，2000，调试）；//重置模块
sendData（“AT+CWMODE=1\r\n”，1000，调试）；//双模式로 설정
sendData（“AT+CWJAP=\“0sangsiljangnim\”，\“123456788\”\r\n“，5000，调试）；
//2Y0A21
模拟参考（默认）；
引脚模式（距离引脚，输入）；
//距离销2Y0A21
int raw=模拟读数（距离PIN）；
int volt=map（原始值，0,1023,0,5000）；
内部距离=（21.61/（伏特-0.1696））*1000；
默认距离=距离；
Serial.println（“默认值：+defaultDistance”）；
}
void循环（）{
//距离销2Y0A21
int raw=模拟读数（距离PIN）；
int volt=map（原始值，0,1023,0,5000）；
内部距离=（21.61/（伏特-0.1696））*1000；
串行打印LN（距离）；
如果（距离<默认距离）
{
字符串alarmData=“1”；
esp8266.听（）；
ThingspeakSendData（报警数据）；
cameraconnection.listen（）；
快照（）；
}
else if（距离==默认距离）
{
字符串alarmData=“0”；
esp8266.听（）；
ThingspeakSendData（报警数据）；
}
延迟（3000）；
}
无效内容SpeakSendData（字符串alarmData）{
String cmd=“AT+CIPSTART=\“TCP\”，\”；
cmd+=“184.106.153.149”；
cmd+=“\”，80”；
esp8266.println（cmd）；
如果（esp8266.查找（“错误”））{
Serial.println（“AT+CIPSTART错误”）；
返回；
}
String getStr=“获取/更新？api_key=”；
getStr+=apiKey；
getStr+=“&field1=”；
getStr+=字符串（alarmData）；
getStr+=“\r\n\r\n”；
//发送数据
cmd=“AT+CIPSEND=”；
cmd+=String（getStr.length（））；
esp8266.println（cmd）；
如果（esp8266.find（“>”）{
esp8266.打印（getStr）；
}
否则{
esp8266.println（“AT+CIPCLOSE”）；
//警报uesp8266
Serial.println（“AT+CIPCLOSE”）；
}
}
字符串sendData（字符串命令、常量int超时、布尔调试）{
字符串响应=”；
esp8266.打印（命令）；
长整数时间=毫秒（）；
而（（时间+超时）>毫秒（）{
而（esp8266.available（））{
char c=esp8266.read（）；
响应+=c；
}
}
如果（调试）{
串行打印（响应）；
}
返回响应；
}
无效快照（）{
Serial.println（“管理单元3秒…”）；
延迟（3000）；
如果（！cam.takePicture（））
Serial.println（“未能捕捉！”）；
其他的
Serial.println（“拍照！”）；
如果（！SD.begin（芯片选择））{
Serial.println（“卡故障或不存在”）；
返回；
}
字符文件名[13]；
strcpy（文件名为IMAGE00.JPG）；
对于（int i=0；i<100；i++）{
文件名[5]=“0”+i/10；
文件名[6]=“0”+i%10；
如果（！SD.存在（文件名））{
打破
}
}
文件imgFile=SD.open（文件名，文件写入）；
uint16_t jpglen=cam.frameLength（）；
串行打印（“存储”）；
连续打印（jpglen，12月）；
串行打印（“字节图像”）；
int32_t time=millis（）；
pinMode（8，输出）；
字节wCount=0；
而（jpglen>0）{
uint8_t*缓冲器；
uint8_t bytesToRead=min（32，jpglen）；
缓冲区=cam.readPicture（bytesToRead）；
write（缓冲区，bytesToRead）；
如果（++wCount>=64）{
序列号。打印（'.'）；
wCount=0；
}
jpglen-=bytesToRead；
}
imgFile.close（）；
时间=毫秒（）-时间；
Serial.println（“完成！”）；
Serial.print（时间）；Serial.println（“已用毫秒”）；
}

Hi GENYF，欢迎来到stack overflow。当你编译代码和上传到Uno时，你能显示你得到的输出吗？您正在使用Arduino IDE吗？是英国广播公司吗