HS-F27-L 4가지 라인 모터 8가지 서보 모듈 확장 보드

HS-F27-L 4가지 라인 모터 8가지 서보 모듈 확장 보드

1、소개

电机 제어를 실현합니다: I2C 인터페이스를 통해 외부 마이크로컨트롤러와 연결되어, PCA9685 칩을 통해 PWM 신호를 출력하여, 네 개의 MOC PF 모터의 속도 등의 파라미터를 제어합니다。8PIN 인터페이스: 8개의 핀 인터페이스를 제공하여 센서, 다른 컨트롤러 또는 기능을 확장할 수 있으며, 시스템의 추가 확장 및 통합에 편리하다.

2、시뮬레이션 그래프

3、모듈 매개변수

핀 이름

설명

G

GND(전원 입력 부정极)

V

VCC(전원 입력 정극)

SDA

데이터핀

SCL

시계핀

  • 전원 공급 전압: 3.3V-5V

  • 연결 방식: PH2.0 4P 핀 라인

  • 설치 방법:乐乐고 구축

4、회로판 크기

5、Arduino 라이브러리 추가

Arduino 환경 라이브러리 설치 단계:참고 링크

Arduino 환경 라이브러리: 클릭하여 다운로드

미스키 UNO 개발판 라이브러리 설치 단계(코드 사용 전 미스키 라이브러리를 다운로드하고 설치하세요):참고 링크

6、한국어로 MicroPython 환경 라이브러리 파일 추가

미스키 ESP32 개발 보드 라이브러리 파일 다운로드 및 설치 단계（코드 사용 전 먼저 미스키 라이브러리 파일을 다운로드 및 설치하세요）：참고 링크

7、아두이노 IDE 예제 프로그램

예제 프로그램(UNO 개발보드)：다운로드 클릭

#include "Wire.h"
#include "Adafruit_PWMServoDriver.h"
Adafruit_PWMServoDriver PWM = Adafruit_PWMServoDriver(0x40);

void setup(){
  PWM.begin();
  PWM.setPWMFreq(85);
}

void loop(){
  PWM.setPWM(0,0,0);
  PWM.setPWM(1,0,2048);
  PWM.setPWM(2,0,0);
  PWM.setPWM(3,0,2048);
  PWM.setPWM(4,0,0);
  PWM.setPWM(5,0,2048);
  PWM.setPWM(6,0,0);
  PWM.setPWM(7,0,2048);
  for (int i = 0; i <= 180; i = i + (1)) {
    PWM.setPWM(8,0,(map(i, 0, 180, 140, 680)));
    PWM.setPWM(9,0,(map(i, 0, 180, 140, 680)));
    PWM.setPWM(10,0,(map(i, 0, 180, 140, 680)));
    PWM.setPWM(11,0,(map(i, 0, 180, 140, 680)));
    delay(50);
  }

}

예제 프로그램 (ESP32 개발판):

from machine import I2C, Pin
import time
from mixpy import math_map


PCA9685_MODE1      = 0x00
PCA9685_MODE2      = 0x01
PCA9685_LED0_ON_L  = 0x06
PCA9685_LED0_ON_H  = 0x07
PCA9685_LED0_OFF_L = 0x08
PCA9685_LED0_OFF_H = 0x09
PCA9685_ALLLED_ON_L  = 0xFA
PCA9685_ALLLED_ON_H  = 0xFB
PCA9685_ALLLED_OFF_L = 0xFC
PCA9685_ALLLED_OFF_H = 0xFD
PCA9685_PRESCALE     = 0xFE

MODE1_ALLCAL  = 0x01
MODE1_SUB3    = 0x02
MODE1_SUB2    = 0x04
MODE1_SUB1    = 0x08
MODE1_SLEEP   = 0x10
MODE1_AI      = 0x20
MODE1_EXTCLK  = 0x40
MODE1_RESTART = 0x80

MODE2_OUTNE_0 = 0x01
MODE2_OUTNE_1 = 0x02
MODE2_OUTDRV  = 0x04
MODE2_OCH     = 0x08
MODE2_INVRT   = 0x10


PCA9685_I2C_ADDRESS       = 0x40
FREQUENCY_OSCILLATOR_HZ   = 25_000_000
PRESCALE_MIN = 3
PRESCALE_MAX = 255


