ESP32智能小车+PS2无线遥控器+麦克纳姆轮+microPython

已于 2023-10-26 15:55:10 修改
阅读量1k 收藏 11
点赞数 1
分类专栏： 单片机 文章标签： python 开发语言
于 2023-10-26 15:05:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwpoor123/article/details/134056575
版权 
from machine import Pin,PWM
from ps2 import PS2Controller
import time
import os

# #############################################
# PS2 遥控器
# #############################################
ps2ctl = PS2Controller(di_pin_no=26, do_pin_no=27, cs_pin_no=14, clk_pin_no=12)
ps2ctl.init()

# #############################################
# 小车轮子控制
# #############################################
pin1=PWM(Pin(19),freq=1000)  #左前 红1
pin2=PWM(Pin(18),freq=1000)
pin3=PWM(Pin( 5),freq=1000)  #左后 红3
pin4=PWM(Pin(17),freq=1000)
pin5=PWM(Pin(16),freq=1000)  #右前 黑5
pin6=PWM(Pin( 4),freq=1000)
pin7=PWM(Pin( 0),freq=1000)  #右后 黑7
pin8=PWM(Pin( 2),freq=1000)

#前进
def car_forward(speed):
  pin1.duty(speed)  #左前
  pin2.duty(0)
  pin3.duty(speed)  #左后
  pin4.duty(0)
  pin5.duty(speed)  #右前
  pin6.duty(0)
  pin7.duty(speed)  #右后
  pin8.duty(0)  

#后退、倒车、倒转
def car_back(speed):
  pin1.duty(0)     #左前
  pin2.duty(speed)
  pin3.duty(0)     #左后
  pin4.duty(speed)
  pin5.duty(0)     #右前
  pin6.duty(speed)  
  pin7.duty(0)     #右后
  pin8.duty(speed)  

# 普通左转 = 左前、左后后退， 右前、右后前进
def car_left(speed):
  pin1.duty(0)     #左前
  pin2.duty(speed)
  pin3.duty(0)     #左后
  pin4.duty(speed)
  pin5.duty(speed)     #右前
  pin6.duty(0)  
  pin7.duty(speed)     #右后
  pin8.duty(0)  

# 普通右转 = 左前、左后前进， 右前、右后后退  
def car_right(speed):
  pin1.duty(speed)   #左前
  pin2.duty(0)
  pin3.duty(speed)   #左后
  pin4.duty(0)
  pin5.duty(0)     #右前
  pin6.duty(speed)  
  pin7.duty(0)     #右后
  pin8.duty(speed)  

#停车、停止
def car_stop():
  pin1.duty(0)
  pin2.duty(0)
  pin3.duty(0)
  pin4.duty(0)
  pin5.duty(0)
  pin6.duty(0)
  pin7.duty(0)
  pin8.duty(0)

#  左平移=左前倒转、左后前进、右前前进、右后倒转
def car_left_pingyi(speed):
  pin1.duty(0)  #左前
  pin2.duty(speed)
  pin3.duty(speed)  #左后
  pin4.duty(0)
  pin5.duty(speed)  #右前
  pin6.duty(0)
  pin7.duty(0)  #右后
  pin8.duty(speed)  
  
#  右平移=左前前进、左后倒转、右前倒转、右后前进
def car_right_pingyi(speed):
  pin1.duty(speed)  #左前
  pin2.duty(0)
  pin3.duty(0)  #左后
  pin4.duty(speed)
  pin5.duty(0)  #右前
  pin6.duty(speed)
  pin7.duty(speed)  #右后
  pin8.duty(0) 

# 左上角 = 左前不动、左后前进、右前前进、右后不动
def car_left_up(speed):
  pin1.duty(0)  #左前
  pin2.duty(0)
  pin3.duty(speed)  #左后
  pin4.duty(0)
  pin5.duty(speed)  #右前
  pin6.duty(0)
  pin7.duty(0)  #右后
  pin8.duty(0)  
  
