成品图

这是一个和宋庆龄基金会和航天什么什么合作的项目，然后主要的功能是这样的。

通过433无线串口做图传（传一个图片要用20多秒，不要问我为什么要做……）然后可以在processing上控制Arduino无线传输图片或者陀螺仪，地磁，温度，GPS等传感器数据，控制太阳能帆板的张开还是闭合。Arduino还可以用太阳能充电，做电源管理。

然后这是代码

Arduino

#include "High_Temp.h"
#include "Wire.h"
#include "I2Cdev.h"
#include "MPU9250.h"
#include <SPI.h>
#include <arduino.h>
#include <SD.h>
#include <Servo.h>









//Camera vary


#define PIC_PKT_LEN    128                  
#define PIC_FMT_VGA    7
#define PIC_FMT_CIF    5
#define PIC_FMT_OCIF   3
#define CAM_ADDR       0
#define CAM_SERIAL     Serial1
#define PIC_FMT        PIC_FMT_VGA

#define SERVO_PIN      10
#define SERVO1_PIN     6

#define sample_num_mdate  5000  



// SD card shield
File myFile;

const byte cameraAddr = (CAM_ADDR << 5);  // addr
unsigned long picTotalLen = 0;            // picture length





//High Tempature Sensor vary
HighTemp ht(A4, A5);



//GPS vary
#define GPS_SERIAL Serial2



//GYRO vray
MPU9250 accelgyro;
I2Cdev   I2C_M;

uint8_t buffer_m[6];

int16_t ax, ay, az;
int16_t gx, gy, gz;
int16_t   mx, my, mz;

float heading;
float tiltheading;

float Axyz[3];
float Gxyz[3];
float Mxyz[3];

volatile float mx_sample[3];
volatile float my_sample[3];
volatile float mz_sample[3];

static float mx_centre = 0;
static float my_centre = 0;
static float mz_centre = 0;

volatile int mx_max =0;
volatile int my_max =0;
volatile int mz_max =0;

volatile int mx_min =0;
volatile int my_min =0;
volatile int mz_min =0;

// Servo
Servo myservo,myservo1;




void setup() {


//Serial init
  Serial.begin(9600);
  Serial.println("init....");

//High Temperature Sensor init
  ht.begin();
  Serial.println("High Temperature Sensor init suceed");

//GPS init
  GPS_SERIAL.begin(9600);
  Serial.println("GPS init succeed");

//gyro init
  Wire.begin();
  accelgyro.initialize();
  Serial.println(accelgyro.testConnection() ? "MPU9250 connection successful" : "MPU9250 connection failed");

//servo init
  myservo.attach(10); 
  myservo1.attach(6);

//Camera init
  CAM_SERIAL.begin(115200);
  camera_initialize();


//SD carc shield init
pinMode(4,OUTPUT);          // CS pin of SD Card Shield
if (!SD.begin(4)) 
{
  Serial.print("sd init failed");
  return;
}
Serial.println("sd init done.");





}

