M5CameraをSTAモードで起動して固定IPにする手順.md

M5CameraをSTAモードで起動して固定IPにする手順.md

• 

参考

• https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html
• http://mag.switch-science.com/2018/12/21/m5camera-test/
• https://github.com/nkolban/esp32-snippets/blob/master/wifi/fragments/connect_with_static_ip.c

ESP-IDFのセットアップ手順 (Windows編)

参考 : Standard Setup of Toolchain for Windows — ESP-IDF Programming Guide v3.3-beta1-223-ga62cbfe documentation

ESP-IDF用MSYS設定手順

• esp32_win32_msys2_environment_and_toolchain-20181001.zipをダウンロード
• zipを解凍して、c:\msys32\へ配置
• c:\msys32\mingw32.exeを起動。ターミナルが起動する。
• "pacman -S vim" を実行

ESP-IDFのセットアップ手順。MSYS環境から次のコマンドを実行する

$ mkdir -p ~/esp
$ cd ~/esp/
$ git clone --recursive https://github.com/espressif/esp-idf.git


※環境変数の設定
$ vi ~/.bashrc
※ 「export IDF_PATH=~/esp/esp-idf/」を設定しておく
$ source ~/.bashrc


※pyhtonに必要なモジュールをインストールしておく
$ python2.7 -m pip install --user -r $IDF_PATH/requirements.txt

M5Cameraのファームのバックアップ

esptools.pyを使ってバックアップする。例はCOM4にM5Cameraが接続されている場合の例

$ python $IDF_PATH/components/esptool_py/esptool/esptool.py  --chip esp32 --port COM4 --baud 921600 read_flash 0x0000 4194304 ~/esp32-original-backup.bin
※ MSYS環境の場合、COM?でポートを指定する必要あり。/dev/ttyS?で指定すると実行に失敗する…

書き戻す場合は次のコマンドを実行

$ python $IDF_PATH/components/esptool_py/esptool/esptool.py --chip esp32 --port COM4 --baud 921600 write_flash 0 ~/esp32-original-backup.bin

m5stack-cam-psramをビルドしてみる

MSYS環境から次のコマンドを実行してソースコードをcloneする

$ cd ~/esp/
$ git clone https://github.com/m5stack/m5stack-cam-psram.git
$ cd m5stack-cam-psram

1/17現在、店頭で販売されているM5Cameraに対応するためにはピンアサインの修正が必要。 main/main.cを次のように修正する。

$ diff -u main/main.c.org main/main.c
--- main/main.c.org     2019-01-17 21:14:16.485605000 +0900
+++ main/main.c         2019-01-17 21:45:21.789814800 +0900
@@ -20,7 +20,7 @@
 //M5STACK_CAM PIN Map
 #define CAM_PIN_RESET   15 //software reset will be performed
 #define CAM_PIN_XCLK    27
-#define CAM_PIN_SIOD    25
+#define CAM_PIN_SIOD    22
 #define CAM_PIN_SIOC    23

 #define CAM_PIN_D7      19
@@ -32,7 +32,7 @@
 #define CAM_PIN_D1      35
 #define CAM_PIN_D0      32

-#define CAM_PIN_VSYNC   22
+#define CAM_PIN_VSYNC   25
 #define CAM_PIN_HREF    26
 #define CAM_PIN_PCLK    21

次の手順でビルドする

$ make menuconfig
※"Serial flasher config"→"Default serial port"から書き込みに使用するシリアルポートを設定しておく
※設定をsaveしてmenuconfigを抜ける
$ make

ビルドが終わったら、PCにM5Cameraを接続し、"make flash"コマンドを実行して書き込みする。

$ make flash

モニタを起動してみる

ソースコード中にあるESP_LOGI(...)で出力されるメッセージは、PCにM5Cameraを接続している状態でモニタを起動すると見ることができる。

$ make monitor

モニタ実行中のキーバインドは次の通り。(一部抜粋)

ctrl+]           モニタの終了
ctrl+T, ctrl+H   ヘルプの表示
ctrl+T, ctrl+R   リセット
ctrl+T, ctrl+P   出力の一時停止 (…というよりか、bootloaderへ落ちるコマンド)
ctrl+T, ctrl+Y   出力のON/OFF切り替え

モニタの詳細については、以下URLを参照。

