Cam_Viewer-test.ino

#define SSID_NAME "ESP32-CAM"

#define SSID_PASSWORD ""

#define URL "http://192.168.4.1/jpg"

//#define SSID_NAME "xxxxxxxx"

//#define SSID_PASSWORD "xxxxxxxx"

//#define URL "http://192.168.0.136/jpg"  // IP der Kamera anpassen als Sta

#include <WiFi.h>

#include <HTTPClient.h>

#include "TFT_eSPI.h"

#include <JPEGDecoder.h>

#define SD_CS 16

#define TFT_BL   13  // LED back-light

#define TOUCH_BUSY 27

#define TOUCH_IRQ  25

// Return the minimum of two values a and b

#define minimum(a,b)     (((a) < (b)) ? (a) : (b))

const int picBufferSize = 80*1024;

void *picBuffer = NULL;

TFT_eSPI tft = TFT_eSPI();

void setup()

{

  pinMode(TOUCH_BUSY,INPUT_PULLUP);

  pinMode(TOUCH_IRQ,INPUT_PULLUP);

  digitalWrite(TOUCH_CS, HIGH);                               // Touch controller chip select

  digitalWrite(TFT_CS, HIGH);                                 // TFT screen chip select 

  digitalWrite( SD_CS, HIGH);                                 // SD card chips select

  pinMode(SD_CS,OUTPUT);

  pinMode(TFT_BL,OUTPUT);                                     // Backlight an

  digitalWrite(TFT_BL,HIGH);

  Serial.begin(115200);

  Serial.println("\r\nReset");

  tft.begin();

  picBuffer = malloc(picBufferSize);        // Stream-File-Buffer

  WiFi.begin(SSID_NAME, SSID_PASSWORD);

}

void loop()

{

  Serial.print("WiFi connect");

  if (WiFi.status() != WL_CONNECTED)

  {

    // wait for WiFi connection

    delay(500);

  }

  else

  {

    Serial.println("OK");

    HTTPClient http;

    Serial.print("[HTTP] begin...\n");

    http.begin(URL);

    Serial.print("[HTTP] GET...\n");

    int httpCode = http.GET();

    Serial.printf("[HTTP] GET... code: %d\n", httpCode);

    // HTTP header has been send and Server response header has been handled

    if (httpCode <= 0)

    {

      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());

    }

    else

    {

      if (httpCode != HTTP_CODE_OK)

      {

        Serial.printf("[HTTP] Not OK!\n");

      }

      else

      {

        // get lenght of document (is -1 when Server sends no Content-Length header)

        int len = http.getSize();

        Serial.printf("[HTTP] size: %d\n", len);

        if (len <= 0)

        {

          Serial.printf("[HTTP] Unknow content size: %d\n", len);

        }

        else

        {

          // get tcp stream

          WiFiClient * stream = http.getStreamPtr();

          // read all data from server

          uint8_t* p = (uint8_t*) picBuffer;

          int l = len;

          while (http.connected() && (l > 0 || len == -1))

          {

            // get available data size

            size_t size = stream->available();

            if (size)

            {

              int c = stream->readBytes(p, size);

              p += size;

              Serial.printf("[HTTP] read: %d\n", c);

            }

          }

          Serial.println();

          Serial.print("[HTTP] connection closed.\n");

          drawArrayJpeg((uint8_t*) picBuffer, len, 0, 0);

        }

      }

    }

    http.end();

  }

}

//####################################################################################################

// Draw a JPEG on the TFT pulled from a program memory array

//####################################################################################################

void drawArrayJpeg(const uint8_t arrayname[], uint32_t array_size, int xpos, int ypos) {

  int x = xpos;

  int y = ypos;

  JpegDec.decodeArray(arrayname, array_size);

  jpegInfo(); // Print information from the JPEG file (could comment this line out)

  renderJPEG(x, y);

  Serial.println("#########################");

}

//####################################################################################################

// Draw a JPEG on the TFT, images will be cropped on the right/bottom sides if they do not fit

//####################################################################################################

// This function assumes xpos,ypos is a valid screen coordinate. For convenience images that do not

// fit totally on the screen are cropped to the nearest MCU size and may leave right/bottom borders.