void loop() {

//send High Tempature Sensor data
  Serial.print("High Temperature Sensor = ");
  Serial.println(ht.getThmc());
  Serial.println();



//send GPS data
  while(1){
    
    char inChar = GPS_SERIAL.read();

  while(inChar != '$'){             //'$' means a new line of data
    inChar = GPS_SERIAL.read();
}

GPS_SERIAL.setTimeout(100);
  String inString = GPS_SERIAL.readStringUntil('\n');     //read the whole line of data


  if(inString.substring(0,5) == "GPGGA"){     //"GPGGA" is a line of message which include the message of possition, then send it with Serial

    Serial.println(inString);
  break;
}

}
Serial.println();





//send gyro data
getAccel_Data();
getGyro_Data();
getCompassDate_calibrated(); // compass data has been calibrated here 
getHeading();       //before we use this function we should run 'getCompassDate_calibrated()' frist, so that we can get calibrated data ,then we can get correct angle .          
getTiltHeading();           

Serial.print("Acceleration(g) of X,Y,Z:");
Serial.print(Axyz[0]); 
Serial.print(",");
Serial.print(Axyz[1]); 
Serial.print(",");
Serial.println(Axyz[2]); 
Serial.print("Gyro(degress/s) of X,Y,Z:");
Serial.print(Gxyz[0]); 
Serial.print(",");
Serial.print(Gxyz[1]); 
Serial.print(",");
Serial.println(Gxyz[2]); 
Serial.print("Compass Value of X,Y,Z:");
Serial.print(Mxyz[0]); 
Serial.print(",");
Serial.print(Mxyz[1]); 
Serial.print(",");
Serial.println(Mxyz[2]);
Serial.println("The clockwise angle between the magnetic north and X-Axis:");
Serial.print(heading);
Serial.println(" ");
Serial.println("The clockwise angle between the magnetic north and the projection of the positive X-Axis in the horizontal plane:");
Serial.println(tiltheading);
Serial.println();



Serial.println();  //finished the whole data once, send some blank line 
Serial.println();
Serial.println();



if (Serial.available()) { // if there is some data from Serial
  int val = Serial.read(); // read it and store it in val
  if(val == '2'){    //'2' is a valid char, flush the data of Serial buffer and wait the next command
    Serial.flush();
  
    while(Serial.available() <= 0){  //wait the next command from Serial, PC won't send the next command before it get ready for the next thing like quite a lot data of the picature.
  }
val = Serial.read();
switch (val) {
        case '2':           //'2' means need get a picature and send it with Serial

          preCapture();     //check the sync with camera
          Capture();        //camera will get an image and store in its temporary memory
          GetData();        //get the data from camera and store them as a jpg file in SD card. 
          sendData();       //send the data with Serial


          break;
        case '3':             //'3' means need pull up the solar battery

        myservo.write(180);
        myservo1.write(170);

        break;
        
        case '4':             //'4' means need pull down the solar battery
        myservo.write(90);
        myservo1.write(80);

        break;


      } 

    }
    
  } 

  
  delay(1000);
  

}




















/**
* Gyro functions
*/

void getHeading(void)
{
  heading=180*atan2(Mxyz[1],Mxyz[0])/PI;
  if(heading <0) heading +=360;
}

void getTiltHeading(void)
{
  float pitch = asin(-Axyz[0]);
  float roll = asin(Axyz[1]/cos(pitch));

  float xh = Mxyz[0] * cos(pitch) + Mxyz[2] * sin(pitch);
  float yh = Mxyz[0] * sin(roll) * sin(pitch) + Mxyz[1] * cos(roll) - Mxyz[2] * sin(roll) * cos(pitch);
  float zh = -Mxyz[0] * cos(roll) * sin(pitch) + Mxyz[1] * sin(roll) + Mxyz[2] * cos(roll) * cos(pitch);
  tiltheading = 180 * atan2(yh, xh)/PI;
  if(yh<0)    tiltheading +=360;
}



void Mxyz_init_calibrated ()
{

  Serial.println(F("Before using 9DOF,we need to calibrate the compass frist,It will takes about 2 minutes."));
  Serial.print("  ");
  Serial.println(F("During  calibratting ,you should rotate and turn the 9DOF all the time within 2 minutes."));
  Serial.print("  ");
  Serial.println(F("If you are ready ,please sent a command data 'ready' to start sample and calibrate."));
  while(!Serial.find("ready")); 
  Serial.println("  ");
  Serial.println("ready");
  Serial.println("Sample starting......");
  Serial.println("waiting ......");

  get_calibration_Data ();

  Serial.println("     ");
  Serial.println("compass calibration parameter ");
  Serial.print(mx_centre);
  Serial.print("     ");
  Serial.print(my_centre);
  Serial.print("     ");
  Serial.println(mz_centre);
  Serial.println("    ");
}


