Hoe je een servomotor bestuurt met de Raspberry Pi

ⓘ Cet article peut avoir été partiellement ou totalement traduit à l'aide d'outils automatiques. Nous nous excusons des erreurs que cela pourrait engendrer.

Deze tutorial is het derde deel van een bestand gewijd aan het ontdekken van elektronica met de Raspberry Pi. Als je het nog niet hebt gelezen, raad ik je aan om de eerste tutorial om een LED te besturen met de Raspberry Pi te raadplegen, evenals de tweede tutorial om een RFID-lezer te gebruiken met de Raspberry Pi.

Bij het starten van domotica is het een klassieke behoefte om fysieke bewegingen in werkelijkheid vanuit een programma te sturen.

In deze tutorial zullen we zien hoe je de Raspberry Pi kunt gebruiken om een servomotor aan te sturen.

Accessoires voor het aansturen van een servomotor

Om deze tutorial te kunnen volgen en een servomotor aan te sturen hebben we het volgende materiaal nodig:

• Een Raspberry Pi
• Zijn dieet
• Micro SD kaart
• Een servomotor (we zullen een SG90 gebruiken)
• Dupont kabels en weerstanden

Wat is het verschil tussen motor, servomotor en stappenmotor?

Laten we, voordat we beginnen met het aansluiten van onze servomotor op onze Raspberry Pi, eens kijken naar de verschillende soorten motoren die conventioneel in elektronica worden gebruikt.

Zonder in details te treden, kunnen we de motoren die in de elektronica worden gebruikt grofweg in drie categorieën verdelen:

• De motor: hij draait zolang hij wordt aangedreven. Het is geschikt als u een continue beweging wilt uitvoeren die geen grote precisie vereist.
• De stappenmotor: hij draait met een soort kleine opeenvolgende sprongen. Dat wil zeggen dat je hem bijvoorbeeld kunt vragen om 50 sprongen of 112 sprongen te maken, wat overeenkomt met een bepaalde beweging (bijvoorbeeld een kwartslag). Het is geschikt wanneer je met hoge precisie een continue beweging wilt maken (ze worden bijvoorbeeld gebruikt in 3D-printers).
• De servomotor: hij draait onder een bepaalde hoek, gedefinieerd volgens een PWM-signaal (Pulse Width Modulation). Vaak zijn kleine motoren beperkt en kunnen ze niet meer dan één omwenteling maken. Ze worden daarom eerder gebruikt voor een korte beweging met grote precisie.

Er zouden nog veel andere dingen te zeggen zijn over deze verschillende motoren, maar we zullen dan ingaan op mechanische vragen die ver buiten het bestek van onze tutorial vallen.

In ons geval gaan we een servomotor gebruiken omdat dit de gemakkelijkste precisiemotor is om vanaf een Raspberry Pi te besturen.

Sluit een servomotor aan op de Raspberry Pi

Het eerste dat u moet doen om onze servomotor te kunnen gebruiken, is deze op de Raspberry Pi aansluiten.

De actuatoren hebben 3 elektrische connectoren. Kleuren kunnen variëren afhankelijk van de fabrikant, maar over het algemeen vindt u zoiets als:

• Een rode draad, die dient als voeding.
• Een zwarte of bruine draad, die dient als GDN.
• Een andere draad, die wordt gebruikt om het PWM-signaal te verzenden dat de positie van de motor bestuurt.

We gaan daarom deze verschillende kabels aansluiten op de Raspberry Pi, de rode draad op een 5 volt GPIO poort en de zwarte op een GND poort.

Voor de PWM-poort daarentegen, zullen we deze noodzakelijkerwijs moeten aansluiten op de 12e GPIO-pin van de Raspberry Pi. Het is inderdaad de enige GPIO-pin die standaard een PWM-signaal ondersteunt.

Dus je zou een montage als deze moeten hebben.

Let op, hier voeden we onze servomotor rechtstreeks vanaf de Raspberry Pi. Dit werkt omdat we een zeer kleine servomotor gebruiken, maar op een groter model hebben we een speciale voeding nodig.

Bedien de servomotor in de opdrachtregels

Nu we onze servomotor hebben aangesloten, kunnen we deze rechtstreeks vanaf de Raspberry Pi-opdrachtregel besturen.

Om dit te doen, beginnen we met het activeren van de PWM-modus op poort 12, d.w.z. GPIO 18 volgens de processornummering.

gpio -o mode 18 pwm

En we zullen de Mark / Space-modus van PWM activeren, waardoor we een signaal kunnen hebben dat meer geschikt is voor ons gebruik.

gpio pwm-ms