class PCA9685:
    def __init__(self, i2c: I2C, addr: int = PCA9685_I2C_ADDRESS):
        self.i2c = i2c
        self.addr = addr
        self._oscillator_freq = FREQUENCY_OSCILLATOR_HZ

    def _write8(self, reg: int, val: int):
        self.i2c.writeto_mem(self.addr, reg, bytes([val & 0xFF]))

    def _read8(self, reg: int) -> int:
        return self.i2c.readfrom_mem(self.addr, reg, 1)[0]

    def _write4(self, base_reg: int, on: int, off: int):
        buf = bytearray(4)
        buf[0] = on & 0xFF
        buf[1] = (on >> 8) & 0x0F
        buf[2] = off & 0xFF
        buf[3] = (off >> 8) & 0x0F
        self.i2c.writeto_mem(self.addr, base_reg, buf)

    def begin(self):
        self.reset()
        mode1 = self._read8(PCA9685_MODE1)
        self._write8(PCA9685_MODE1, mode1 | MODE1_AI)
        self.set_output_mode(True)

    def reset(self):
        self._write8(PCA9685_MODE1, MODE1_RESTART)  # 写 RESTART
        time.sleep_ms(10)

    def sleep(self):
        m1 = self._read8(PCA9685_MODE1)
        self._write8(PCA9685_MODE1, m1 | MODE1_SLEEP)
        time.sleep_ms(5)

    def wakeup(self):
        m1 = self._read8(PCA9685_MODE1)
        self._write8(PCA9685_MODE1, m1 & (~MODE1_SLEEP))
        time.sleep_ms(5)

    def set_output_mode(self, totempole: bool = True):
        m2 = self._read8(PCA9685_MODE2)
        if totempole:
            m2 |= MODE2_OUTDRV
        else:
            m2 &= ~MODE2_OUTDRV
        self._write8(PCA9685_MODE2, m2)

    def set_oscillator_frequency(self, freq_hz: int):
        self._oscillator_freq = int(freq_hz)

    def get_oscillator_frequency(self) -> int:
        return self._oscillator_freq

    def set_pwm_freq(self, freq_hz: float):
        if freq_hz < 1.0:
            freq_hz = 1.0
        if freq_hz > 3500.0:
            freq_hz = 3500.0

        prescaleval = ((self._oscillator_freq / (freq_hz * 4096.0)) + 0.5) - 1.0
        if prescaleval < PRESCALE_MIN:
            prescaleval = PRESCALE_MIN
        if prescaleval > PRESCALE_MAX:
            prescaleval = PRESCALE_MAX
        prescale = int(prescaleval)

        oldmode = self._read8(PCA9685_MODE1)
        newmode = (oldmode & ~MODE1_RESTART) | MODE1_SLEEP
        self._write8(PCA9685_MODE1, newmode)
        self._write8(PCA9685_PRESCALE, prescale)
        self._write8(PCA9685_MODE1, oldmode)
        time.sleep_ms(5)
        self._write8(PCA9685_MODE1, oldmode | MODE1_RESTART | MODE1_AI)

    def read_prescale(self) -> int:
        return self._read8(PCA9685_PRESCALE)

    def set_pwm(self, ch: int, on: int, off: int):
        base = PCA9685_LED0_ON_L + 4 * ch
        self._write4(base, on & 0x1FFF, off & 0x1FFF)

    def set_pin(self, ch: int, val: int, invert: bool = False):
        if val < 0:
            val = 0
        if val > 4095:
            val = 4095

        if invert:
            if val == 0:
                self.set_pwm(ch, 4096, 0)   # fully ON
            elif val == 4095:
                self.set_pwm(ch, 0, 4096)  # fully OFF
            else:
                self.set_pwm(ch, 0, 4095 - val)
        else:
            if val == 4095:
                self.set_pwm(ch, 4096, 0)  # fully ON
            elif val == 0:
                self.set_pwm(ch, 0, 4096)  # fully OFF
            else:
                self.set_pwm(ch, 0, val)

    def write_microseconds(self, ch: int, us: int):
        prescale = self.read_prescale() + 1
        us_per_bit = (1_000_000.0 * prescale) / float(self._oscillator_freq)
        ticks = int(us / us_per_bit + 0.5)
        if ticks < 0:
            ticks = 0
        if ticks > 4095:
            ticks = 4095
        self.set_pwm(ch, 0, ticks)


i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

PWM = PCA9685(i2c, addr=0x40)

PWM.begin()

PWM.set_pwm_freq(50)
while True:
    PWM.set_pwm(0,1,4095)
    PWM.set_pwm(1,1,2000)
    PWM.set_pwm(2,1,4095)
    PWM.set_pwm(3,1,2000)
    PWM.set_pwm(4,1,4095)
    PWM.set_pwm(5,1,2000)
    PWM.set_pwm(6,1,4095)
    PWM.set_pwm(7,1,2000)
    PWM.set_pwm(8,  0, int(math_map(90, 0, 180, 140, 680)))
    time.sleep(5)
    PWM.set_pwm(0,1,2000)
    PWM.set_pwm(1,1,2000)
    PWM.set_pwm(2,1,2000)
    PWM.set_pwm(3,1,2000)
    PWM.set_pwm(4,1,2000)
    PWM.set_pwm(5,1,2000)
    PWM.set_pwm(6,1,2000)
    PWM.set_pwm(7,1,2000)
    PWM.set_pwm(8,  0, int(math_map(0, 0, 180, 140, 680)))
    time.sleep(5)

8、미스키 Mixly 예제 프로그램(그래픽 언어)

예제 프로그램(UNO 개발판)：다운로드 클릭

예제 프로그램(ESP32 개발 보드)：다운로드 클릭

9、테스트 환경 구축

Arduino UNO 테스트 환경 구축

부품 준비：“

  • UNO-R3 개발 보드 *1

  • UNO-R3 EXP 확장판 *1

  • USB type-c 데이터 케이블 *1

  • HS-F27 4로 전기 모터 8로 서보 모터 확장 보드*1

  • PH2.0 4P둘쪽 머리 끝 케이블 *1

  • 6-9V 배터리 상자*1

  • 레고 전기 모터*4

  • 서보 모터*4

전기 연결도):

ESP32 Python 테스트 환경 구축

10、비디오 강의

Arduino UNO 비디오 강의：시각화 클릭

ESP32 Python 비디오 강의：

11、테스트 결과

Arduino UNO 테스트 결과：

코딩을 내리고, 해당 모듈을 연결한 후, 전원을 켜면 모터와 서보모터가 동시에 회전합니다.

粤ICP备2026021056号 © 2020-2026 Hellostem 모든 권리 보호됨, Hellostem에 의해 만들어짐