设为首页收藏本站
首页 > 论坛 > 树莓派

[项目]用树莓派PICO制作一个FPV小车

豆爸 | 高级技师 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2024-1-8 15:37:57 [显示全部楼层]
7401浏览
0回复
0收藏
查看: 7401|回复: 0

[项目] 用树莓派PICO制作一个FPV小车

[复制链接]
本帖最后由 豆爸 于 2024-1-10 15:17 编辑

作品介绍：


本作品使用树莓派Pico实现一个小车。


功能介绍：
  
基础功能：实现小车的进行、后退、停止、左转、右转的控制。
  
  拓展功能：手机APP控制、FPV、视觉控制等。


设计思路：


基础功能：通过Raspberry Pi Pico + 悟空2040树莓派扩展板，通过实现microblocks编程实现。
  
  基础功能：由于Raspberry Pi Pico不支持wifi，为了实现无线控制，需要增加支持wifi的模块，鉴于视觉的考虑，可以增加一块ESP32-S3，来实现APP控制、FPV等功能。


器材清单：

  基础功能：

  • 悟空2040树莓派扩展板WuKong2040 * 1块
  • N20电机 * 4个
  • 43MM轮子 * 4个

  拓展功能：

  • ESP32-S3
  • OV2640摄像头模块

制作过程（基础功能部分）：

   1、嘉立创EDA绘制小车底板
   用树莓派PICO制作一个FPV小车图1


用树莓派PICO制作一个FPV小车图2



  2、PCB打样


用树莓派PICO制作一个FPV小车图3



3、安装电机，焊接电机线


用树莓派PICO制作一个FPV小车图4


  4、悟空2040树莓派扩展板安装

用树莓派PICO制作一个FPV小车图5






5、最终合体

用树莓派PICO制作一个FPV小车图6


编写程序（基础功能部分）：

https://microblocks.fun/run/microblocks.html

  编程这里使用了microblocks，这里使用了悟空扩展板WUKong2040扩展库。

用树莓派PICO制作一个FPV小车图7



  基本的小车运行的程序，如下图所示


用树莓派PICO制作一个FPV小车图8



拓展功能：

   1、接线图


用树莓派PICO制作一个FPV小车图9


树莓派Pico                         ESP32

TX   GPIO0   ——————   U0R   IO13

RX   GPIO1   ——————   U0T  IO12

  GND   ——————   GND



     2、树莓派Pico端程序：