Ten slotte zullen we de duur van een cyclus configureren, de te gebruiken frequenties, enz.

De servomotor is ingesteld om te werken met een frequentie van 50 Hz, d.w.z. 20 ms. Het Raspberry Pi-signaal werkt op een andere frequentie, 19,2 MHz. Met behulp van deze twee cijfers kunnen we een periode en een bereik berekenen (dankzij ramboise314.fr voor de formule):

50 = 19.2 * 10^6 / 192 / 2000

We zullen daarom de Raspberry Pi instellen om deze waarden te gebruiken:

gpio pwmc 192
gpio pwmr 2000

Eindelijk kunnen we onze motor in beweging krijgen! Merk op dat we geen hoek doorgeven aan de servomotor, maar een getal dat wordt omgezet in een hoek. Onze servomotor gaat van 0 ° tot 180 °. Na wat testen lijkt het erop dat 0 ° overeenkomt met 230, 90 ° met 150 en 180 ° met 70.

Om onze motor op 90 ° te sturen zullen we daarom het commando gebruiken:

gpio -g pwm 18 150

En we zullen 150 vervangen door 230 om naar 0 ° te gaan, 70 om naar 180 ° te gaan of een waarde daartussenin, zoals we nodig hebben.

Let op, deze kleine motoren ondersteunen een hoek van 180 ° op een precieze manier, maar ze hebben een kleine marge waardoor ze 190 ° of 200 ° kunnen maken en zelfs een volledige draai kunnen maken als je een voldoende lage waarde invoert. Het is specifiek voor elk motormodel.

Bestuur de servomotor met Python

Net als bij de vorige tutorials in deze serie, is het doel eerder om onze engine met Python te besturen in plaats van rechtstreeks vanaf de opdrachtregels. Ik ben van mening dat je nu de basis van Python hebt, als je de vorige tutorials niet leest, zijn er links beschikbaar aan het begin van dit artikel.

Om onze engine vanuit een Python-script te besturen, zullen we opnieuw de lib gebruiken Rpi.GPIO.

In Python en op de Pi wordt de motorhoek berekend als een percentage van de cyclus. Dit percentage wordt "Duty Cycle" genoemd.

Een signaal van 0,5 ms komt overeen met 0 ° en een signaal van 2,5 ms met 180 °. Wetende dat onze cyclus 50 Hz is, d.w.z. 20 ms, stelt dit ons in staat om de Duty Cycle voor 0 ° en 180 ° als volgt te berekenen:

x = 0.5 / 20
y = 2.5 / 20

We vinden dan dat de Duty Cycle die overeenkomt met 0 ° 0,025 of 2,5% is en dat degene die overeenkomt met 180 ° 0,125 of 12,5% is.

Klein probleem echter, als deze waarde theoretisch goed is, heeft het in feite de neiging om een volledige omwenteling van de motor voor 0 ° … Ik raad je daarom aan om 4% te gebruiken voor 0 °. De waarde 12,5% voor 180 is goed.

Om de motor te besturen, hoeven we alleen pin 12 in te stellen als ons PWM-signaal en de functies te gebruiken start en ChangeDutyCycle.

U kunt dus een bestand aanmaken servo.py en zet daar de volgende code:

#!/usr/bin/env python3
#-- coding: utf-8 --
import RPi.GPIO as GPIO
import time


#Set function to calculate percent from angle
def angle_to_percent (angle) :
    if angle > 180 or angle < 0 :
        return False

    start = 4
    end = 12.5
    ratio = (end - start)/180 #Calcul ratio from angle to percent

    angle_as_percent = angle * ratio

    return start + angle_as_percent


GPIO.setmode(GPIO.BOARD) #Use Board numerotation mode
GPIO.setwarnings(False) #Disable warnings

#Use pin 12 for PWM signal
pwm_gpio = 12
frequence = 50
GPIO.setup(pwm_gpio, GPIO.OUT)
pwm = GPIO.PWM(pwm_gpio, frequence)

#Init at 0°
pwm.start(angle_to_percent(0))
time.sleep(1)

#Go at 90°
pwm.ChangeDutyCycle(angle_to_percent(90))
time.sleep(1)

#Finish at 180°
pwm.ChangeDutyCycle(angle_to_percent(180))
time.sleep(1)

#Close GPIO & cleanup
pwm.stop()
GPIO.cleanup()

Het enige dat u hoeft te doen, is het script uitvoeren door het volgende te doen:

python3 ./servo.py

U zou dan uw motor moeten zien starten bij 0 °, dan naar 90 ° verschuiven en uiteindelijk stoppen bij 180 °.

Het enige dat u hoeft te doen, is dit script aan uw eigen behoeften aanpassen!