• https://docs.espressif.com/projects/esp-idf/en/latest/get-started/idf-monitor.html

STAモードで起動して固定IPにする手順

次のようにmain/main.cを修正する。

$ diff -u main/main.c.org main/main.c
--- main/main.c.org     2019-01-17 21:45:21.789814800 +0900
+++ main/main.c 2019-01-17 22:06:08.603979600 +0900
@@ -15,6 +15,8 @@
 #include "esp_event_loop.h"
 #include "esp_http_server.h"

+#include <lwip/sockets.h>
+
 static const char* TAG = "camera";

 //M5STACK_CAM PIN Map
@@ -40,10 +42,14 @@

 #define CAM_USE_WIFI

-#define ESP_WIFI_SSID "m5stack-cam"
-#define ESP_WIFI_PASS ""
+#define ESP_WIFI_SSID "ssid"
+#define ESP_WIFI_PASS "passowrd"
 #define MAX_STA_CONN  1

+#define DEVICE_IP          "192.168.1.123"
+#define DEVICE_GW          "192.168.1.1"
+#define DEVICE_NETMASK     "255.255.255.0"
+
 #define PART_BOUNDARY "123456789000000000000987654321"
 static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
 static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
@@ -233,19 +239,8 @@
       esp_wifi_connect();
       break;
     case SYSTEM_EVENT_STA_GOT_IP:
-      ESP_LOGI(TAG, "got ip:%s", ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));
-      s_ip_addr = event->event_info.got_ip.ip_info.ip;
-      xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);
-      break;
-    case SYSTEM_EVENT_AP_STACONNECTED:
-      ESP_LOGI(TAG, "station:" MACSTR " join, AID=%d", MAC2STR(event->event_info.sta_connected.mac)                                                           ,
-               event->event_info.sta_connected.aid);
       xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);
-      break;
-    case SYSTEM_EVENT_AP_STADISCONNECTED:
-      ESP_LOGI(TAG, "station:" MACSTR "leave, AID=%d", MAC2STR(event->event_info.sta_disconnected.m                                                           ac),
-               event->event_info.sta_disconnected.aid);
-      xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);
+      s_ip_addr = event->event_info.got_ip.ip_info.ip;
       break;
     case SYSTEM_EVENT_STA_DISCONNECTED:
       esp_wifi_connect();
@@ -262,30 +257,36 @@
   s_wifi_event_group = xEventGroupCreate();

   tcpip_adapter_init();
+  tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
+  tcpip_adapter_ip_info_t ipInfo;
+
+  inet_pton(AF_INET, DEVICE_IP, &ipInfo.ip);
+  inet_pton(AF_INET, DEVICE_GW, &ipInfo.gw);
+  inet_pton(AF_INET, DEVICE_NETMASK, &ipInfo.netmask);
+  tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &ipInfo);
+
+  s_wifi_event_group = xEventGroupCreate();
+
   ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));

   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
   ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+  ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
+
   wifi_config_t wifi_config = {
-      .ap = {.ssid = ESP_WIFI_SSID,
-             .ssid_len = strlen(ESP_WIFI_SSID),
+      .sta = {.ssid = ESP_WIFI_SSID,
              .password = ESP_WIFI_PASS,
-             .max_connection = MAX_STA_CONN,
-             .authmode = WIFI_AUTH_WPA_WPA2_PSK},
+      },
   };
-  if (strlen(ESP_WIFI_PASS) == 0) {
-    wifi_config.ap.authmode = WIFI_AUTH_OPEN;
-  }

-  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
-  ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
+  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+  ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
   ESP_ERROR_CHECK(esp_wifi_start());
+  ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));

-  uint8_t addr[4] = {192, 168, 4, 1};
-  s_ip_addr = *(ip4_addr_t*)&addr;
-
-  ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s",
-           ESP_WIFI_SSID, ESP_WIFI_PASS);
+  ESP_LOGI(TAG, "Connecting to \"%s\"", wifi_config.sta.ssid);
+  xEventGroupWaitBits(s_wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
+  ESP_LOGI(TAG, "Connected");
 }

main.c

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/semphr.h"
#include "freertos/task.h"

#include "driver/gpio.h"
#include "sdkconfig.h"
#include "esp_log.h"