void renderJPEG(int xpos, int ypos) {

  // retrieve infomration about the image

  uint16_t *pImg;

  uint16_t mcu_w = JpegDec.MCUWidth;

  uint16_t mcu_h = JpegDec.MCUHeight;

  uint32_t max_x = JpegDec.width;

  uint32_t max_y = JpegDec.height;

  // Jpeg images are draw as a set of image block (tiles) called Minimum Coding Units (MCUs)

  // Typically these MCUs are 16x16 pixel blocks

  // Determine the width and height of the right and bottom edge image blocks

  uint32_t min_w = minimum(mcu_w, max_x % mcu_w);

  uint32_t min_h = minimum(mcu_h, max_y % mcu_h);

  // save the current image block size

  uint32_t win_w = mcu_w;

  uint32_t win_h = mcu_h;

  // record the current time so we can measure how long it takes to draw an image

  uint32_t drawTime = millis();

  // save the coordinate of the right and bottom edges to assist image cropping

  // to the screen size

  max_x += xpos;

  max_y += ypos;

  // read each MCU block until there are no more

  while (JpegDec.read()) {

    // save a pointer to the image block

    pImg = JpegDec.pImage ;

    // calculate where the image block should be drawn on the screen

    int mcu_x = JpegDec.MCUx * mcu_w + xpos;  // Calculate coordinates of top left corner of current MCU

    int mcu_y = JpegDec.MCUy * mcu_h + ypos;

    // check if the image block size needs to be changed for the right edge

    if (mcu_x + mcu_w <= max_x) win_w = mcu_w;

    else win_w = min_w;

    // check if the image block size needs to be changed for the bottom edge

    if (mcu_y + mcu_h <= max_y) win_h = mcu_h;

    else win_h = min_h;

    // copy pixels into a contiguous block

    if (win_w != mcu_w)

    {

      uint16_t *cImg;

      int p = 0;

      cImg = pImg + win_w;

      for (int h = 1; h < win_h; h++)

      {

        p += mcu_w;

        for (int w = 0; w < win_w; w++)

        {

          *cImg = *(pImg + w + p);

          cImg++;

        }

      }

    }

    // calculate how many pixels must be drawn

    uint32_t mcu_pixels = win_w * win_h;

    // draw image MCU block only if it will fit on the screen

    if (( mcu_x + win_w ) <= tft.width() && ( mcu_y + win_h ) <= tft.height())

    {

      // Now set a MCU bounding window on the TFT to push pixels into (x, y, x + width - 1, y + height - 1)

      tft.setWindow(mcu_x, mcu_y, mcu_x + win_w - 1, mcu_y + win_h - 1);

      // Write all MCU pixels to the TFT window

      while (mcu_pixels--) {

        // Push each pixel to the TFT MCU area

        tft.pushColor(*pImg++);

      }

    }

    else if ( (mcu_y + win_h) >= tft.height()) JpegDec.abort(); // Image has run off bottom of screen so abort decoding

  }

  // calculate how long it took to draw the image

  drawTime = millis() - drawTime;

  // print the results to the serial port

  Serial.print(F(  "Total render time was    : ")); Serial.print(drawTime); Serial.println(F(" ms"));

  Serial.println(F(""));

}

//####################################################################################################

// Print image information to the serial port (optional)

//####################################################################################################

void jpegInfo() {

  Serial.println(F("==============="));

  Serial.println(F("JPEG image info"));

  Serial.println(F("==============="));

  Serial.print(F(  "Width      :")); Serial.println(JpegDec.width);

  Serial.print(F(  "Height     :")); Serial.println(JpegDec.height);

  Serial.print(F(  "Components :")); Serial.println(JpegDec.comps);

  Serial.print(F(  "MCU / row  :")); Serial.println(JpegDec.MCUSPerRow);

  Serial.print(F(  "MCU / col  :")); Serial.println(JpegDec.MCUSPerCol);

  Serial.print(F(  "Scan type  :")); Serial.println(JpegDec.scanType);

  Serial.print(F(  "MCU width  :")); Serial.println(JpegDec.MCUWidth);

  Serial.print(F(  "MCU height :")); Serial.println(JpegDec.MCUHeight);

  Serial.println(F("==============="));

}

//####################################################################################################

// Show the execution time (optional)

//####################################################################################################

// WARNING: for UNO/AVR legacy reasons printing text to the screen with the Mega might not work for

// sketch sizes greater than ~70KBytes because 16 bit address pointers are used in some libraries.

// The Due will work fine with the HX8357_Due library.

void showTime(uint32_t msTime) {

  //tft.setCursor(0, 0);

  //tft.setTextFont(1);

  //tft.setTextSize(2);

  //tft.setTextColor(TFT_WHITE, TFT_BLACK);

  //tft.print(F(" JPEG drawn in "));

  //tft.print(msTime);

  //tft.println(F(" ms "));

  Serial.print(F(" JPEG drawn in "));

  Serial.print(msTime);

  Serial.println(F(" ms "));

}