用树莓派PICO制作一个FPV小车图10



     3、ESP32-S3端程序：

    1）主程序FPVCar.ino


  1. #include "esp_camera.h"

  2. #include <WiFi.h>

  3. #include <ArduinoOTA.h>

  4. #include <ESP32Servo.h>

  5. // #include <EEPROM.h>

  6. 

  7. // #define  EEPROM_speed 2   //地址范围0-4095

  8. // #define  EEPROM_Size 1024  //开辟1024个位空间

  9. 

  10. /* Wifi Crdentials */

  11. // String sta_ssid = "MKMK";     // set Wifi network you want to connect to

  12. // String sta_password = "MAKRMAKER";   // set password for Wifi network

  13. 

  14. /* define CAMERA_MODEL_AI_THINKER */

  15. #define PWDN_GPIO_NUM     32

  16. #define RESET_GPIO_NUM    -1

  17. #define XCLK_GPIO_NUM      0

  18. #define SIOD_GPIO_NUM     26

  19. #define SIOC_GPIO_NUM     27

  20. #define Y9_GPIO_NUM       35

  21. #define Y8_GPIO_NUM       34

  22. #define Y7_GPIO_NUM       39

  23. #define Y6_GPIO_NUM       36

  24. #define Y5_GPIO_NUM       21

  25. #define Y4_GPIO_NUM       19

  26. #define Y3_GPIO_NUM       18

  27. #define Y2_GPIO_NUM        5

  28. #define VSYNC_GPIO_NUM    25

  29. #define HREF_GPIO_NUM     23

  30. #define PCLK_GPIO_NUM     22

  31. 

  32. /* Defining motor and servo pins */

  33. extern int DRV_A = 2;

  34. extern int DRV_B = 13;

  35. extern int DIR_A = 14;

  36. extern int DIR_B = 15;

  37. 

  38. extern int ledVal = 20;  // setting bright of flash LED 0-255

  39. 

  40. extern int ledPin = 4;  // set digital pin GPIO4 as LED pin (use biult-in LED)

  41. // extern int buzzerPin = 2;  // set digital pin GPIO2 as LED pin (use Active Buzzer)

  42. // extern int servoPin = 12;  // set digital pin GPIO2 as servo pin (use SG90)

  43. extern int  servoPin = 12;

  44. Servo myservo; 

  45. // int EEPROM_dataT;

  46. 

  47. 

  48. unsigned long previousMillis = 0;

  49. 

  50. 

  51. int speed1=255;//右边

  52. int speed2=255;

  53. void startCameraServer();

  54. 

  55. void initServo() {

  56.   myservo.attach(12,500,2500);

  57. 

  58.   myservo.write(90);

  59.   delay(100);

  60.   digitalWrite(servoPin, LOW);

  61. 

  62. 

  63. }

  64. 

  65. void initLed() {

  66.   ledcSetup(7, 5000, 8); /* 5000 hz PWM, 8-bit resolution and range from 0 to 255 */

  67.   ledcAttachPin(ledPin, 7);

  68. }

  69. 

  70. void setup() {

  71.   Serial.begin(115200);         // set up seriamonitor at 115200 bps

  72.   Serial.setDebugOutput(true);

  73.   Serial.println();

  74.   Serial.println("*ESP32 Camera Remote Control - L293D Bluino Shield*");

  75.   Serial.println("--------------------------------------------------------");

  76. 

  77.   Serial1.begin(9600, SERIAL_8N1, 12, 13); // 初始化 UART1，波特率为 115200，TX 引脚为 GPIO12，RX 引脚为 GPIO13

  78. 

  79.   // Set all the motor control pin to Output

  80.   pinMode(DRV_A, OUTPUT);

  81.   pinMode(DRV_B, OUTPUT);

  82.   pinMode(DIR_A, OUTPUT);

  83.   pinMode(DIR_B, OUTPUT);

  84.   

  85.   pinMode(ledPin, OUTPUT); // set the LED pin as an Output

  86.   // pinMode(buzzerPin, OUTPUT); // set the buzzer pin as an Output

  87.   pinMode(servoPin, OUTPUT); // set the servo pin as an Output

  88. 

  89.   // Initial state - turn off motors, LED & buzzer

  90.   // digitalWrite(DRV_A, LOW);

  91.   // digitalWrite(DRV_B, LOW);

  92.   // digitalWrite(DIR_A, LOW);

  93.   // digitalWrite(DIR_B, LOW);

  94. 

  95.   analogWrite(DRV_A, 0);

  96.   analogWrite(DRV_B, 0);

  97.   analogWrite(DIR_A, 0);

  98.   analogWrite(DIR_B, 0);

  99.   digitalWrite(ledPin, LOW);

  100.   // digitalWrite(buzzerPin, LOW);

  101.   digitalWrite(servoPin, LOW);

  102.   myservo.setPeriodHertz(50);// Standard 50hz servo

  103.   myservo.attach(servoPin, 500, 2400); 

  104.   /* Initializing Servo and LED */

  105.   initServo();

  106.   initLed();

  107.   

  108.   camera_config_t config;

  109.   config.ledc_channel = LEDC_CHANNEL_0;

  110.   config.ledc_timer = LEDC_TIMER_0;

  111.   config.pin_d0 = Y2_GPIO_NUM;

  112.   config.pin_d1 = Y3_GPIO_NUM;

  113.   config.pin_d2 = Y4_GPIO_NUM;

  114.   config.pin_d3 = Y5_GPIO_NUM;

  115.   config.pin_d4 = Y6_GPIO_NUM;

  116.   config.pin_d5 = Y7_GPIO_NUM;

  117.   config.pin_d6 = Y8_GPIO_NUM;

  118.   config.pin_d7 = Y9_GPIO_NUM;

  119.   config.pin_xclk = XCLK_GPIO_NUM;

  120.   config.pin_pclk = PCLK_GPIO_NUM;

  121.   config.pin_vsync = VSYNC_GPIO_NUM;

  122.   config.pin_href = HREF_GPIO_NUM;

  123.   config.pin_sscb_sda = SIOD_GPIO_NUM;

  124.   config.pin_sscb_scl = SIOC_GPIO_NUM;

  125.   config.pin_pwdn = PWDN_GPIO_NUM;

  126.   config.pin_reset = RESET_GPIO_NUM;

  127.   config.xclk_freq_hz = 20000000;

  128.   config.pixel_format = PIXFORMAT_JPEG;

  129.   //init with high specs to pre-allocate larger buffers

  130.   if(psramFound()){

  131.     config.frame_size = FRAMESIZE_UXGA;

  132.     config.jpeg_quality = 10;

  133.     config.fb_count = 2;

  134.   } else {

  135.     config.frame_size = FRAMESIZE_SVGA;

  136.     config.jpeg_quality = 10;

  137.     config.fb_count = 1;

  138.   }

  139. 

  140.   // camera init

  141.   esp_err_t err = esp_camera_init(&config);

  142.   if (err != ESP_OK) {

  143.     Serial.printf("Camera init failed with error 0x%x", err);

  144.     return;

  145.   }

  146. 

  147.   //drop down frame size for higher initial frame rate

  148.   sensor_t * s = esp_camera_sensor_get();

  149.   s->set_framesize(s, FRAMESIZE_QVGA);

  150. 

  151.   // Set NodeMCU Wifi hostname based on chip mac address

  152.   char chip_id[15];

  153.   snprintf(chip_id, 15, "%04X", (uint16_t)(ESP.getEfuseMac()>>32));

  154.   String hostname = "esp32cam-" + String(chip_id);

  155. 

  156.   Serial.println();

  157.   Serial.println("Hostname: "+hostname);

  158. 

  159.   // first, set NodeMCU as STA mode to connect with a Wifi network

  160.   // WiFi.mode(WIFI_STA);

  161.   // WiFi.begin(sta_ssid.c_str(), sta_password.c_str());

  162.   // Serial.println("");

  163.   // Serial.print("Connecting to: ");

  164.   // Serial.println(sta_ssid);

  165.   // Serial.print("Password: ");

  166.   // Serial.println(sta_password);

  167. 

  168.   // // try to connect with Wifi network about 10 seconds

  169.   // unsigned long currentMillis = millis();

  170.   // previousMillis = currentMillis;

  171.   // while (WiFi.status() != WL_CONNECTED && currentMillis - previousMillis <= 10000) {

  172.   //   delay(500);

  173.   //   Serial.print(".");

  174.   //   currentMillis = millis();

  175.   // }

  176. 

  177.   // if failed to connect with Wifi network set NodeMCU as AP mode

  178.   IPAddress myIP;

  179.   // if (WiFi.status() == WL_CONNECTED) {

  180.   //   Serial.println("");

  181.   //   Serial.println("*WiFi-STA-Mode*");

  182.   //   Serial.print("IP: ");

  183.   //   myIP=WiFi.localIP();

  184.   //   Serial.println(myIP);

  185.   //   delay(2000);

  186.   // } else {

  187.   WiFi.mode(WIFI_AP);

  188.   WiFi.softAP(hostname.c_str());

  189.   myIP = WiFi.softAPIP();

  190.   Serial.println("");

  191.   // Serial.println("WiFi failed connected to " + sta_ssid);

  192.   Serial.println("");

  193.   Serial.println("*WiFi-AP-Mode*");

  194.   Serial.print("AP IP address: ");

  195.   Serial.println(myIP);

  196.   delay(2000);

  197.   // }

  198. 

  199.   // Start camera server to get realtime view

  200.   startCameraServer();

  201.   Serial.print("Camera Ready! Use 'http://");

  202.   Serial.print(myIP);

  203.   Serial.println("' to connect ");

  204. 

  205.   // ArduinoOTA.begin();   // enable to receive update/upload firmware via Wifi OTA

  206. }

  207. 

  208. void loop() {

  209.   // put your main code here, to run repeatedly:

  210.   // ArduinoOTA.handle();

  211. }