void get_calibration_Data ()
{
  for (int i=0; i<sample_num_mdate;i++)
  {
    get_one_sample_date_mxyz();
    /*
    Serial.print(mx_sample[2]);
    Serial.print(" ");
    Serial.print(my_sample[2]);                            //you can see the sample data here .
    Serial.print(" ");
    Serial.println(mz_sample[2]);
    */


    
    if (mx_sample[2]>=mx_sample[1])mx_sample[1] = mx_sample[2];     
    if (my_sample[2]>=my_sample[1])my_sample[1] = my_sample[2]; //find max value      
    if (mz_sample[2]>=mz_sample[1])mz_sample[1] = mz_sample[2];   
    
    if (mx_sample[2]<=mx_sample[0])mx_sample[0] = mx_sample[2];
    if (my_sample[2]<=my_sample[0])my_sample[0] = my_sample[2];//find min value
    if (mz_sample[2]<=mz_sample[0])mz_sample[0] = mz_sample[2];
    
  }
  
  mx_max = mx_sample[1];
  my_max = my_sample[1];
  mz_max = mz_sample[1];      
  
  mx_min = mx_sample[0];
  my_min = my_sample[0];
  mz_min = mz_sample[0];
  

  
  mx_centre = (mx_max + mx_min)/2;
  my_centre = (my_max + my_min)/2;
  mz_centre = (mz_max + mz_min)/2;  
  
}

void get_one_sample_date_mxyz()
{   
  getCompass_Data();
  mx_sample[2] = Mxyz[0];
  my_sample[2] = Mxyz[1];
  mz_sample[2] = Mxyz[2];
} 

void getAccel_Data(void)
{
  accelgyro.getMotion9(&ax, &ay, &az, &gx, &gy, &gz, &mx, &my, &mz);
Axyz[0] = (double) ax / 16384;//16384  LSB/g
Axyz[1] = (double) ay / 16384;
Axyz[2] = (double) az / 16384; 
}

void getGyro_Data(void)
{
  accelgyro.getMotion9(&ax, &ay, &az, &gx, &gy, &gz, &mx, &my, &mz);
Gxyz[0] = (double) gx * 250 / 32768;//131 LSB(¡ã/s)
Gxyz[1] = (double) gy * 250 / 32768;
Gxyz[2] = (double) gz * 250 / 32768;
}

void getCompass_Data(void)
{
I2C_M.writeByte(0x0C, 0x0A, 0x01); //enable the magnetometer
delay(10);
I2C_M.readBytes(0x0C, 0x03, 6, buffer_m);

mx = ((int16_t)(buffer_m[1]) << 8) | buffer_m[0] ;
my = ((int16_t)(buffer_m[3]) << 8) | buffer_m[2] ;
mz = ((int16_t)(buffer_m[5]) << 8) | buffer_m[4] ;  

//Mxyz[0] = (double) mx * 1200 / 4096;
//Mxyz[1] = (double) my * 1200 / 4096;
//Mxyz[2] = (double) mz * 1200 / 4096;
Mxyz[0] = (double) mx * 4800 / 8192;
Mxyz[1] = (double) my * 4800 / 8192;
Mxyz[2] = (double) mz * 4800 / 8192;
}

void getCompassDate_calibrated ()
{
  getCompass_Data();
  Mxyz[0] = Mxyz[0] - mx_centre;
  Mxyz[1] = Mxyz[1] - my_centre;
  Mxyz[2] = Mxyz[2] - mz_centre;  
}










/**
* camera functions
*/
void clearRxBuf()
{
  while (CAM_SERIAL.available())
  {
    CAM_SERIAL.read();
  }
}

void sendCmd(char cmd[], int cmd_len)
{
  for (char i = 0; i < cmd_len; i++) CAM_SERIAL.print(cmd[i]);
}

void camera_initialize()
{
  char cmd[] = {0xaa,0x0d|cameraAddr,0x00,0x00,0x00,0x00} ;
  unsigned char resp[6];

  CAM_SERIAL.setTimeout(500);
  while (1)
  {
      //clearRxBuf();
    sendCmd(cmd,6);
    if (CAM_SERIAL.readBytes((char *)resp, 6) != 6)
    {
      continue;
    }
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x0d && resp[4] == 0 && resp[5] == 0)
    {
      if (CAM_SERIAL.readBytes((char *)resp, 6) != 6) continue;
      if (resp[0] == 0xaa && resp[1] == (0x0d | cameraAddr) && resp[2] == 0 && resp[3] == 0 && resp[4] == 0 && resp[5] == 0) break;
    }
  }
  cmd[1] = 0x0e | cameraAddr;
  cmd[2] = 0x0d;
  sendCmd(cmd, 6);
  // Serial.println("\nCamera initialization done.");
}