# 左下角 = 左前倒退、左后不动、右前不动、右后倒退
def car_left_down(speed):
  pin1.duty(0)  #左前
  pin2.duty(speed)
  pin3.duty(0)  #左后
  pin4.duty(0)
  pin5.duty(0)  #右前
  pin6.duty(0)
  pin7.duty(0)  #右后
  pin8.duty(speed)  
  
# 右上角 =  左前前进、左后不动、右前不动、右后前进
def car_right_up(speed):
  pin1.duty(speed)  #左前
  pin2.duty(0)
  pin3.duty(0)  #左后
  pin4.duty(0)
  pin5.duty(0)  #右前
  pin6.duty(0)
  pin7.duty(speed)  #右后
  pin8.duty(0)    
  
# 右下角 =  左前不动、左后倒退、右前倒退、右后不动
def car_right_down(speed):
  pin1.duty(0)  #左前
  pin2.duty(0)
  pin3.duty(0)  #左后
  pin4.duty(speed)
  pin5.duty(0)  #右前
  pin6.duty(speed)
  pin7.duty(0)  #右后
  pin8.duty(0)   
  
# ##################################################  
# 主循环开始！！！
# ##################################################
i=1  #循环次数
speed=400   #初始速度，最高1000. 低于400容易电压太低驱动不了
print("小车程序开始运行，正在等待PS2遥控器按键(按start停车)")
try:
  while True:

    key_car= ps2ctl.read_once()   # 收到的字符格式为 keys:UP,RIGHT: pos(lx,ly):0,-1: pos(rx,ry): 0,-1:
    #print("检测到按键：",key_car)    
    key_list= key_car.split(':')  # 用：来将字符串进行分割，写入数组key_list中
    # key_list[1]  输入的按键
    # key_list[3]  左摇杆坐标
    # key_list[5]  右摇杆坐标

    # 停止 = 遥控器 start = 4    
    if key_list[1]=="START" : 
      print(key_car," 停止.......")
      car_stop()

    # 前进 = 遥控器 左摇杆 上 = 5
    # 前进 = 遥控器 右摇杆 上 = 13    
    if key_list[1]=="UP" or key_list[1]=="TRIANGLE": 
      print(key_car," 前进")
      car_forward(speed)
      
    # 后退 = 遥控器 左摇杆 下 = 7 
    # 后退 = 遥控器 右摇杆 下 = 15          
    if key_list[1]=="DOWN" or key_list[1]=="CROSS": 
      print(key_car," 后退")
      car_back(speed)

    # 左平移 = 遥控器 左摇杆左 = 8
    if key_list[1]=="LEFT": 
      print(key_car," 左平移")
      car_left_pingyi(speed)
      
    # 右平移 = 遥控器 左摇杆右 = 6
    if key_list[1]=="RIGHT": 
      print(key_car," 右平移")
      car_right_pingyi(speed)
      
    # 左转 = 遥控器 右摇杆 左 = 16
    if key_list[1]=="SQUARE" : 
      print(key_car," 左转")
      car_left(speed)
    
    # 右转 = 遥控器 右摇杆 右 = 14
    if key_list[1]=="CIRCLE": 
      print(key_car," 右转")
      car_right(speed) 
      
    # 左上方 = 遥控器 左L1 = 11
    if key_list[1]=="UP,LEFT": 
      print(key_car," 左上方")
      car_left_up(speed) 
      
    # 左下方 = 遥控器 左L2 = 9
    if key_list[1]=="DOWN,LEFT": 
      print(key_car," 左下方")
      car_left_down(speed) 
      
    # 右上方 = 遥控器 右R1 = 12
    if key_list[1]=="UP,RIGHT": 
      print(key_car," 右上方")
      car_right_up(speed) 

    # 右下方 = 遥控器 右R2 = 10  
    if key_list[1]=="RIGHT,DOWN": 
      print(key_car," 右下方")
      car_right_down(speed) 
      
    # L1 加速
    if key_list[1]=="L1"  and speed<1000: 
      speed=speed+100
      print("当前速度已经加速至：",speed)
      
    # L2 减速
    if key_list[1]=="L2"  and speed>400: 
      speed=speed-100
      print("当前速度已经降低至：",speed)  
      
    # 右侧 三角+X，同时按下，删除main.py 取消自动启动
    if key_list[1]=="TRIANGLE,CROSS" : 
      os.remove("main.py")
      print("-----------  main.py 已经删除 ----------")       
      car_stop()

    # SELECT = 1    L3 = 2    R3 = 3    START = 4    
    # UP = 5    RIGHT = 6    DOWN = 7    LEFT = 8    
    # L2 = 9    R2 = 10    L1 = 11    R1 = 12
    # TRIANGLE = 13    CIRCLE = 14    CROSS = 15    SQUARE = 16
  
    i=i+1
    time.sleep(0.1)
    
