设为首页收藏本站
首页 > 论坛 > ESP32

[项目]Esp32-c6与Esp32-c3自制ESP-NOW 遥控车 精华

云天 | 中级技神 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2024-3-31 11:26:20 [显示全部楼层]
3470浏览
1回复
1收藏
查看: 3470|回复: 1

[项目] Esp32-c6与Esp32-c3自制ESP-NOW 遥控车

[复制链接]
【项目背景】
一直我都想自制一辆遥控车，自己打板制作遥控器，自制车身框架。这段时间正在试用Esp32-c6，手上还有一块Esp32-c3，两者都支持ESP-NOW通信。使用佳立创画板，焊接元器件，打造自己的遥控车。
Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图1

【佳立创画板】
1.摇杆VRx接esp32-c3的0引脚(A0)，VRy接esp32-c3的4引脚(A4),按键分别接esp32-c3的2、8、9、21引脚(编程引脚初始化时设置为上拉输入模式）
Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图4

Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图5

2.车身电路esp32-c6与电机驱动，esp32-c6的4、5、23、22引脚用来向电机驱动输入控制信号。
Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图6

Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图7

【组装】
1.遥控器
Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图8

Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图9

Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图10

2.车
Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图2


Esp32-c6与Esp32-c3自制ESP-NOW 遥控车图3




【编写程序】
使用Arduino IDE 编写。
1.esp32-c3遥控器程序
  1. 

  2. 

  3. #include <esp_now.h>

  4. #include <WiFi.h>

  5. #include <esp_wifi.h> // only for esp_wifi_set_channel()

  6. 

  7. // Global copy of slave

  8. esp_now_peer_info_t slave;

  9. #define CHANNEL 1

  10. #define PRINTSCANRESULTS 0

  11. #define DELETEBEFOREPAIR 0

  12. 

  13. // Init ESP Now with fallback

  14. void InitESPNow() {

  15.   WiFi.disconnect();

  16.   if (esp_now_init() == ESP_OK) {

  17.     Serial.println("ESPNow Init Success");

  18.   }

  19.   else {

  20.     Serial.println("ESPNow Init Failed");

  21.     // Retry InitESPNow, add a counte and then restart?

  22.     // InitESPNow();

  23.     // or Simply Restart

  24.     ESP.restart();

  25.   }

  26. }

  27. 

  28. // Scan for slaves in AP mode

  29. void ScanForSlave() {

  30.   int16_t scanResults = WiFi.scanNetworks(false, false, false, 300, CHANNEL); // Scan only on one channel

  31.   // reset on each scan

  32.   bool slaveFound = 0;

  33.   memset(&slave, 0, sizeof(slave));

  34. 

  35.   Serial.println("");

  36.   if (scanResults == 0) {

  37.     Serial.println("No WiFi devices in AP Mode found");

  38.   } else {

  39.     Serial.print("Found "); Serial.print(scanResults); Serial.println(" devices ");

  40.     for (int i = 0; i < scanResults; ++i) {

  41.       // Print SSID and RSSI for each device found

  42.       String SSID = WiFi.SSID(i);

  43.       int32_t RSSI = WiFi.RSSI(i);

  44.       String BSSIDstr = WiFi.BSSIDstr(i);

  45. 

  46.       if (PRINTSCANRESULTS) {

  47.         Serial.print(i + 1);

  48.         Serial.print(": ");

  49.         Serial.print(SSID);

  50.         Serial.print(" (");

  51.         Serial.print(RSSI);

  52.         Serial.print(")");

  53.         Serial.println("");

  54.       }

  55.       delay(10);

  56.       // Check if the current device starts with `Slave`

  57.       if (SSID.indexOf("Slave") == 0) {

  58.         // SSID of interest

  59.         Serial.println("Found a Slave.");

  60.         Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");

  61.         // Get BSSID => Mac Address of the Slave

  62.         int mac[6];

  63.         if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {

  64.           for (int ii = 0; ii < 6; ++ii ) {

  65.             slave.peer_addr[ii] = (uint8_t) mac[ii];

  66.           }

  67.         }

  68. 

  69.         slave.channel = CHANNEL; // pick a channel

  70.         slave.encrypt = 0; // no encryption

  71. 

  72.         slaveFound = 1;

  73.         // we are planning to have only one slave in this example;

  74.         // Hence, break after we find one, to be a bit efficient

  75.         break;

  76.       }

  77.     }

  78.   }

  79. 

  80.   if (slaveFound) {

  81.     Serial.println("Slave Found, processing..");

  82.   } else {

  83.     Serial.println("Slave Not Found, trying again.");

  84.   }

  85. 

  86.   // clean up ram

  87.   WiFi.scanDelete();

  88. }

  89. 

  90. // Check if the slave is already paired with the master.

  91. // If not, pair the slave with master

  92. bool manageSlave() {

  93.   if (slave.channel == CHANNEL) {

  94.     if (DELETEBEFOREPAIR) {

  95.       deletePeer();

  96.     }

  97. 

  98.     Serial.print("Slave Status: ");

  99.     // check if the peer exists

  100.     bool exists = esp_now_is_peer_exist(slave.peer_addr);

  101.     if ( exists) {

  102.       // Slave already paired.

  103.       Serial.println("Already Paired");

  104.       return true;

  105.     } else {

  106.       // Slave not paired, attempt pair

  107.       esp_err_t addStatus = esp_now_add_peer(&slave);

  108.       if (addStatus == ESP_OK) {

  109.         // Pair success

  110.         Serial.println("Pair success");

  111.         return true;

  112.       } else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {

  113.         // How did we get so far!!

  114.         Serial.println("ESPNOW Not Init");

  115.         return false;

  116.       } else if (addStatus == ESP_ERR_ESPNOW_ARG) {

  117.         Serial.println("Invalid Argument");

  118.         return false;

  119.       } else if (addStatus == ESP_ERR_ESPNOW_FULL) {

  120.         Serial.println("Peer list full");

  121.         return false;

  122.       } else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {

  123.         Serial.println("Out of memory");

  124.         return false;

  125.       } else if (addStatus == ESP_ERR_ESPNOW_EXIST) {

  126.         Serial.println("Peer Exists");

  127.         return true;

  128.       } else {

  129.         Serial.println("Not sure what happened");

  130.         return false;

  131.       }

  132.     }

  133.   } else {

  134.     // No slave found to process

  135.     Serial.println("No Slave found to process");

  136.     return false;

  137.   }

  138. }

  139. 

  140. void deletePeer() {

  141.   esp_err_t delStatus = esp_now_del_peer(slave.peer_addr);

  142.   Serial.print("Slave Delete Status: ");

  143.   if (delStatus == ESP_OK) {

  144.     // Delete success

  145.     Serial.println("Success");

  146.   } else if (delStatus == ESP_ERR_ESPNOW_NOT_INIT) {

  147.     // How did we get so far!!

  148.     Serial.println("ESPNOW Not Init");

  149.   } else if (delStatus == ESP_ERR_ESPNOW_ARG) {

  150.     Serial.println("Invalid Argument");

  151.   } else if (delStatus == ESP_ERR_ESPNOW_NOT_FOUND) {

  152.     Serial.println("Peer not found.");

  153.   } else {

  154.     Serial.println("Not sure what happened");

  155.   }

  156. }

  157. 

  158. // 发送结构体类型

  159. typedef struct struct_message {

  160.   char a;

  161.   int b;

  162. 

  163. } struct_message;

  164. // 创建一个结构体变量

  165. struct_message data;

  166. // send data

  167. void sendData() {

  168. 

  169.   const uint8_t *peer_addr = slave.peer_addr;

  170. 

  171.   esp_err_t result = esp_now_send(peer_addr,(uint8_t *) &data, sizeof(data));

  172.   Serial.print("Send Status: ");

  173.   if (result == ESP_OK) {

  174.     Serial.println("Success");

  175.   } else if (result == ESP_ERR_ESPNOW_NOT_INIT) {

  176.     // How did we get so far!!

  177.     Serial.println("ESPNOW not Init.");

  178.   } else if (result == ESP_ERR_ESPNOW_ARG) {

  179.     Serial.println("Invalid Argument");

  180.   } else if (result == ESP_ERR_ESPNOW_INTERNAL) {

  181.     Serial.println("Internal Error");

  182.   } else if (result == ESP_ERR_ESPNOW_NO_MEM) {

  183.     Serial.println("ESP_ERR_ESPNOW_NO_MEM");

  184.   } else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {

  185.     Serial.println("Peer not found.");

  186.   } else {

  187.     Serial.println("Not sure what happened");

  188.   }

  189. }

  190. 

  191. // callback when data is sent from Master to Slave

  192. void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {

  193.   char macStr[18];

  194.   snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",

  195.            mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

  196.   Serial.print("Last Packet Sent to: "); Serial.println(macStr);

  197.   Serial.print("Last Packet Send Status: "); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");

  198. }

  199. 

  200. void setup() {

  201.   Serial.begin(115200);

  202.   //Set device in STA mode to begin with

  203.   WiFi.mode(WIFI_STA);

  204.   esp_wifi_set_channel(CHANNEL, WIFI_SECOND_CHAN_NONE);

  205.   Serial.println("ESPNow/Basic/Master Example");

  206.   // This is the mac address of the Master in Station Mode

  207.   Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());

  208.   Serial.print("STA CHANNEL "); Serial.println(WiFi.channel());

  209.   // Init ESPNow with a fallback logic

  210.   InitESPNow();

  211.   // Once ESPNow is successfully Init, we will register for Send CB to

  212.   // get the status of Trasnmitted packet

  213.   esp_now_register_send_cb(OnDataSent);

  214.      pinMode(2,INPUT_PULLUP);  //配置按键所在端口为上拉输入模式 

  215.      pinMode(8,INPUT_PULLUP);  //配置按键所在端口为上拉输入模式 

  216.      pinMode(9,INPUT_PULLUP);  //配置按键所在端口为上拉输入模式 

  217.      pinMode(21,INPUT_PULLUP);  //配置按键所在端口为上拉输入模式 

  218. }

  219. bool i=1;

  220. int xValue;

  221. int yValue; 

  222. int bs=0;

  223. void loop() {

  224.   // In the loop we scan for slave

  225.   if (i) {

  226.    ScanForSlave();

  227.   }

  228.   // If Slave is found, it would be populate in `slave` variable

  229.   // We will check if `slave` is defined and then we proceed further

  230.   if (slave.channel == CHANNEL) { // check if slave channel is defined

  231.     // `slave` is defined

  232.     // Add slave as peer if it has not been added already

  233.     bool isPaired = manageSlave();

  234.     if (isPaired) {

  235.       i=0;

  236.       // pair success or already paired

  237.       // Send data to device

  238.       if(!digitalRead(9))  //如果按键按下，即GPIO9的端口状态为低电平 

  239.       {

  240.       data.a='y';

  241.       data.b=4000;

  242.       sendData();

  243.       delay(500);

  244.       }

  245.           if(!digitalRead(8))  //如果按键按下，即GPIO9的端口状态为低电平 

  246.       {

  247.       data.a='y';

  248.       data.b=500;

  249.       sendData();

  250.       delay(500);

  251.       }

  252.         if(!digitalRead(2))  //如果按键按下，即GPIO2的端口状态为低电平 

  253.       {

  254.       data.a='x';

  255.       data.b=4000;

  256.       sendData();

  257.       delay(500);

  258.       }

  259.        if(!digitalRead(21))  //如果按键按下，即GPIO21的端口状态为低电平 

  260.       {

  261.       data.a='x';

  262.       data.b=500;

  263.       sendData();

  264.       delay(500);

  265.       }

  266.       xValue = analogRead(4);//获取摇杆的x值，连接在主板A4接口

  267.       yValue = analogRead(0);//获取摇杆的y值，连接在主板A0接口

  268.       Serial.println(xValue);

  269.       Serial.println(yValue);

  270.       delay(100);

  271.       if(xValue>4000 || xValue<500)

  272.       {

  273.         bs=1;

  274.         data.a='x';

  275.         data.b=xValue;

  276.         sendData();

  277.         Serial.println('x');

  278.       }

  279.       else{

  280.         if(yValue>4000 || yValue<500)

  281.         {  bs=1;

  282.            data.a='y';

  283.            data.b=yValue;

  284.            sendData();

  285.            Serial.println('y');

  286.         }

  287.         else{

  288.           if(bs==1){

  289.            bs=0;

  290.            data.a='s';

  291.            sendData();

  292.           Serial.println('s');

  293.           }

  294.         }

  295.       }

  296.     } else {

  297.       // slave pair failed

  298.       Serial.println("Slave pair failed!");

  299.     }

  300.   }

  301.   else {

  302.     // No slave found to process

  303.   }

  304. 

  305.   // wait for 3seconds to run the logic again

  306.   

  307. }

  308. 