void preCapture()
{
  char cmd[] = { 0xaa, 0x01 | cameraAddr, 0x00, 0x07, 0x00, PIC_FMT };
  unsigned char resp[6];

  CAM_SERIAL.setTimeout(100);
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (CAM_SERIAL.readBytes((char *)resp, 6) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x01 && resp[4] == 0 && resp[5] == 0) break;
  }
}

void Capture()
{
  char cmd[] = { 0xaa, 0x06 | cameraAddr, 0x08, PIC_PKT_LEN & 0xff, (PIC_PKT_LEN>>8) & 0xff ,0};
  unsigned char resp[6];

  CAM_SERIAL.setTimeout(100);
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (CAM_SERIAL.readBytes((char *)resp, 6) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x06 && resp[4] == 0 && resp[5] == 0) break;
  }
  cmd[1] = 0x05 | cameraAddr;
  cmd[2] = 0;
  cmd[3] = 0;
  cmd[4] = 0;
  cmd[5] = 0;
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (CAM_SERIAL.readBytes((char *)resp, 6) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x05 && resp[4] == 0 && resp[5] == 0) break;
  }
  cmd[1] = 0x04 | cameraAddr;
  cmd[2] = 0x1;
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (CAM_SERIAL.readBytes((char *)resp, 6) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x04 && resp[4] == 0 && resp[5] == 0)
    {
      CAM_SERIAL.setTimeout(1000);
      if (CAM_SERIAL.readBytes((char *)resp, 6) != 6)
      {
        continue;
      }
      if (resp[0] == 0xaa && resp[1] == (0x0a | cameraAddr) && resp[2] == 0x01)
      {
        picTotalLen = (resp[3]) | (resp[4] << 8) | (resp[5] << 16);
            // Serial.print("picTotalLen:");
        delay(500);
        Serial.println(picTotalLen);
        break;
      }
    }
  }

}

void GetData()
{
  unsigned int pktCnt = (picTotalLen) / (PIC_PKT_LEN - 6);
  if ((picTotalLen % (PIC_PKT_LEN-6)) != 0) pktCnt += 1;

  char cmd[] = { 0xaa, 0x0e | cameraAddr, 0x00, 0x00, 0x00, 0x00 };
  unsigned char pkt[PIC_PKT_LEN];

  char picName[] = "pic.jpg";     //make a jpg file named "pic.jpg", the file will be removed if it has already exist.

  if (SD.exists(picName))
  {
    SD.remove(picName);
  }

  myFile = SD.open(picName, FILE_WRITE);
  if(myFile){
    CAM_SERIAL.setTimeout(1000);
    for (unsigned int i = 0; i < pktCnt; i++)
    {
      cmd[4] = i & 0xff;
      cmd[5] = (i >> 8) & 0xff;

      int retry_cnt = 0;
      retry:
      delay(10);
      clearRxBuf();
      sendCmd(cmd, 6);
      uint16_t cnt = CAM_SERIAL.readBytes((char *)pkt, PIC_PKT_LEN);

      unsigned char sum = 0;
      for (int y = 0; y < cnt - 2; y++)
      {
        sum += pkt[y];
      }
      if (sum != pkt[cnt-2])
      {
        if (++retry_cnt < 100) goto retry;
        else break;
      }

          myFile.write((const uint8_t *)&pkt[4], cnt-6);  //write the date getted from camera.
        }
        cmd[4] = 0xf0;
        cmd[5] = 0xf0;
        sendCmd(cmd, 6);
      }
      myFile.close();
}