except KeyboardInterrupt:
    print('KeyboardInterrupt 程序被人为中止....')
finally:
    pin1.deinit()
    pin2.deinit()
    pin3.deinit()
    pin4.deinit()
    pin5.deinit()
    pin6.deinit()
    pin7.deinit()
    pin8.deinit()    
    print('Exit 程序共运行了'+str(i)+'次，程序结束。')

需要用到ps2.py文件，可查看ESP32+PS2 无线手柄转接板+microPython-CSDN博客

 ps2.py

import time
from machine import Pin
 
class PS2Controller:
    # These are our button constants
    SELECT = 1
    L3 = 2
    R3 = 3
    START = 4
    UP = 5
    RIGHT = 6
    DOWN = 7
    LEFT = 8
    L2 = 9
    R2 = 10
    L1 = 11
    R1 = 12
    TRIANGLE = 13
    CIRCLE = 14
    CROSS = 15
    SQUARE = 16
    KEYS = dict([
                  (SELECT, "SELECT"),        (L3, "L3"),        (R3, "R3"),        (START, "START"),
                  (UP, "UP"),        (RIGHT, "RIGHT"),        (DOWN, "DOWN"),        (LEFT, "LEFT"),
                  (L2, "L2"),        (R2, "R2"),        (L1, "L1"),        (R1, "R1"),
                  (TRIANGLE, "TRIANGLE"),        (CIRCLE, "CIRCLE"),        (CROSS, "CROSS"),        (SQUARE, "SQUARE")  ])
 
    CTRL_CLK = 10
    CTRL_BYTE_DELAY = 16
 
    CMD_SHORT_POLL   = [0x01, 0x42, 0x00, 0x00, 0x00]
    CMD_ENTER_CONFIG = [0x01, 0x43, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00]
    CMD_SET_MODE     = [0X01, 0x44, 0x00,
                        0x01,  # 00 normal; 01 red or analog
                        0x03,  # 03 lock; ee no lock
                        0x00, 0x00, 0x00, 0x00]
    CMD_SET_BYTES_LARGE = [0x01, 0x4F, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00]
    CMD_EXIT_CONFIG     = [0x01, 0x43, 0x00, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A]
    CMD_ENABLE_RUMBLE   = [0x01, 0x4D, 0x00, 0x00, 0x01]
    CMD_TYPE_READ       = [0x01, 0x45, 0x00, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A]
    CMD_READ_DATA       = [0X01, 0X42, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00]
 
    MAX_READ_DELAY = 1500
 
    VALID_MODES = [0X41, 0X73]
 
    def __init__(self, di_pin_no=26, do_pin_no=27, cs_pin_no=14, clk_pin_no=12):  # DI=DAT、DO=CMD 可以在此处将针脚调整为你自己对应的针脚
        self.di_pin_no = di_pin_no
        self.do_pin_no = do_pin_no
        self.cs_pin_no = cs_pin_no
        self.clk_pin_no = clk_pin_no
        self.di  = Pin(self.di_pin_no, Pin.IN)  # DI = DAT
        self.do  = Pin(self.do_pin_no, Pin.OUT) # DO = CMD
        self.cs  = Pin(self.cs_pin_no, Pin.OUT)
        self.clk = Pin(self.clk_pin_no, Pin.OUT)
        self.buff_out = [0x01, 0x42]
        self.buff_in = [0] * 9
        self.pressed_keys = []
        self.read_delay = 1
        self.last_read_ms = 0
        self.lx = 0
        self.ly = 0
        self.rx = 0
        self.ry = 0
 
    @property
    def red_mode(self):  # analog mode
        return self.buff_in[1] & 0xf0 == 0x70
 
    def do_h(self):
        self.do.value(1)
 
    def do_l(self):
        self.do.value(0)
 
    def cs_h(self):
        self.cs.value(1)
 
    def cs_l(self):
        self.cs.value(0)
 
    def clk_h(self):
        self.clk.value(1)
 
    def clk_l(self):
        self.clk.value(0)
 
 
    # noinspection PyUnresolvedReferences
    def delay_byte(self):
        time.sleep_us(self.read_delay)
 
    # noinspection PyUnresolvedReferences
    def delay_clk(self):
        time.sleep_us(self.CTRL_CLK)
 
    # noinspection PyUnresolvedReferences
    def delay_read(self):
        time.sleep_us(self.CTRL_BYTE_DELAY)
        # time.sleep_ms(self.read_delay)
 
    def cmd(self, cmd):
        ret = 0
        for i in range(8):
            if cmd & 1 << i:
                self.do_h()
            else:
                self.do_l()
            self.clk_l()
            self.delay_clk()
            if self.di.value():
                ret |= 1 << i
            self.clk_h()
        self.do_h()
        self.delay_byte()
        return ret
 
    """
    :param 
    pure True means not delay
    """
 
    def cmd_group(self, cmds):
        self.cs_l()
        self.delay_byte()
        for cmd in cmds:
            self.cmd(cmd)
        self.cs_h()
        self.delay_read()
 
    def init(self):
        self.di  = Pin(self.di_pin_no, Pin.IN)
        self.do  = Pin(self.do_pin_no, Pin.OUT)
        self.cs  = Pin(self.cs_pin_no, Pin.OUT)
        self.clk = Pin(self.clk_pin_no, Pin.OUT)
        self.do_h()
        self.clk_h()
 
        self.read_once()
        self.read_once()
        #
        if self.buff_in[1] not in [0x41, 0x73]:
            print("control type not ok, expect 41 73 79, bug get ", "{:02x}".format(self.buff_in[1]))
            return 1
 
        self.read_delay = 1
 
        for i in range(10):
            # self.cmd_group(self.CMD_SHORT_POLL)
            # self.cmd_group(self.CMD_SHORT_POLL)
            # self.cmd_group(self.CMD_SHORT_POLL)
            self.cmd_group(self.CMD_ENTER_CONFIG)
            self.delay_byte()
 
            self.do_h()
            self.clk_h()
            self.cs_l()
 
            self.delay_byte()
            #
            temp = [0] * len(self.CMD_TYPE_READ)
            for j in range(9):
                for cmd in self.CMD_TYPE_READ:
                    temp[j] = self.cmd(cmd)
            self.cs_h()
 
            self.cmd_group(self.CMD_SET_MODE)
            # self.cmd_group(self.CMD_ENABLE_RUMBLE)
            self.cmd_group(self.CMD_EXIT_CONFIG)
            self.read_once()
            if self.buff_in[1] in self.VALID_MODES:
                print("read_delay configed,", self.read_delay)
                break
            else:
                self.read_delay += 1
                print("read_delay++,", self.read_delay)
 
    def reconfig(self):
        print("reconfig")
        self.cmd_group(self.CMD_ENTER_CONFIG)
        self.cmd_group(self.CMD_SET_MODE)
        self.cmd_group(self.CMD_EXIT_CONFIG)
 
    def p(self, debug=True):
        if debug:
            for d in self.buff_in:
                print("{:08b}".format(d))
 
        key_raw = (self.buff_in[4] << 8) | self.buff_in[3]
        for i in range(1, 17):
            if not key_raw & 1 << i - 1:
                self.pressed_keys.append(i)
 
        if self.red_mode:
            self.rx = self.buff_in[5] - 128
            self.ry = self.buff_in[6] - 128
            self.lx = self.buff_in[7] - 128
            self.ly = self.buff_in[8] - 128
        if self.pressed_keys:
            out = "keys:" + ','.join(self.KEYS[k] for k in self.pressed_keys) + "; "
        else:
            out = ""
        # for key in self.pressed_keys:
        #     print(key, self.KEYS[key])
        if self.red_mode and (out or any(x != 0 for x in [self.rx, self.ry, self.lx, self.ly])):
            out += "pos: (lx,ly):{},{};  (rx,ry): {},{}".format(self.lx, self.ly, self.rx, self.ry)
 
        if out:
            print(out)
 
    def read_once(self, debug=False):
        now = time.ticks_ms()
        delay = now - self.last_read_ms
        if delay > self.MAX_READ_DELAY:
            print(now, self.last_read_ms, delay)
            self.reconfig()
        elif delay < self.read_delay:
            # noinspection PyUnresolvedReferences
            time.sleep_ms(self.read_delay - delay)
 
        self.buff_in = [0] * 9
        self.pressed_keys.clear()
 
        for j in range(5):
            # for i in range(1):
            self.do_h()
            self.clk_h()
            self.cs_l()
            self.delay_byte()
 
            for i, c in enumerate(self.CMD_READ_DATA):
                self.buff_in[i] = self.cmd(c)
 
            self.cs_h()
 
            if self.buff_in[1] in self.VALID_MODES:
                break
            else:
                print("mode: {:08b}, retry_J: {}".format(self.buff_in[1], j))
                self.reconfig()
                self.delay_read()
        if self.buff_in[1] not in self.VALID_MODES and self.read_delay < 10:
            self.read_delay += 1
 
        self.last_read_ms = time.ticks_ms()
        #self.p(debug)
 
        #以下为自己添加 ，原P()内的代码
        key_raw = (self.buff_in[4] << 8) | self.buff_in[3]
        for i in range(1, 17):
            if not key_raw & 1 << i - 1:
                self.pressed_keys.append(i)
 
        if self.red_mode:
            self.rx = self.buff_in[5] - 128
            self.ry = self.buff_in[6] - 128
            self.lx = self.buff_in[7] - 128
            self.ly = self.buff_in[8] - 128
        if self.pressed_keys:      #注意下面这几行的:和,千万不要修改，后面要他们做标记分割使用！
            out = "keys:" + ','.join(self.KEYS[k] for k in self.pressed_keys) + ": "
        else:
            out = "keys:无:"
        # for key in self.pressed_keys:
        #     print(key, self.KEYS[key])
        if self.red_mode and (out or any(x != 0 for x in [self.rx, self.ry, self.lx, self.ly])):
            out += "pos(lx,ly):{},{}:  pos(rx,ry):{},{}:".format(self.lx, self.ly, self.rx, self.ry)
        if out:
            print(out)
            
        #return self.buff_in
        return out
 