复制代码
2.esp32-c6 车程序
  1. 

  2. 

  3. 

  4. #include <esp_now.h>

  5. #include <WiFi.h>

  6. 

  7. 

  8. #define CHANNEL 1

  9. //设置PWM参数

  10. 

  11. // Init ESP Now with fallback

  12. void InitESPNow() {

  13.   WiFi.disconnect();

  14.   if (esp_now_init() == ESP_OK) {

  15.     Serial.println("ESPNow Init Success");

  16.   }

  17.   else {

  18.     Serial.println("ESPNow Init Failed");

  19.     // Retry InitESPNow, add a counte and then restart?

  20.     // InitESPNow();

  21.     // or Simply Restart

  22.     ESP.restart();

  23.   }

  24. }

  25. 

  26. // config AP SSID

  27. void configDeviceAP() {

  28.   const char *SSID = "Slave_1";

  29.   bool result = WiFi.softAP(SSID, "Slave_1_Password", CHANNEL, 0);

  30.   if (!result) {

  31.     Serial.println("AP Config failed.");

  32.   } else {

  33.     Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));

  34.     Serial.print("AP CHANNEL "); Serial.println(WiFi.channel());

  35.   }

  36. }

  37.     const int IA1=4;

  38.     const int IA2=5;

  39.     const int IB1=23;

  40.     const int IB2=22;

  41. void setup() {

  42.   Serial.begin(115200);

  43.  

  44.          pinMode(IA1, OUTPUT);

  45.          pinMode(IA2, OUTPUT);

  46.          pinMode(IB1, OUTPUT);

  47.          pinMode(IB2, OUTPUT);

  48. 

  49.   Serial.println("ESPNow/Basic/Slave Example");

  50.   //Set device in AP mode to begin with

  51.   WiFi.mode(WIFI_AP);

  52.   // configure device AP mode

  53.   configDeviceAP();

  54.   // This is the mac address of the Slave in AP Mode

  55.   Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());

  56.   // Init ESPNow with a fallback logic

  57.   InitESPNow();

  58.   // Once ESPNow is successfully Init, we will register for recv CB to

  59.   // get recv packer info.

  60.   esp_now_register_recv_cb(OnDataRecv);

  61. }

  62. // 创建一个结构体接收数据

  63. typedef struct struct_message {

  64.     char a;

  65.     int b;

  66. 

  67. } struct_message;

  68. 

  69. // 创建一个结构体变量

  70. struct_message myData;

  71. 

  72.                         

  73. 

  74. // callback when data is recv from Master

  75. void OnDataRecv(const esp_now_recv_info_t * info, const uint8_t *data, int data_len) {

  76.   memcpy(&myData, data, sizeof(myData));

  77.   char macStr[18];

  78.   snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",

  79.            info->src_addr[0], info->src_addr[1], info->src_addr[2], info->src_addr[3], info->src_addr[4], info->src_addr[5]);

  80.   Serial.print("Last Packet Recv from: "); Serial.println(macStr);

  81.   Serial.print("Last Packet Recv Data a: "); Serial.println(myData.a);

  82.   Serial.print("Last Packet Recv Data b: "); Serial.println(myData.b);

  83.   if(myData.a=='x')

  84.   {   

  85.     int v1=int(myData.b)-2400;

  86.     if(v1>0)

  87.       {

  88.      

  89.       MA2_Backward(); 

  90.        MB1_Forward();

  91.         

  92.       }

  93.       else{

  94. 

  95.         MA1_Forward();

  96.       MB2_Backward(); 

  97.       }

  98.   }

  99.   else{

  100.     if(myData.a=='y')

  101.     {

  102.     int v1=int(myData.b)-2600;

  103.     if(v1>0)

  104.       {

  105.       MA1_Forward();

  106.       MB1_Forward();

  107.         

  108.       }

  109.       else{

  110.        MA2_Backward(); 

  111.        MB2_Backward(); 

  112.       }

  113.     }

  114.     else{

  115.          if(myData.a=='s')

  116.            {

  117.             stop();

  118.             

  119.            } 

  120.     }

  121.   }

  122. }

  123. void MA1_Forward()

  124.     {

  125.          digitalWrite(IA1,HIGH);

  126.          digitalWrite(IA2,LOW);

  127.       }

  128. 

  129.     void MA2_Backward()

  130.     {

  131.         digitalWrite(IA2,HIGH);

  132.          digitalWrite(IA1,LOW);

  133.       }

  134. 

  135.     void MB1_Forward()

  136.     {

  137.          digitalWrite(IB2,HIGH);

  138.          digitalWrite(IB1,LOW);

  139.       }

  140. 

  141.     void MB2_Backward()

  142.     {

  143.         digitalWrite(IB1,HIGH);

  144.          digitalWrite(IB2,LOW);

  145.       }

  146.     void stop()

  147.     {

  148.       digitalWrite(IA1,LOW);

  149.       digitalWrite(IA2,LOW);

  150.       digitalWrite(IB1,LOW);

  151.       digitalWrite(IB2,LOW);

  152.     }

  153. void loop() {

  154.   // Chill

  155. }

  156. 

复制代码
【演示视频】


回复

使用道具 举报

精彩评论(1)

hnyzcj  版主

发表于 2024-3-31 12:07:28

哈哈哈哈，这个好玩
回复

使用道具 举报

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

本版积分规则

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

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主
勋章墙
活跃会员 宣传大使 创客造 编辑选择奖 志“童”道合 编辑选择奖 编辑选择奖 编辑选择奖

楼主的其它帖子

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

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

mail