复制代码


    2）app_httpd.cpp程序 


  1. #include "esp_http_server.h"

  2. #include "esp_timer.h"

  3. #include "esp_camera.h"

  4. #include "img_converters.h"

  5. #include "Arduino.h"

  6. #include <ESP32Servo.h>

  7. #include "cJSON.h"

  8. // #include <EEPROM.h>

  9. 

  10. // #define  EEPROM_speedT 2   //地址范围0-4095

  11. // // #define  EEPROM_speedY 10   //地址范围0-4095

  12. // // #define  EEPROM_speedU 20   //地址范围0-4095

  13. // #define  EEPROM_Size 1024  //开辟1024个位空间

  14. 

  15. extern int EEPROM_dataT;

  16. // extern int EEPROM_dataY;

  17. // extern int EEPROM_dataU;

  18. /* Initializing pins */

  19. extern int DRV_A;

  20. extern int DRV_B;

  21. extern int DIR_A;

  22. extern int DIR_B;

  23. extern int ledPin;

  24. // extern int buzzerPin;

  25. // extern int servoPin;

  26. extern int ledVal;

  27. extern Servo myservo;

  28. // extern Servo servo_1;

  29. extern int servoPin;

  30. extern int speed1;

  31. extern int speed2;

  32. extern int speed1d;

  33. extern int speed2d;

  34. // servo_1.attach(2,500,2500);

  35. 

  36. typedef struct {

  37.         httpd_req_t *req;

  38.         size_t len;

  39. } jpg_chunking_t;

  40. //定义视频流相关常量

  41. #define PART_BOUNDARY "123456789000000000000987654321"

  42. static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;

  43. static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";

  44. static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

  45. 

  46. httpd_handle_t stream_httpd = NULL;

  47. httpd_handle_t camera_httpd = NULL;

  48. 

  49. // 这是一个回调函数，用于编码并发送JPEG数据流

  50. static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){

  51.     jpg_chunking_t *j = (jpg_chunking_t *)arg;

  52.     if(!index){

  53.         j->len = 0;

  54.     }

  55.     if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){

  56.         return 0;

  57.     }

  58.     j->len += len;

  59.     return len;

  60. }

  61. // 这是处理图像捕获请求的函数，捕获并发送图像

  62. static esp_err_t capture_handler(httpd_req_t *req){

  63.     camera_fb_t * fb = NULL;

  64.     esp_err_t res = ESP_OK;

  65.     int64_t fr_start = esp_timer_get_time();

  66. 

  67.     fb = esp_camera_fb_get();

  68.     if (!fb) {

  69.         Serial.printf("Camera capture failed");

  70.         httpd_resp_send_500(req);

  71.         return ESP_FAIL;

  72.     }

  73. 

  74.     httpd_resp_set_type(req, "image/jpeg");

  75.     httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");

  76. 

  77.     size_t fb_len = 0;

  78.     if(fb->format == PIXFORMAT_JPEG){

  79.         fb_len = fb->len;

  80.         res = httpd_resp_send(req, (const char *)fb->buf, fb->len);

  81.     } else {

  82.         jpg_chunking_t jchunk = {req, 0};

  83.         res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;

  84.         httpd_resp_send_chunk(req, NULL, 0);

  85.         fb_len = jchunk.len;

  86.     }

  87.     esp_camera_fb_return(fb);

  88.     int64_t fr_end = esp_timer_get_time();

  89.     Serial.printf("JPG: %uB %ums", (uint32_t)(fb_len), (uint32_t)((fr_end - fr_start)/1000));

  90.     return res;

  91. }

  92. // 这是处理视频流请求的函数，捕获视频流并发送给客户端

  93. static esp_err_t stream_handler(httpd_req_t *req){

  94.     camera_fb_t * fb = NULL;

  95.     esp_err_t res = ESP_OK;

  96.     size_t _jpg_buf_len = 0;

  97.     uint8_t * _jpg_buf = NULL;

  98.     char * part_buf[64];

  99. 

  100.     static int64_t last_frame = 0;

  101.     if(!last_frame) {

  102.         last_frame = esp_timer_get_time();

  103.     }

  104. 

  105.     res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);

  106.     if(res != ESP_OK){

  107.         return res;

  108.     }

  109. 

  110.     while(true){

  111.         fb = esp_camera_fb_get();

  112.         if (!fb) {

  113.             Serial.printf("Camera capture failed");

  114.             res = ESP_FAIL;

  115.         } else {

  116.             if(fb->format != PIXFORMAT_JPEG){

  117.                 bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);

  118.                 esp_camera_fb_return(fb);

  119.                 fb = NULL;

  120.                 if(!jpeg_converted){

  121.                     Serial.printf("JPEG compression failed");

  122.                     res = ESP_FAIL;

  123.                 }

  124.             } else {

  125.                 _jpg_buf_len = fb->len;

  126.                 _jpg_buf = fb->buf;

  127.             }

  128.         }

  129.         if(res == ESP_OK){

  130.             size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);

  131.             res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);

  132.         }

  133.         if(res == ESP_OK){

  134.             res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);

  135.         }

  136.         if(res == ESP_OK){

  137.             res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));

  138.         }

  139.         if(fb){

  140.             esp_camera_fb_return(fb);

  141.             fb = NULL;

  142.             _jpg_buf = NULL;

  143.         } else if(_jpg_buf){

  144.             free(_jpg_buf);

  145.             _jpg_buf = NULL;

  146.         }

  147.         if(res != ESP_OK){

  148.             break;

  149.         }

  150.         int64_t fr_end = esp_timer_get_time();

  151. 

  152.         int64_t frame_time = fr_end - last_frame;

  153.         last_frame = fr_end;

  154.         frame_time /= 1000;

  155.     }

  156. 

  157.     last_frame = 0;

  158.     return res;

  159. }

  160. 

  161.  // 这是处理命令请求的函数，根据请求执行不同的命令

  162. static esp_err_t cmd_handler(httpd_req_t *req){

  163.     char*  buf;

  164.     size_t buf_len;

  165.     char variable[32] = {0,};

  166.     char value[32] = {0,};

  167. 

  168.     buf_len = httpd_req_get_url_query_len(req) + 1;

  169.     if (buf_len > 1) {

  170.         buf = (char*)malloc(buf_len);

  171.         Serial.println(buf);

  172.         if(!buf){

  173.             httpd_resp_send_500(req);

  174.             return ESP_FAIL;

  175.         }

  176.         if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {

  177.             if (httpd_query_key_value(buf, "var", variable, sizeof(variable)) == ESP_OK &&

  178.                 httpd_query_key_value(buf, "val", value, sizeof(value)) == ESP_OK) {

  179.             } else {

  180.                 free(buf);

  181.                 Serial.println(buf);

  182.                 httpd_resp_send_404(req);

  183.                 return ESP_FAIL;

  184.             }

  185.         } else {

  186.             free(buf);

  187.             Serial.println(buf);

  188.             httpd_resp_send_404(req);

  189.             return ESP_FAIL;

  190.         }

  191.         Serial.println(buf);

  192.         free(buf);

  193.     } else {

  194.         httpd_resp_send_404(req);

  195.         Serial.println(ESP_FAIL);

  196.         return ESP_FAIL;

  197.     }

  198. 

  199.     int val = atoi(value);

  200.     sensor_t * s = esp_camera_sensor_get();

  201.     int res = 0;

  202. 

  203.     if(!strcmp(variable, "framesize")) {

  204.         if(s->pixformat == PIXFORMAT_JPEG) res = s->set_framesize(s, (framesize_t)val);

  205.     }

  206.     else if(!strcmp(variable, "quality")) res = s->set_quality(s, val);

  207.     else if(!strcmp(variable, "contrast")) res = s->set_contrast(s, val);

  208.     else if(!strcmp(variable, "brightness")) res = s->set_brightness(s, val);

  209.     else if(!strcmp(variable, "saturation")) res = s->set_saturation(s, val);

  210.     else if(!strcmp(variable, "gainceiling")) res = s->set_gainceiling(s, (gainceiling_t)val);

  211.     else if(!strcmp(variable, "colorbar")) res = s->set_colorbar(s, val);

  212.     else if(!strcmp(variable, "awb")) res = s->set_whitebal(s, val);

  213.     else if(!strcmp(variable, "agc")) res = s->set_gain_ctrl(s, val);

  214.     else if(!strcmp(variable, "aec")) res = s->set_exposure_ctrl(s, val);

  215.     else if(!strcmp(variable, "hmirror")) res = s->set_hmirror(s, val);

  216.     else if(!strcmp(variable, "vflip")) res = s->set_vflip(s, val);

  217.     else if(!strcmp(variable, "awb_gain")) res = s->set_awb_gain(s, val);

  218.     else if(!strcmp(variable, "agc_gain")) res = s->set_agc_gain(s, val);

  219.     else if(!strcmp(variable, "aec_value")) res = s->set_aec_value(s, val);

  220.     else if(!strcmp(variable, "aec2")) res = s->set_aec2(s, val);

  221.     else if(!strcmp(variable, "dcw")) res = s->set_dcw(s, val);

  222.     else if(!strcmp(variable, "bpc")) res = s->set_bpc(s, val);

  223.     else if(!strcmp(variable, "wpc")) res = s->set_wpc(s, val);

  224.     else if(!strcmp(variable, "raw_gma")) res = s->set_raw_gma(s, val);

  225.     else if(!strcmp(variable, "lenc")) res = s->set_lenc(s, val);

  226.     else if(!strcmp(variable, "special_effect")) res = s->set_special_effect(s, val);

  227.     else if(!strcmp(variable, "wb_mode")) res = s->set_wb_mode(s, val);

  228.     else if(!strcmp(variable, "ae_level")) res = s->set_ae_level(s, val);

  229.     else {

  230.         res = -1;

  231.     }

  232. 

  233.     if(res){

  234.         return httpd_resp_send_500(req);

  235.     }

  236. 

  237.     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");

  238.     return httpd_resp_send(req, NULL, 0);

  239. }

  240.  // 这个函数用于处理状态请求，返回相机的当前状态

  241. static esp_err_t status_handler(httpd_req_t *req){

  242.     static char json_response[1024];

  243. 

  244.     sensor_t * s = esp_camera_sensor_get();

  245.     char * p = json_response;

  246.     *p++ = '{';

  247. 

  248.     p+=sprintf(p, ""framesize":%u,", s->status.framesize);

  249.     p+=sprintf(p, ""quality":%u,", s->status.quality);

  250.     p+=sprintf(p, ""brightness":%d,", s->status.brightness);

  251.     p+=sprintf(p, ""contrast":%d,", s->status.contrast);

  252.     p+=sprintf(p, ""saturation":%d,", s->status.saturation);

  253.     p+=sprintf(p, ""special_effect":%u,", s->status.special_effect);

  254.     p+=sprintf(p, ""wb_mode":%u,", s->status.wb_mode);

  255.     p+=sprintf(p, ""awb":%u,", s->status.awb);

  256.     p+=sprintf(p, ""awb_gain":%u,", s->status.awb_gain);

  257.     p+=sprintf(p, ""aec":%u,", s->status.aec);

  258.     p+=sprintf(p, ""aec2":%u,", s->status.aec2);

  259.     p+=sprintf(p, ""ae_level":%d,", s->status.ae_level);

  260.     p+=sprintf(p, ""aec_value":%u,", s->status.aec_value);

  261.     p+=sprintf(p, ""agc":%u,", s->status.agc);

  262.     p+=sprintf(p, ""agc_gain":%u,", s->status.agc_gain);

  263.     p+=sprintf(p, ""gainceiling":%u,", s->status.gainceiling);

  264.     p+=sprintf(p, ""bpc":%u,", s->status.bpc);

  265.     p+=sprintf(p, ""wpc":%u,", s->status.wpc);

  266.     p+=sprintf(p, ""raw_gma":%u,", s->status.raw_gma);

  267.     p+=sprintf(p, ""lenc":%u,", s->status.lenc);

  268.     p+=sprintf(p, ""hmirror":%u,", s->status.hmirror);

  269.     p+=sprintf(p, ""dcw":%u,", s->status.dcw);

  270.     p+=sprintf(p, ""colorbar":%u", s->status.colorbar);

  271.     *p++ = '}';

  272.     *p++ = 0;

  273.     httpd_resp_set_type(req, "application/json");

  274.     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");

  275.     return httpd_resp_send(req, json_response, strlen(json_response));

  276. }

  277. 

  278. // 这个函数用于处理设备状态请求，根据请求执行不同的操作，例如控制舵机角度

  279. static esp_err_t state_handler(httpd_req_t *req){

  280. 

  281.     char*  buf;

  282.     size_t buf_len;

  283.     char cmd[32] = {0,};

  284. 

  285.     buf_len = httpd_req_get_url_query_len(req) + 1;

  286.     if (buf_len > 1) {

  287.         buf = (char*)malloc(buf_len);

  288.         Serial.println(buf);

  289.         

  290.         if(!buf){

  291.             httpd_resp_send_500(req);

  292.             return ESP_FAIL;

  293.         }

  294.         

  295.         if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {

  296.             if (httpd_query_key_value(buf, "cmd", cmd, sizeof(cmd)) == ESP_OK) {

  297.               

  298.             } else {

  299.                 free(buf);

  300.                 Serial.print("*");

  301.                 Serial.println(ESP_FAIL);

  302.                 httpd_resp_send_404(req);

  303.                 return ESP_FAIL;

  304.             }

  305.         } else {

  306.             free(buf);

  307.             Serial.print("**");

  308.             Serial.println(ESP_FAIL);

  309.             httpd_resp_send_404(req);

  310.             return ESP_FAIL;

  311.         }

  312.         free(buf);

  313.         

  314.     } else {

  315.         Serial.print("***");

  316.         Serial.println(ESP_FAIL);

  317.         httpd_resp_send_404(req);

  318.         return ESP_FAIL;

  319.     }

  320. 

  321.     int res = 0;

  322. 

  323.     if(!strcmp(cmd, "F")) {

  324.       Serial.println("Forward");

  325.       // digitalWrite(DRV_A, LOW);

  326.       // digitalWrite(DRV_B, HIGH);

  327.       // digitalWrite(DIR_A, LOW);

  328.       // digitalWrite(DIR_B, HIGH);

  329. 

  330.       Serial1.println("F"); // 发送前进指令

  331. 

  332.       analogWrite(DRV_A, 0);

  333.       analogWrite(DRV_B, speed1);

  334.       analogWrite(DIR_A, 0);

  335.       analogWrite(DIR_B, speed2);

  336.       httpd_resp_set_type(req, "text/html");

  337.       return httpd_resp_send(req, "OK", 2);

  338.     }

  339.     

  340.     else if(!strcmp(cmd, "B")) {

  341.       Serial.println("Backward");

  342.       // digitalWrite(DRV_A, HIGH);

  343.       // digitalWrite(DRV_B, LOW);

  344.       // digitalWrite(DIR_A, HIGH);

  345.       // digitalWrite(DIR_B, LOW);

  346. 

  347.       Serial1.println("B"); // 发送后退指令

  348. 

  349.       analogWrite(DRV_A, speed1);

  350.       analogWrite(DRV_B, 0);

  351.       analogWrite(DIR_A, speed2);

  352.       analogWrite(DIR_B, 0);

  353.       httpd_resp_set_type(req, "text/html");

  354.       return httpd_resp_send(req, "OK", 2);

  355.     }

  356.     

  357.     else if(!strcmp(cmd, "L")) {

  358.       Serial.println("Turn Left");

  359.       

  360.       // digitalWrite(DRV_A, HIGH);

  361.       // digitalWrite(DRV_B, LOW);

  362.       // digitalWrite(DIR_A, LOW);

  363.       // digitalWrite(DIR_B, HIGH);

  364. 

  365.       Serial1.println("L"); // 发送左转指令

  366. 

  367.       analogWrite(DRV_A, speed1);

  368.       analogWrite(DRV_B, 0);

  369.       analogWrite(DIR_A, 0);

  370.       analogWrite(DIR_B, speed2);

  371.       httpd_resp_set_type(req, "text/html");

  372.       return httpd_resp_send(req, "OK", 2);

  373.     }

  374.     

  375.     else if(!strcmp(cmd, "R")) {

  376.       Serial.println("Turn Right");

  377. 

  378.       Serial1.println("R"); // 发送右转指令

  379. 

  380.       analogWrite(DRV_A, 0);

  381.       analogWrite(DRV_B, speed1);

  382.       analogWrite(DIR_A, speed2);

  383.       analogWrite(DIR_B, 0);

  384.       httpd_resp_set_type(req, "text/html");

  385.       return httpd_resp_send(req, "OK", 2);

  386.     }

  387.     

  388.     else if(!strcmp(cmd, "G")) {

  389.       Serial.println("Forward Left");

  390. 

  391.       analogWrite(DRV_A, 0);

  392.       analogWrite(DRV_B, 0);

  393.       analogWrite(DIR_A, 0);

  394.       analogWrite(DIR_B, speed2);

  395. 

  396.       httpd_resp_set_type(req, "text/html");

  397.       return httpd_resp_send(req, "OK", 2);

  398.     }

  399.     

  400.     else if(!strcmp(cmd, "H")) {

  401.       Serial.println("Backward Left");

  402. 

  403.       analogWrite(DRV_A, speed1);

  404.       analogWrite(DRV_B, 0);

  405.       analogWrite(DIR_A, 0);

  406.       analogWrite(DIR_B, 0);

  407.       httpd_resp_set_type(req, "text/html");

  408.       return httpd_resp_send(req, "OK", 2);

  409.     }

  410.     

  411.     else if(!strcmp(cmd, "I")) {

  412.       Serial.println("Forward Right");

  413. 

  414.       analogWrite(DRV_A, 0);

  415.       analogWrite(DRV_B, speed1);

  416.       analogWrite(DIR_A, 0);

  417.       analogWrite(DIR_B, 0);

  418.       httpd_resp_set_type(req, "text/html");

  419.       return httpd_resp_send(req, "OK", 2);

  420.     }

  421.     

  422.     else if(!strcmp(cmd, "J")) {

  423.       Serial.println("Backward Right");

  424. 

  425.       analogWrite(DRV_A, 0);

  426.       analogWrite(DRV_B, 0);

  427.       analogWrite(DIR_A, speed2);

  428.       analogWrite(DIR_B, 0);

  429.       httpd_resp_set_type(req, "text/html");

  430.       return httpd_resp_send(req, "OK", 2);

  431.     }

  432.     

  433.     else if(!strcmp(cmd, "S")) {

  434.       Serial.println("Stop");

  435. 

  436.       Serial1.println("S"); // 发送停止指令

  437. 

  438.       analogWrite(DRV_A, 0);

  439.       analogWrite(DRV_B, 0);

  440.       analogWrite(DIR_A, 0);

  441.       analogWrite(DIR_B, 0);

  442.       httpd_resp_set_type(req, "text/html");

  443.       return httpd_resp_send(req, "OK", 2);

  444.     }

  445.     

  446.     // else if(!strcmp(cmd, "V")) {

  447.     //   Serial.println("Horn On");

  448.     //   digitalWrite(buzzerPin, HIGH);

  449.     //   httpd_resp_set_type(req, "text/html");

  450.     //   return httpd_resp_send(req, "OK", 2);

  451.     // }

  452.     

  453.     // else if(!strcmp(cmd, "v")) {

  454.     //   Serial.println("Horn Off");

  455.     //   digitalWrite(buzzerPin, LOW);

  456.     //   httpd_resp_set_type(req, "text/html");

  457.     //   return httpd_resp_send(req, "OK", 2);

  458.     // }

  459.     else if(!strcmp(cmd, "T")) {

  460.       speed1=105;   //左

  461.       speed2=105;

  462.       httpd_resp_set_type(req, "text/html");

  463.       return httpd_resp_send(req, "OK", 2);

  464.     }

  465.     

  466.     else if(!strcmp(cmd, "Y")) {

  467.       speed1=165;

  468.       speed2=165;

  469.       httpd_resp_set_type(req, "text/html");

  470.       return httpd_resp_send(req, "OK", 2);

  471.     }        

  472.     else if(!strcmp(cmd, "U")) {

  473.       speed1=255;

  474.       speed2=255;

  475.       httpd_resp_set_type(req, "text/html");

  476.       return httpd_resp_send(req, "OK", 2);

  477.     }  

  478.     // else if(!strcmp(cmd, "W")) {

  479.     //   Serial.println("LED On");

  480.     //   ledcWrite(7, ledVal);

  481.     //   httpd_resp_set_type(req, "text/html");

  482.     //   return httpd_resp_send(req, "OK", 2);

  483.     // }

  484.     

  485.     else if(!strcmp(cmd, "w")) {

  486.       Serial.println("LED Off");

  487. 

  488.       Serial1.println("w"); // 发送关灯指令

  489. 

  490.       ledcWrite(7, 0);

  491.       httpd_resp_set_type(req, "text/html");

  492.       return httpd_resp_send(req, "OK", 2);

  493.     }

  494.     

  495.     // else if (!strcmp(cmd, "x")){

  496.     //   Serial.println("Flash Light : Low (20)");

  497.     //   ledVal = 20;

  498.     //   ledcWrite(7, ledVal);

  499.     //   httpd_resp_set_type(req, "text/html");

  500.     //   return httpd_resp_send(req, "OK", 2);

  501.     // }

  502.     // else if (!strcmp(cmd, "y")){

  503.     //   Serial.println("Flash Light : Medium (50)");

  504.     //   ledVal = 50;

  505.     //   ledcWrite(7, ledVal);

  506.     //   httpd_resp_set_type(req, "text/html");

  507.     //   return httpd_resp_send(req, "OK", 2);

  508.     // }

  509.     // else if (!strcmp(cmd, "z")){

  510.     //   Serial.println("Flash Light : Bright (100)");

  511.     //   ledVal = 100;

  512.     //   ledcWrite(7, ledVal);

  513.     //   httpd_resp_set_type(req, "text/html");

  514.     //   return httpd_resp_send(req, "OK", 2);

  515.     // }    

  516.     else if (!strcmp(cmd, "Z")){

  517.       Serial.println("Flash Light : Super Bright (255)");

  518. 

  519.       Serial1.println("Z"); // 发送开灯指令

  520. 

  521.       ledVal = 255;

  522.       ledcWrite(7, ledVal);

  523.       httpd_resp_set_type(req, "text/html");

  524.       return httpd_resp_send(req, "OK", 2);

  525.     }   

  526.     

  527. 

  528.     else if (!strcmp(cmd, "a")){

  529.       Serial.println("Servo q (0)");

  530.       // ledcWrite(8, 400);

  531. 

  532.       myservo.write(110);

  533.       delay(100);

  534.       myservo.write(90);

  535.       delay(100);

  536.       digitalWrite(servoPin, LOW);

  537.       httpd_resp_set_type(req, "text/html");

  538.       return httpd_resp_send(req, "OK", 2);

  539.     }

  540.     else if (!strcmp(cmd, "b")){

  541.       Serial.println("Servo q (6500)");

  542.       // ledcWrite(8, 6000);

  543.       myservo.write(70);

  544.       delay(100);

  545.       myservo.write(90);

  546.       delay(100);

  547.       digitalWrite(servoPin, LOW);

  548.       httpd_resp_set_type(req, "text/html");

  549.       return httpd_resp_send(req, "OK", 2);

  550.     }

  551. 

  552.     // else if (!strcmp(cmd, "n")){

  553.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  554.     //   EEPROM_dataT=EEPROM.read(EEPROM_speedT);

  555.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataT);

  556.     //   if (EEPROM_dataT<60)

  557.     //     EEPROM_dataT=EEPROM_dataT+1;

  558.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataT);

  559.     //   EEPROM.write(EEPROM_speedT,EEPROM_dataT);

  560.     //   EEPROM.commit();

  561. 

  562.     //   String response = String(EEPROM_dataT); // 将整数转换为字符串

  563.     //   httpd_resp_set_type(req, "text/html");

  564.     //   return httpd_resp_send(req,response.c_str(), response.length());

  565.     // }

  566. 

  567.     // else if (!strcmp(cmd, "m")){

  568.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  569.     //   EEPROM_dataT=EEPROM.read(EEPROM_speedT);

  570.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataT);

  571.     //   if (EEPROM_dataT>0)

  572.     //     EEPROM_dataT=EEPROM_dataT-1;

  573.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataT);

  574.     //   EEPROM.write(EEPROM_speedT,EEPROM_dataT);

  575.     //   EEPROM.commit();

  576. 

  577.     //   String response = String(EEPROM_dataT); // 将整数转换为字符串

  578.     //   httpd_resp_set_type(req, "text/html");

  579.     //   return httpd_resp_send(req, response.c_str(), response.length());

  580.     // }

  581. 

  582.     // else if (!strcmp(cmd, "h")){

  583.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  584.     //   EEPROM_dataT=EEPROM.read(EEPROM_speedT);

  585.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataT);

  586. 

  587.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataT);

  588.     //   EEPROM.write(EEPROM_speedT,EEPROM_dataT);

  589.     //   EEPROM.commit();

  590. 

  591.     //   speed1=125+EEPROM_dataT;

  592.     //   speed2=155;

  593. 

  594.     //   String response = String(EEPROM_dataT); // 将整数转换为字符串

  595.     //   httpd_resp_set_type(req, "text/html");

  596.     //   return httpd_resp_send(req,"OK", 2);

  597.     // }

  598. 

  599.     // else if (!strcmp(cmd, "j")){

  600.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  601.     //   EEPROM_dataY=EEPROM.read(EEPROM_speedY);

  602.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataY);

  603.     //   if (EEPROM_dataY>0)

  604.     //     EEPROM_dataY=EEPROM_dataY+1;

  605.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataY);

  606.     //   EEPROM.write(EEPROM_speedY,EEPROM_dataY);

  607.     //   EEPROM.commit();

  608.     //   //  speed1=speed1d+EEPROM_data;

  609.     //   String response = String(EEPROM_dataY); // 将整数转换为字符串

  610.     //   httpd_resp_set_type(req, "text/html");

  611.     //   return httpd_resp_send(req, response.c_str(), response.length());

  612.     // }

  613.     // else if (!strcmp(cmd, "k")){

  614.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  615.     //   EEPROM_dataY=EEPROM.read(EEPROM_speedY);

  616.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataY);

  617.     //   if (EEPROM_dataY>0)

  618.     //     EEPROM_dataY=EEPROM_dataY-1;

  619.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataY);

  620.     //   EEPROM.write(EEPROM_speedY,EEPROM_dataY);

  621.     //   EEPROM.commit();

  622.     //   //  speed1=speed1d+EEPROM_data;

  623.     //   String response = String(EEPROM_dataY); // 将整数转换为字符串

  624.     //   httpd_resp_set_type(req, "text/html");

  625.     //   return httpd_resp_send(req, response.c_str(), response.length());

  626.     // }

  627. 

  628.     // else if (!strcmp(cmd, "i")){

  629.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  630.     //   EEPROM_dataU=EEPROM.read(EEPROM_speedU);

  631.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataU);

  632.     //   if (EEPROM_dataU>0)

  633.     //     EEPROM_dataU=EEPROM_dataU+1;

  634.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataU);

  635.     //   EEPROM.write(EEPROM_speedU,EEPROM_dataU);

  636.     //   EEPROM.commit();

  637.     //   //  speed1=speed1d+EEPROM_data;

  638.     //   String response = String(EEPROM_dataU); // 将整数转换为字符串

  639.     //   httpd_resp_set_type(req, "text/html");

  640.     //   return httpd_resp_send(req, response.c_str(), response.length());

  641.     // }

  642. 

  643.     // else if (!strcmp(cmd, "o")){

  644.     //   EEPROM.begin(EEPROM_Size);  //开启EEPROM

  645.     //   EEPROM_dataU=EEPROM.read(EEPROM_speedU);

  646.     //   Serial.printf("last_EEPROM_speed:%d",EEPROM_dataU);

  647.     //   if (EEPROM_dataU>0)

  648.     //     EEPROM_dataU=EEPROM_dataU-1;

  649.     //   Serial.printf("now_EEPROM_speed:%d",EEPROM_dataU);

  650.     //   EEPROM.write(EEPROM_speedU,EEPROM_dataU);

  651.     //   EEPROM.commit();

  652.     //   //  speed1=speed1d+EEPROM_data;

  653.     //   String response = String(EEPROM_dataU); // 将整数转换为字符串

  654.     //   httpd_resp_set_type(req, "text/html");

  655.     //   return httpd_resp_send(req, response.c_str(), response.length());

  656.     // }

  657. 

  658. 

  659.     

  660.     else {

  661.         res = -1;

  662.     }

  663. 

  664.     if(res){

  665.         return httpd_resp_send_500(req);

  666.     }

  667. 

  668.     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");

  669.     return httpd_resp_send(req, NULL, 0);

  670. }

  671. 

  672. 

  673. 

  674. 

  675. // static esp_err_t data_handler(httpd_req_t *req) {

  676. //     char buf[1024];  // 增加缓冲区大小

  677. //     int ret, remaining = req->content_len;

  678. 

  679. //     char request_data[1024];  // 增加缓冲区大小

  680. //     int data_index = 0;

  681. 

  682. //     while (remaining > 0) {

  683. //         ret = httpd_req_recv(req, buf, MIN(remaining, sizeof(buf)));

  684. //         if (ret <= 0) {

  685. //             if (ret == HTTPD_SOCK_ERR_TIMEOUT) {

  686. //                 httpd_resp_send_408(req);

  687. //             } else {

  688. //                 httpd_resp_send_500(req);

  689.             

  690. //             return ESP_FAIL;

  691. //         }

  692. 

  693. //         for (int i = 0; i < ret; i++) {

  694. //             request_data[data_index] = buf[i];

  695. //             data_index++;

  696. //         }

  697. 

  698. //         remaining -= ret;

  699. //     }

  700. 

  701. //     // 解析JSON数据

  702. //     cJSON *root = cJSON_Parse(request_data);

  703. //     if (root == NULL) {

  704. //         // JSON解析失败

  705. //         httpd_resp_send_500(req);

  706. //         return ESP_FAIL;

  707. //     }

  708. 

  709. //     // 获取JSON对象中的数据项

  710. //     cJSON *value1 = cJSON_GetObjectItem(root, "value1");

  711. //     cJSON *value2 = cJSON_GetObjectItem(root, "value2");

  712. 

  713. //     if (value1 == NULL || value2 == NULL) {

  714. //         // JSON数据项不存在

  715. //         //httpd_resp_send_400(req);  // 使用400 Bad Request

  716. //         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Bad Request");

  717. //         cJSON_Delete(root);

  718. //         return ESP_FAIL;

  719. //     }

  720. 

  721. //     // 将数据项转换为整数

  722. //     int intValue1 = value1->valueint;

  723. //     int intValue2 = value2->valueint;

  724. 

  725. //     // 打印解析后的数据

  726. //     printf("Received JSON data - value1: %d, value2: %d\n", intValue1, intValue2);

  727. 

  728. //     cJSON_Delete(root);

  729. 

  730. //     // 发送响应给客户端

  731. //     httpd_resp_set_type(req, "text/plain");

  732. //     httpd_resp_send(req, "JSON data received and processed", -1);

  733. 

  734. //     return ESP_OK;

  735. // }

  736. // }

  737. 

  738. 

  739.  

  740. 

  741. // 这是启动相机服务器的函数，它会注册URI处理程序，包括视频流处理程序

  742. void startCameraServer(){

  743.     httpd_config_t config = HTTPD_DEFAULT_CONFIG();

  744.     

  745. 

  746.     httpd_uri_t status_uri = {

  747.         .uri       = "/status",

  748.         .method    = HTTP_GET,

  749.         .handler   = status_handler,

  750.         .user_ctx  = NULL

  751.     };

  752. 

  753.     httpd_uri_t cmd_uri = {

  754.         .uri       = "/control",

  755.         .method    = HTTP_GET,

  756.         .handler   = cmd_handler,

  757.         .user_ctx  = NULL

  758.     };

  759. 

  760.     httpd_uri_t capture_uri = {

  761.         .uri       = "/capture",

  762.         .method    = HTTP_GET,

  763.         .handler   = capture_handler,

  764.         .user_ctx  = NULL

  765.     };

  766. 

  767.    httpd_uri_t stream_uri = {

  768.         .uri       = "/stream",

  769.         .method    = HTTP_GET,

  770.         .handler   = stream_handler,

  771.         .user_ctx  = NULL

  772.     };

  773. 

  774.    httpd_uri_t state_uri = {

  775.         .uri       = "/state",

  776.         .method    = HTTP_GET,

  777.         .handler   = state_handler,

  778.         .user_ctx  = NULL

  779.     };

  780.     // httpd_uri_t data_uri = {

  781.     // .uri       = "/data",

  782.     // .method    = HTTP_GET,

  783.     // .handler   = data_handler,

  784.     // .user_ctx  = NULL

  785.     // };

  786. 

  787.     Serial.printf("Starting web server on port: '%d'", config.server_port);

  788.     if (httpd_start(&camera_httpd, &config) == ESP_OK) {

  789.         httpd_register_uri_handler(camera_httpd, &cmd_uri);

  790.         httpd_register_uri_handler(camera_httpd, &capture_uri);

  791.         httpd_register_uri_handler(camera_httpd, &status_uri);

  792.         httpd_register_uri_handler(camera_httpd, &state_uri);

  793.         // httpd_register_uri_handler(camera_httpd, &data_uri);

  794.     }

  795. 

  796.     config.server_port += 1;

  797.     config.ctrl_port += 1;

  798.     Serial.printf("Starting stream server on port: '%d'", config.server_port);

  799.     if (httpd_start(&stream_httpd, &config) == ESP_OK) {

  800.         httpd_register_uri_handler(stream_httpd, &stream_uri);

  801.     }

  802. }
复制代码



    4、APP

APP来自开源项目ESP32履带车

用树莓派PICO制作一个FPV小车图11




附件：








树莓派, Raspberry Pi, Pico, ESP32-S3, ESP32-CAM

相关帖子

回复

使用道具 举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4

© 2013-2024 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail