Déclencheur

J'ai eu SparkFun moto: bit qui est une sorte de pilote de moteur pour micro: bit.

Elle peut être moins chère que la carte de commande de moteur de Kitronik, mais lorsque vous regardez la base, GPIO est directement connecté au circuit de commande de moteur. Ça ne ressemble pas à ça. Si vous vous référez au Schéma du circuit, le PSoC traite les instructions envoyées par I2C et le pilote du moteur Il semble que ce soit devenu une chose intelligente à contrôler.

C'est bien de pouvoir contrôler le moteur sans consommer d'autres broches d'E / S, mais l'interface d'utilisation n'est fournie que par le Makecode de Microsoft. Je voulais l'utiliser à partir de MicroPython, j'ai donc regardé l'implémentation du bloc pour Makecode pour voir comment I2C le contrôle.

La source du bloc moto: bit (TypeScript) se trouve ci-dessous.

https://github.com/sparkfun/pxt-moto-bit/blob/master/motobit.ts

Résultats du sondage

Adresse I2C

L'adresse I2C est 0x59 (89)

Format des informations de contrôle envoyées par I2C

Toutes sont des configurations à 2 octets. Le premier octet est le type de contrôle et le deuxième octet est le paramètre.

Spécifier la vitesse

Lors de la spécification de la vitesse du moteur gauche (LEFT MOTOR), le premier octet est 0x21, et lors de la spécification de la vitesse du moteur droit (RIGHT MOTOR), le premier octet est 0x20.

Dans le deuxième octet, spécifiez le sens de déplacement et la vitesse.

Transférer si le bit le plus significatif est 1.

Spécifiez la vitesse avec les 7 bits inférieurs 0-127 (plus la vitesse est élevée, plus rapide)

Le bit le plus significatif est 0: inverse

Spécifiez la vitesse avec les 7 bits inférieurs 0-127 (plus la vitesse est élevée, plus la vitesse est lente)

La vitesse spécifiée dans le bloc Makecode est de 0 à 100 (plus elle est grande, plus elle est rapide), et elle est mappée à 0-127 pour le contrôle.

Désignation d'inversion du sens de déplacement

Il existe une spécification pour inverser le mouvement avant / arrière du moteur.

Le premier octet est 0x13 lorsque le moteur gauche (LEFT MOTOR) est inversé et le premier octet est 0x12 lorsque le moteur droit (RIGHT MOTOR) est inversé. 　 Le deuxième octet est la spécification de l'inversion / non-inversion. S'il vaut 1, c'est l'inversion, et s'il vaut 0, l'inversion est arrêtée (restaurée).

Spécifier s'il faut activer / désactiver le moteur

Lors de l'activation / désactivation du moteur, le premier octet est 0x70.

Le deuxième octet est la spécification d'activation / désactivation. S'il vaut 1, il sera activé et s'il vaut 0, il sera désactivé.

C'est pourquoi j'ai créé la bibliothèque MycroPython

Code source

from microbit import i2c


class Motor:
    # command
    LEFT = 0x21
    RIGHT = 0x20
    LEFT_INVERT = 0x13
    RIGHT_INVERT = 0x12
    ENABLE = 0x70

    # direction
    FORWARD = 0x80
    REVERSE = 0x00

    # i2c
    _I2C_ADDR = 0x59
    _I2C_SDA = 20
    _I2C_SCL = 19
    _i2c_buf = bytearray(2)

    def __init__(self, motor):
        self.motor = motor

    def set_speed(self, speed, direction=FORWARD):
        pwr = speed * 127 // 100
        Motor._i2c_buf[0] = self.motor
        Motor._i2c_buf[1] = (pwr | direction) \
                            if direction == Motor.FORWARD else (127 - pwr)
        i2c.write(Motor._I2C_ADDR, Motor._i2c_buf)

    def invert(self, invert):
        if self.motor == Motor.LEFT:
            Motor._i2c_buf[0] = Motor.LEFT_INVERT
        else:
            Motor._i2c_buf[0] = Motor.RIGHT_INVERT
        Motor._i2c_buf[1] = int(invert)
        i2c.write(Motor._I2C_ADDR, Motor._i2c_buf)

    @staticmethod
    def enable():
        Motor._i2c_buf[0] = Motor.ENABLE
        Motor._i2c_buf[1] = 1
        i2c.write(Motor._I2C_ADDR, Motor._i2c_buf)

    @staticmethod
    def disable():
        Motor._i2c_buf[0] = Motor.ENABLE
        Motor._i2c_buf[1] = 0
        i2c.write(Motor._I2C_ADDR, Motor._i2c_buf)


motor_left = Motor(Motor.LEFT)
motor_right = Motor(Motor.RIGHT)

J'ai également mis la source sur github.

https://github.com/MinoruInachi/micropython-microbit-mylib/blob/master/motobit.py

Comment utiliser

Importation de module

import motobit

API

motobit.Motor.enable()

Activez le moteur.

motobit.motor_left.set_speed(speed, direction=Motor.FORWARD)

Réglez la vitesse du moteur gauche. speed: Spécifiez la vitesse du moteur de 0 à 100. 100 est la vitesse maximale direction: Avancez avec le moteur AVANT, reculez avec le moteur.

motobit.motor_right.set_speed(speed, direction=Motor.FORWARD)

Règle la vitesse du moteur droit. speed: Spécifiez la vitesse du moteur de 0 à 100. 100 est la vitesse maximale direction: Avancez avec le moteur AVANT, reculez avec le moteur.

motobit.motor_left.invert(invert)

Définissez s'il faut inverser le sens de déplacement du moteur gauche. invert: True --Invert, False --Ne pas inverser

motobit.motor_left.invert(invert)

Définissez s'il faut inverser le sens de marche du moteur droit. invert: True - défini pour inverser, False - pas défini pour inverser

motobit.Motor.disable()

Désactivez le moteur.

Exemple de code

Faites la même chose dans MicroPython que "Expérience 1: Conduire et tourner" sur le site SparkFun C'est le code que j'ai écrit.

from microbit import button_a, sleep
from microbot import *

while True:
    if button_a.is_pressed():
        Motor.enable()
        motor_left.set_speed(100)
        motor_right.set_speed(100)
        sleep(1000)
        motor_left.set_speed(100, Motor.REVERSE)
        motor_right.set_speed(100)
        sleep(200)
        motor_left.set_speed(100)
        motor_right.set_speed(100)
        sleep(1000)
        Motor.disable()

De côté

micro: kit bot en utilisant cette moto: le bit va dans la direction ARRIÈRE en avant et dans la direction AVANT en marche arrière. Je vais. Au début, je me suis demandé s'il n'avait pas été assemblé correctement, mais la [Vidéo expérimentale] de SparkFun (https://youtu.be/EL4c4ujjQ48) fonctionne également de cette façon. C'est terrible.
Quand j'ai utilisé microbit.i2c.init () dans la documentation MicroPython, j'ai eu une erreur si elle n'était pas définie. Eh bien, les valeurs par défaut (freq = 100000, sda = pin20, scl = pin19) sont correctes. Selon l'histoire de github, il a été ajouté le 11/11/2016, mais il semble qu'il ne se soit pas encore reflété dans l'environnement de développement.
C'est dommage que la documentation MicroPython n'ait pas été traduite en japonais sur le site officiel de ~~ micro: bit. Auto-traduction est disponible. ~~ document japonais était officiellement lié.

SparkFun moto: opération bit I2C et utilisation à partir de MicroPython