void sendData(){

  byte dataBuffer[127]; 
  int tail = 0;

  delay(1000);
  File photoFile = SD.open("pic.jpg");   
      
if (photoFile) {                    //send 128 bytes once a time,127 bytes from the jpg file, and calc 1 check byte(sum check) 
  while (photoFile.position() < photoFile.size()) {   //do when there is bytes in jpg file.
    
    dataBuffer[tail++] = photoFile.read();   //fullfill the databuffer
    if(tail == 127){          //if already get 127 byte from jpg file
      int val;
      do{
        
        
        
        int sum = 0;
        for(int i=0; i< 127; i++){
        Serial.write(dataBuffer[i]); // send the data in buffer
        sum += dataBuffer[i];
        sum = sum % 0xFF;           //calc the check byte.
      }
      Serial.write(sum);            //send the check byte.
      tail = 0;
      
      while(Serial.available() <= 0){
      }

      val = Serial.read();     //get a command to know if PC have got all the 128 bytes correctly.


      if(val == '3'){    //'3' is a special command in case of the pc have restart the program, but arduino are still trying to send all the camera data. it should be finished.
        return;
    }

      } while (val == '0');  //'0' means pc didn't get the bytes correctly, something is wrong, resend it.
    }
  }







  if(tail > 0){           //if there are still bytes in jpg file, but less than 127byte. most thing is similar to before expect need fullfill the buffer when there is no data in jpg file.
    int val;
    do{
      
      
      
      int sum = 0;
      for(int i=0; i< 127; i++){
        if(i < tail){
          Serial.write(dataBuffer[i]);
          sum += dataBuffer[i];
          sum = sum % 0xFF;
        }else{
          Serial.write(0);    //if there are no bytes in jpg file, fill it with 0x00;
        }
      }
      Serial.write(sum);



      while(Serial.available() <= 0){
      }

      val = Serial.read();
      

    } while (val == '0');  
    
  }






}else{
  Serial.println("open photoFile failed");
}   

photoFile.close();   



}    

processing