#include "esp_wifi.h"
#include "nvs_flash.h"
#include "esp_timer.h"
#include "esp_camera.h"
#include "esp_event_loop.h"
#include "esp_http_server.h"

#include <lwip/sockets.h>

static const char* TAG = "camera";

//M5STACK_CAM PIN Map
#define CAM_PIN_RESET   15 //software reset will be performed
#define CAM_PIN_XCLK    27
#define CAM_PIN_SIOD    22
#define CAM_PIN_SIOC    23

#define CAM_PIN_D7      19
#define CAM_PIN_D6      36
#define CAM_PIN_D5      18
#define CAM_PIN_D4      39
#define CAM_PIN_D3      5
#define CAM_PIN_D2      34
#define CAM_PIN_D1      35
#define CAM_PIN_D0      32

#define CAM_PIN_VSYNC   25
#define CAM_PIN_HREF    26
#define CAM_PIN_PCLK    21

#define CAM_XCLK_FREQ   20000000

#define CAM_USE_WIFI

#define ESP_WIFI_SSID "ssid"
#define ESP_WIFI_PASS "password"
#define MAX_STA_CONN  1

#define DEVICE_IP          "192.168.1.123"
#define DEVICE_GW          "192.168.1.1"
#define DEVICE_NETMASK     "255.255.255.0"

#define PART_BOUNDARY "123456789000000000000987654321"
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

static EventGroupHandle_t s_wifi_event_group;
static ip4_addr_t s_ip_addr;
const int CONNECTED_BIT = BIT0;

static camera_config_t camera_config = {
    .pin_reset = CAM_PIN_RESET,
    .pin_xclk = CAM_PIN_XCLK,
    .pin_sscb_sda = CAM_PIN_SIOD,
    .pin_sscb_scl = CAM_PIN_SIOC,

    .pin_d7 = CAM_PIN_D7,
    .pin_d6 = CAM_PIN_D6,
    .pin_d5 = CAM_PIN_D5,
    .pin_d4 = CAM_PIN_D4,
    .pin_d3 = CAM_PIN_D3,
    .pin_d2 = CAM_PIN_D2,
    .pin_d1 = CAM_PIN_D1,
    .pin_d0 = CAM_PIN_D0,
    .pin_vsync = CAM_PIN_VSYNC,
    .pin_href = CAM_PIN_HREF,
    .pin_pclk = CAM_PIN_PCLK,

    //XCLK 20MHz or 10MHz
    .xclk_freq_hz = CAM_XCLK_FREQ,
    .ledc_timer = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,

    .pixel_format = PIXFORMAT_JPEG,//YUV422,GRAYSCALE,RGB565,JPEG
    .frame_size = FRAMESIZE_QVGA,//QQVGA-UXGA Do not use sizes above QVGA when not JPEG

    .jpeg_quality = 2, //0-63 lower number means higher quality
    .fb_count = 3 //if more than one, i2s runs in continuous mode. Use only with JPEG
};

static void wifi_init_softap();
static esp_err_t http_server_init();

void app_main()
{
    esp_log_level_set("wifi", ESP_LOG_INFO);
    
    esp_err_t err = nvs_flash_init();
    if (err != ESP_OK) {
        ESP_ERROR_CHECK( nvs_flash_erase() );
        ESP_ERROR_CHECK( nvs_flash_init() );
    }

    err = esp_camera_init(&camera_config);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Camera Init Failed");
    }
    
    wifi_init_softap();

    vTaskDelay(100 / portTICK_PERIOD_MS);
    http_server_init();
}

#ifdef CAM_USE_WIFI

