До сих пор разбираюсь с передачей через HTTP POST (ESP32)

if (camClient.connect(postHost, postHttpPort))
    {
      uint8_t num = 12;
      String stringOne, stringTwo;
      String image = String();
      stringOne = String("id=7292&num=");
      stringTwo = String("&image=");
      image = stringOne + num + stringTwo;
      String base64image = base64::encode(fb->buf, fb->len);
      int Lenght = base64image.length() + image.length();
 
      //Serial.println("connection");
      camClient.println("POST /test/image/post.php HTTP/1.0");
      camClient.println("Host: cloud.server.com");
      camClient.println("Accept: */*");
      camClient.println("User-Agent: Mozilla/5.0");
      camClient.println("Content-Length: " + Lenght);
      camClient.println("Content-Type: image/jpeg " );
      camClient.println();
 
 
      camClient.write((image + base64image).c_str());
      
      while (camClient.available())
      {
        String line = camClient.readStringUntil('\r');
        Serial.print(line);
      }
      camClient.stop();
    }
    else {
      // если не подключился к серверу:
      Serial.println("connection failed");
    }

 camClient.println("Content-Type: image/jpeg " );

 camClient.println("Content-Type: application/x-www-form-urlencoded" );

Serial.println("--------------");
Serial.println(base64image.length());
Serial.println(image.length());
Serial.println(Lenght);
Serial.println((image + base64image).c_str());
Serial.println("--------------");

#include "WiFi.h"
#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <StringArray.h>
#include <SPIFFS.h>
 
#include <base64.h>
#include <libb64/cencode.h>
 
// Replace with your network credentials
const char* ssid = "ssid";
const char* password = "password";
const char* postHost = "cloud.server.com";
const int postHttpPort = 80;
WiFiClient camClient;
 
 
#define SLEEP_DELAY 10000 //Delay ofr 10 Sec
#define FILE_PHOTO "/photo.jpg"
#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  10
RTC_DATA_ATTR int bootCount = 0;
// OV2640 camera module pins (CAMERA_MODEL_AI_THINKER)
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    15
#define XCLK_GPIO_NUM     27
#define SIOD_GPIO_NUM     22
#define SIOC_GPIO_NUM     23
 
#define Y9_GPIO_NUM       19
#define Y8_GPIO_NUM       36
#define Y7_GPIO_NUM       18
#define Y6_GPIO_NUM       39
#define Y5_GPIO_NUM        5
#define Y4_GPIO_NUM       34
#define Y3_GPIO_NUM       35
#define Y2_GPIO_NUM       32
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     26
#define PCLK_GPIO_NUM     21
 
 
 
void setup_camera() {
  // Turn-off the 'brownout detector'
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
 
  // OV2640 camera module
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
 
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 10;
    config.fb_count = 1;
  }
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    ESP.restart();
  }
}
 
bool checkPhoto( fs::FS & fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}
 
// Capture Photo and Save it to SPIFFS
void capturePhoto( void ) {
 
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0; // Boolean indicating if the picture has been taken correctly
 
  // Take a photo with the camera
  Serial.println("Taking a photo...");
 
  fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Camera capture failed");
    return;
  }
 
  do {
 
    Serial.printf("Picture file name: %s\n", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);
 
    // Insert the data in the photo file
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
 
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    file.close();
    esp_camera_fb_return(fb);
    ok = checkPhoto(SPIFFS);
 
 
    if (camClient.connect(postHost, postHttpPort))
    {
      uint8_t num = 12;
      String stringOne, stringTwo;
      String image = String();
      stringOne = String("id=7292&num=");
      stringTwo = String("&image=");
      image = stringOne + num + stringTwo;
      String base64image = base64::encode(fb->buf, fb->len);
      int Lenght = base64image.length() + image.length();
 
      //Serial.println("connection");
      camClient.println("POST /test/image/post.php HTTP/1.0");
      camClient.println("Host: cloud.server.com");
      camClient.println("Accept: */*");
      camClient.println("User-Agent: Mozilla/5.0");
      camClient.println("Content-Length: " + Lenght);
      camClient.println("Content-Type: application/x-www-form-urlencoded" );
      camClient.println();
 
      //Serial.println("--------------");
      //Serial.println(base64image.length());
      //Serial.println(image.length());
      //Serial.println(Lenght);
      //Serial.println((image + base64image).c_str());
      //Serial.println("--------------");
 
      camClient.write((image + base64image).c_str());
      
      while (camClient.available())
      {
        String line = camClient.readStringUntil('\r');
        Serial.print(line);
      }
      camClient.stop();
    }
    else {
      // if you didn't get a connection to the server:
      Serial.println("connection failed");
    }
 
  } while ( !ok );
}
 
void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  WiFi.begin(ssid, password);
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
 
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.print("IP address : ");
  Serial.println(WiFi.localIP());
 
  //SPIFFS
  if (!SPIFFS.begin(true)) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS mounted successfully");
  }
}
 
 
// initialize digital pin LED_BUILTIN as an output.
// Wait for a second
void setup() {
 
  Serial.begin(115200);
 
  ++bootCount;
 
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
                 " Seconds");
 
 
  setup_camera();
  setup_wifi();
 
}
 
// the loop function runs over and over again forever
void loop() {
 
 
  Serial.println("PSRAM found: " + String(psramFound()));
  // wait for a second
  capturePhoto();
  Serial.println("Boot number: " + String(bootCount));
  delay(SLEEP_DELAY);
  esp_deep_sleep_start();
}