import processing.serial.*;

    Serial myPort;  
    OutputStream output;  


    int is_first_change_to_system_state_1 = 0; //something special should be done at first when system_state is changed to 1
    int number_got_of_img_now = -1;

    String inString = "0"; //this is a temp vary to store the date from the Serial.
    int pic_length; //how many bytes the img include

    int system_state = 0; //this vary indicate which state is the program running now.


    PImage img; 


    void setup() {  

        size(800, 600);  

        printArray( Serial.list() );  
        myPort = new Serial( this, Serial.list()[0], 9600);  //LOOK HERE!!!!!!!!!!!!!!!!!!!!!!!!       0 is the number of Serial module on my PC, you NEED change it to a correct number, most time is 0 or 1 in PC.
        myPort.clear();  
        println("Processing init finished");

    }  


    void draw() {  

        if (system_state == 1) {
            
        


         
            while ( myPort.available () > 0 ) {
                if (is_first_change_to_system_state_1 == 0) {       // Arduino will send the length of img at first, get it
                    delay(500);
                    inString = myPort.readStringUntil('\n'); 
                    inString =  trim(inString);
                    pic_length = int(inString);
                    println("pic_length: "+pic_length);
                    if (pic_length == 0) {
                        system_state = 0;
                        break;
                    }
                    is_first_change_to_system_state_1 = 1;
                }else {
                    int[] dataBuffer = new int[128];
                    int sum = 0;

                    boolean numberEnoughFlag = true;
                    
                    for (int i = 0; i < 127; ++i) {
                        if (numberEnoughFlag) {
                            
                        
                            if (Get_Valid_Serial_Number() == false) {           //if get enough data from serial
                                numberEnoughFlag = false;
                            }

                            if (numberEnoughFlag) {
                                dataBuffer[i] = myPort.read();                  //get the data bytes from serial
                                sum += dataBuffer[i];
                                sum = sum % 0xFF;
                                //println("i = "+i+" , dataBuffer[i] = "+dataBuffer[i]);
                            }
                        }
                    }
                    if (numberEnoughFlag) {
                        
                        if (Get_Valid_Serial_Number() == false) {
                                numberEnoughFlag = false;
                        }
                        dataBuffer[127] = myPort.read();    //get the check byte

                    }


                    while ((sum != dataBuffer[127]) || (!numberEnoughFlag)) {   //if check byte is incorrect or not enough bytes received, get bytes again
                        myPort.write('0');                              //send '0' to tell the arduino something is wrong during communication

                        sum = 0;

                        numberEnoughFlag = true;

                        int falseNumber = 0;
                        for (int i = 0; i < 127; ++i) {
                            if (numberEnoughFlag) {
                                
                                if (Get_Valid_Serial_Number() == false) {
                                    numberEnoughFlag = false;
                                }

                                if (numberEnoughFlag) {
                                    
                                    dataBuffer[i] = myPort.read();
                                    
                                    sum += dataBuffer[i];
                                    sum = sum % 0xFF;
                                    
                                    falseNumber = i;
                                }
                            }
                        }

                        if (numberEnoughFlag) {
                            
                            if (Get_Valid_Serial_Number() == false) {
                                numberEnoughFlag = false;
                            }
                            dataBuffer[127] = myPort.read();
                        }

                        //println(dataBuffer); 

                    }



                    number_got_of_img_now += 127;
                    print('.');
           

                    if (number_got_of_img_now <= pic_length) {      //havn't got all the data
                        for (int i = 0; i < 127; ++i) {
                            try {                                            
                            output.write(dataBuffer[i]);

                            }   
                            catch (IOException e) {  
                                e.printStackTrace();  
                            }   

                        }

                            myPort.write('1');
                        
                    }else {                                         //finished the communicating, 
                        for (int i = 0; i < (127 + pic_length - number_got_of_img_now); ++i) { 
                            try {                                            
                            output.write(dataBuffer[i]);

                            }   
                            catch (IOException e) {  
                                e.printStackTrace();   
                            }  
                        }


                        try {   
                            output.flush(); // Writes the remaining data to the file   
                            output.close(); // Finishes the file  

                        }   

                        catch (IOException e) {  
                            e.printStackTrace();  
                        }  


                        img = loadImage("pic.jpg");             //show the image
                        image(img, 0, 0);
                        system_state = 0; 
                        myPort.write('1'); 
     
                        break;
                    }

                    // try {                                            //when get the data with wire, so there is no need of checking the communication.
                    // output.write(myPort.read());

                    // }   
                    // catch (IOException e) {  
                    //     e.printStackTrace();  
                    // }  


                    // number_got_of_img_now++;
                    // if (number_got_of_img_now == pic_length) {


                    //     try {   
                    //         output.flush(); // Writes the remaining data to the file     
                    //         output.close(); // Finishes the file  

                    //     }   

                    //     catch (IOException e) {  
                    //         e.printStackTrace();  
                    //     }  


                    //     img = loadImage("pic.jpg");
                    //     image(img, 0, 0);
                    //     system_state = 0;

                    //     break;
                    // }




                }
            }  
        


       

        }else {
            while (myPort.available() > 0) {    //system_state = 0, just print the data from serial
                print(myPort.readChar());
                
            }
        }


    }  

    /**
     * [Get_Valid_Serial_Number description] return false if there is still nothing from Serial after 100ms. or return true. in case of some bytes lost while communication,
     *                                       but the program is waiting all the time.
     */
    boolean Get_Valid_Serial_Number(){
        int waitingCount = 0; 
        while (myPort.available() <= 0) { 
            delay(1);
            if (waitingCount++ > 100) {
                return false;
            }

        }
        return true;
    }




    void keyPressed() {  
        if(key == 'a'){                                 //press a to get an image
            output = createOutput("pic.jpg"); 
            myPort.write('2');
            is_first_change_to_system_state_1 = 0;
            number_got_of_img_now = 0;

            system_state = 1;

            delay(5000); 
            while (myPort.available() > 0 ) {
                print(myPort.readChar());
            }
                

            myPort.write('2');  
            println("taking a photo");
        }
        if (key == '1') {                           //press 1 to pull up the solar battery
            myPort.write('2');
            delay(2000);
            while (myPort.available() > 0 ) {
                print(myPort.readChar());
            }

            myPort.write('3');

            println("taking up servo");
        }
        if (key == '2') {                          //press 2 to pull down the solar battery.
            myPort.write('2');
            delay(2000);
            while (myPort.available() > 0 ) {
                print(myPort.readChar());
            }

            myPort.write('4');

            println("taking down servo");
        }
        
        if (key == 'r'){                        //press r to return prograss of arduino, press it when you restart the program 
                                                //but Arduino is still trying to finish sending the jpg file data.
            

            myPort.write('3');
        
        
            system_state = 0;
        }
    }    

tip

如果你不是想做一个完全一样的小卫星的话，我觉得里面可以用的部分主要所有这些：

1. 带校验的无线串口传输，大量数据比如图片什么的在无线传输的时候回丢包什么的，所以加一个校验是很有必要的。
2. 通过串口传输图片，你懂的串口并不是很适合传输图片，即使是有线串口，大概也要几秒钟的样子，但是如果你不得不这样的话这里面的代码可以让你做到这样的事情。。