'''
# 调用方法，将以下几行代码新建一个文件如：ps2_test.py
from ps2 import PS2Controller
import time
ps2ctl = PS2Controller(di_pin_no=26, do_pin_no=27, cs_pin_no=14, clk_pin_no=12)
ps2ctl.init()
while True:
    key_car= ps2ctl.read_once()   # 收到的字符格式为 keys:UP,RIGHT: pos(lx,ly):0,-1: pos(rx,ry): 0,-1:
    #print("检测到按键：",key_car)    
    key_list= key_car.split(':')  # 用：来将字符串进行分割，写入数组key_list中  key_list[1]输入的按键、key_list[3]左摇杆坐标、key_list[5]右摇杆坐标
    if key_list[1]=="UP": 
      print(key_car," 前进")
      
    if key_list[1]=="UP,LEFT": 
      print(key_car," 左上方")
    time.sleep(0.2)
'''

​

YuanlongWang
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
使用esp32cam和树莓派制作简易图传遥控器（基于UDP）
weixin_45179910的博客
09-23 5673
我们最近想开发一款图传小车，先用最简单最易上手的硬件，来自AI-Thinker的esp32cam来做图像采集、发送端，并使用树莓派来接收并显示吧。 小车端使用了esp32cam，这个模块非常好用，集成了wifi和摄像头，初测wifi性能还不错，在办公室环境下传480x320p的图像很流畅，偶尔卡顿是因为被水泥墙遮挡。 接收端使用树莓派4B加一块3.5寸的GPIO屏，这边应该是LCD屏走的SPI接口的原因就比较拉跨了，刷新率基本每秒一帧吧，后续换成HDMI的屏幕应该会好一些。不过好歹系统搭起来了.
STM32F103C8T6实现的麦克纳姆轮小车
12-25
STM32F103C8T6实现的麦克纳姆轮小车，资源包括AD工程源文件以及单片机程序，可以蓝牙或wifi控制
麦克纳姆轮运动原理_【带字幕视频】麦克纳姆轮你了解多少？ESP32的WIFI信号，居然能覆盖10公里？...
weixin_39602569的博客
11-11 430
DIY视频新更新【RM】机器人常用的麦克纳姆轮，你了解多少？麦克纳姆全向轮让机器人能够迅速准确地在赛场上全向移动。快来了解这种轮子的原理和特点吧！点击“阅读全文”免费播放【带字幕资料】ESP32的WIFI信号，居然能覆盖10公里？附带相关资料(代码、动画生成软件)下载点击“阅读全文”免费播放【带资料】物联网防跌倒轮椅！团队提出了一种智能坠落检测系统，以防止老年人在无人看管的情况下从轮...
基于ESP32的智能遥控小车
02-22
基于ESP32的智能遥控小车
23- ESP32 红外遥控 (RMT)
最新发布
m0_60134435的博客
05-03 1313
红外遥控是一种无线、非接触控制技术，具有抗干扰能力强，信息传输可靠，功耗低，成本低，易实现等显著优点。它被诸多电子设备特别是家用电器广泛采用，并越来越多的应用到计算机和手机系统中。红外遥控系统由发射和接收两大部分组成，应用编码/解码专用集成电路芯片来进行控制操作。发射部分包括键盘矩阵、编码调制、LED红外发送器；接收部分包括光、电转换放大器、解调、解码电路。红外遥控器通常使用特定的编解码协议来发送和接收数据。PWM（脉冲宽度调制）的NEC协议和（脉冲位置调制）的RC-5协议的。
基于esp32的智能遥控器
杀手的博客
03-25 8897
项目地址：https://gitee.com/killerp/off_asr 文章目录一，演示视频二，模块框架三，开发环境硬件环境软件环境四，模块简介1，语音模块语音识别语音播放2，蓝牙模块3，红外模块3.1 红外发射3.2 红外学习4，http模块4.1 语音合成4.2 天气接口4.3 获取网络时间4.4 更新token5，时间模块6，传感器模块7，按键模块 一，演示视频 二，模块框架 程序模块如图所示： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ac5MOEi6-16
老宇哥带你玩转 ESP32：14 亲自动手做一个双向通讯的无线遥控器（一）
karaxiaoyu的专栏
04-27 7009
今天我们来玩儿ESP-NOW。相信每个玩电子的童鞋对无线通信都非常感兴趣，从孩童时期的无线遥控赛车，到学生时期的收音机，到长大后接触的各种无线控制的家电，手机等电子产品，无线通信让我们可以像神话小说中的某些绝技，可以做到隔空控制，每个人都都希望将那个遥控器掌握在自己手中。无线遥控的本质就是发射端发射某个频率的电磁波出去，接收端接收并解码这个信号。我们经常接触的空调，电视，...
【ROS2机器人入门到实战】做个遥控车-订阅ROS2 Twist
生活不止眼前的苟且
08-31 1876
本节我们通过将小车接入MicroROS完成了一个遥控小车的开发。下一节我们开始使用编码器来测量轮子的转速。
STM32F103C8T6麦克纳姆轮（全向）智能小车各个方向运动程序源代码.rar
12-10
该程序源代码用于STM32F103C8T6麦克纳姆轮（全向）智能小车各个方向运动实验。 1、源代码开发软件：keil4； 2、程序对应处理器是：STM32F103C8T6； 3、智能小车电机驱动芯片是：L293D； 4、智能小车电机为：TT直流...
ESP32环境搭建资源（Thonny+MicroPython+ESP32）
01-09
ESP32是一款强大的微控制器，集成了Wi-Fi和蓝牙功能，广泛应用于物联网(IoT)开发。本资源包是为想要在ESP32上搭建Thonny IDE与MicroPython环境的用户准备的，旨在帮助初学者和专业人士轻松进行Python编程。 Thonny...
STM32F103C8T6+ESP8266+蓝牙的智能平衡小车
12-25
STM32F103C8T6+ESP8266+蓝牙的智能平衡小车，底盘采用的是亚博的底盘,资源包括电路设计AD文件以及单片机程序和Android APP程序
STM32+ESP8266+MQTT+阿里云 （嵌入式开发 ）
07-06
在嵌入式开发领域，将STM32微控制器与ESP8266 WiFi模块结合，利用MQTT消息传输协议，并接入阿里云物联网平台，可以构建一个高效、可靠的远程监控和控制系统。以下是对这些关键技术和组件的详细说明： 1. STM32（意...
物联网开发笔记（39）- 使用Micropython开发ESP32开发板之控制PS2摇杆
zhusongziye的博客
11-10 1575
使用Micropython开发ESP32开发板之控制PS2摇杆
ESP32（MicroPython） 麦克纳姆轮小车遥控
weixin_74155302的博客
06-01 691
本程序用于对麦克纳姆轮小车进行遥控，增加了RGB灯和转向定时器中断。
ESP32遥控器软硬件设计
weixin_44678052的博客
03-03 3078
做智能车 或者 四轴飞控怎么能少得了遥控器呢！在这里给大家分享一个简单的基于ESP32遥控器的设计，包括软硬件以及3D外壳。遥控器嘛，通信方式是最重要的，本设计支持WIFI、蓝牙 和 2.4G，基本上将入门阶段常用的融合了进来。
用microPython写一个基于esp32的可用ps2手柄遥控的小车代码
weixin_35750483的博客
02-14 707
下面是一个基于ESP32的MicroPython代码，它可以使用PS2手柄作为遥控器控制小车： from machine import Pin, PWM import time # 定义PS2手柄控制引脚 joystick_x = Pin(4) joystick_y = Pin(5) # 定义电机驱动引脚 motor_left = PWM(Pin(14), freq=1000, duty=0)...
PS4 + ESP32 制作无线遥控器
Qrpucp的博客
08-26 4389
使用 PS4 和 ESP32 制作无线遥控器
如何使用esp32从零制作一个ROS2的teleop遥控器（cmd_vel）
zhangrelay的专栏
10-19 1390
使用课程所用镜像，硬件连线如下图所示： 使用io口34和36，对应的arduino端口如下列表： static const uint8_t A0 = 36; static const uint8_t A3 = 39; static const uint8_t A4 = 32; static const uint8_t A5 = 33; static const uint8_t A6 = 34; static const uint8_t A7 = 35; static const uint8_t A
以小魔方遥控器为例，来看看ESP32-C2功能如何
wireless_tag的博客
01-12 533
设备可连接的最远距离是由设备可传输的最大功率和接收灵敏度决定的，或者是由允许传输的最低数据速率决定的。这也就是说，在“802.11b,1 Mbps”模式下达到20 dBm的输出功率，同时具有极好的接收灵敏度，就可以实现最远距离(通常情况下，为了满足FCC的认证要求会保留一些边界，比如达到19.5 dBm或再低些)。如果您的应用需求是追求最大化的物理距离，可以检查您选用的芯片在“802.11b,1 Mbps”模式下的接收灵敏度和传输功率，ESP32-C2已达到可允许的最大边界。一、射频性能拉满，成本却降。
esp32+micropython+openmv+homeassistant
03-30
I'm sorry, I do not understand the question. Can you please provide more context or specify what you would like to know about ESP32, MicroPython, OpenMV, and HomeAssistant?

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YuanlongWang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值