esp_err_t jpg_httpd_handler(httpd_req_t *req){
    camera_fb_t * fb = NULL;
    esp_err_t res = ESP_OK;
    size_t fb_len = 0;
    int64_t fr_start = esp_timer_get_time();

    fb = esp_camera_fb_get();
    if (!fb) {
        ESP_LOGE(TAG, "Camera capture failed");
        httpd_resp_send_500(req);
        return ESP_FAIL;
    }
    res = httpd_resp_set_type(req, "image/jpeg");
    if(res == ESP_OK){
        res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
    }

    if(res == ESP_OK){
        fb_len = fb->len;
        res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
    }
    esp_camera_fb_return(fb);
    int64_t fr_end = esp_timer_get_time();
    ESP_LOGI(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
    return res;
}

esp_err_t jpg_stream_httpd_handler(httpd_req_t *req){
    camera_fb_t * fb = NULL;
    esp_err_t res = ESP_OK;
    size_t _jpg_buf_len;
    uint8_t * _jpg_buf;
    char * part_buf[64];
    static int64_t last_frame = 0;
    if(!last_frame) {
        last_frame = esp_timer_get_time();
    }

    res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
    if(res != ESP_OK){
        return res;
    }

    while(true){
        fb = esp_camera_fb_get();
        if (!fb) {
            ESP_LOGE(TAG, "Camera capture failed");
            res = ESP_FAIL;
        } else {
            if(fb->format != PIXFORMAT_JPEG){
                bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
                if(!jpeg_converted){
                    ESP_LOGE(TAG, "JPEG compression failed");
                    esp_camera_fb_return(fb);
                    res = ESP_FAIL;
                }
            } else {
                _jpg_buf_len = fb->len;
                _jpg_buf = fb->buf;
            }
        }
        if(res == ESP_OK){
            size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);

            res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
        }
        if(res == ESP_OK){
            res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
        }
        if(res == ESP_OK){
            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
        }
        if(fb->format != PIXFORMAT_JPEG){
            free(_jpg_buf);
        }
        esp_camera_fb_return(fb);
        if(res != ESP_OK){
            break;
        }
        int64_t fr_end = esp_timer_get_time();
        int64_t frame_time = fr_end - last_frame;
        last_frame = fr_end;
        frame_time /= 1000;
        ESP_LOGI(TAG, "MJPG: %uKB %ums (%.1ffps)",
            (uint32_t)(_jpg_buf_len/1024),
            (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
    }

    last_frame = 0;
    return res;
}

static esp_err_t http_server_init(){
    httpd_handle_t server;
    httpd_uri_t jpeg_uri = {
        .uri = "/jpg",
        .method = HTTP_GET,
        .handler = jpg_httpd_handler,
        .user_ctx = NULL
    };

    httpd_uri_t jpeg_stream_uri = {
        .uri = "/",
        .method = HTTP_GET,
        .handler = jpg_stream_httpd_handler,
        .user_ctx = NULL
    };

    httpd_config_t http_options = HTTPD_DEFAULT_CONFIG();

    ESP_ERROR_CHECK(httpd_start(&server, &http_options));
    ESP_ERROR_CHECK(httpd_register_uri_handler(server, &jpeg_uri));
    ESP_ERROR_CHECK(httpd_register_uri_handler(server, &jpeg_stream_uri));

    return ESP_OK;
}

static esp_err_t event_handler(void* ctx, system_event_t* event) 
{
  switch (event->event_id) {
    case SYSTEM_EVENT_STA_START:
      esp_wifi_connect();
      break;
    case SYSTEM_EVENT_STA_GOT_IP:
      xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT);
      s_ip_addr = event->event_info.got_ip.ip_info.ip;
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      esp_wifi_connect();
      xEventGroupClearBits(s_wifi_event_group, CONNECTED_BIT);
      break;
    default:
      break;
  }
  return ESP_OK;
}

static void wifi_init_softap() 
{
  s_wifi_event_group = xEventGroupCreate();

  tcpip_adapter_init();
  tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
  tcpip_adapter_ip_info_t ipInfo;

  inet_pton(AF_INET, DEVICE_IP, &ipInfo.ip);
  inet_pton(AF_INET, DEVICE_GW, &ipInfo.gw);
  inet_pton(AF_INET, DEVICE_NETMASK, &ipInfo.netmask);
  tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &ipInfo);

  s_wifi_event_group = xEventGroupCreate();

  ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));

  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ESP_ERROR_CHECK(esp_wifi_init(&cfg));
  ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));

  wifi_config_t wifi_config = {
      .sta = {.ssid = ESP_WIFI_SSID,
             .password = ESP_WIFI_PASS,
      },
  };

  ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
  ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
  ESP_ERROR_CHECK(esp_wifi_start());
  ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));

  ESP_LOGI(TAG, "Connecting to \"%s\"", wifi_config.sta.ssid);
  xEventGroupWaitBits(s_wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY);
  ESP_LOGI(TAG, "Connected");
}

#endif