Problème PCA9685 et servo moteurs

[math7189]

Bonjour à tous,

Je suis actuellement sur un projet de recréer un "wall-e". Je m'attaque à la tête qui comporte une caméra, celle-ci est attachée sur un systeme pan-tilt avec deux petits servo moteurs.

J'ai un module PCA9685 - https://www.sunfounder.com/pca9685-16-c ... river.html

J'ai utilisé les sources fournie pour tester. J'arrive bien à faire bouger les deux servo moteurs, cependant quelques minutes après avoir lancé mon test, l'un des servo fait un bruit bizarre, comme s'il bougeait et qu'il se bloquait (alors que le programme python ne tourne pas) et si je relance mon script, j'ai uniquement l'autre servo qui bouge et pas le deuxième (qui continue à faire du bruit d'ailleurs)

Avez-vous une idée sur la source de ce problème s'il vous plait?

Merci d'avance,

Math

[Etienne]

J'utilise aussi un module PCA9685 sans problème, mais je pilote directement les registres I2C en python sans passer par la librairie sunfounder.
Quand un servo fait du bruit sans bouger c'est à ma connaissance qu'il reçoit une consigne en dehors de ce qu'il est sensé supporter (largueur de l'impulsion pwm en dehors de la plage 1 à 2 ms), il se met alors en buté mécanique et le moteur force (c'est pas forcément très bon pour les engrenage en plastiques).
Il faut savoir qu'avec les servo low cost (du genre sg9 sur ebay), le respect des valeurs min et max du signal pwm et de la position ne sont pas rigoureusement respectés ni reproductibles d'un servo à l'autre.
Pour aller plus loin, il faudrait que tu postes ton code pour voir si les consignes sont bonnes.
As-tu permuté les servos pour voir si c'est un probleme lié à un servo qui serait défectueux ou a une différence de pilotage?

[math7189]

Salut Etienne,

Merci pour ta réponse. Je n'ai pas essayé de permuter les servo moteurs, je vais faire le test.

Voici le code que j'utilise:

Code: Select all

#!/usr/bin/python

from lib_servo_driver import PWM
import time

# ===========================================================================
# Example Code
# ===========================================================================

# Initialise the PWM device using the default address
pwm = PWM(0x40)
# Note if you'd like more debug output you can instead run:
#pwm = PWM(0x40, debug=True)

servoMin = 150  # Min pulse length out of 4096
servoMax = 600  # Max pulse length out of 4096

def setServoPulse(channel, pulse):
  pulseLength = 1000000                   # 1,000,000 us per second
  pulseLength /= 60                       # 60 Hz
  print "%d us per period" % pulseLength
  pulseLength /= 4096                     # 12 bits of resolution
  print "%d us per bit" % pulseLength
  pulse *= 1000
  pulse /= pulseLength
  pwm.setPWM(channel, 0, pulse)

pwm.setPWMFreq(60)                        # Set frequency to 60 Hz
while (True):
  # Change speed of continuous servo on channel O
  pwm.setPWM(0, 0, servoMin)
  pwm.setPWM(1,0, servoMin)
  time.sleep(1)
  pwm.setPWM(0,0, servoMax)
  pwm.setPWM(1, 0, servoMax

Math

[joan]

60Hz = 16667µs per cycle.

150/4096 * 16667 = 610µs

600/4096 * 16667 = 2441µs

SAFE values are 1000µs to 2000µs

[Etienne]

Joan a raison, pour ma part je travaille à 50Hz (20 mSec de période) avec une valeur de pwm de 205 à 409 ce qui fait également de 1 à 2 msec.
A noter qu'il est préférable de couper proprement les PWM quand tu quittes le programme, sinon PCA9685 sort toujours son signal et les servos sont toujours asservis. pour cela il faut écrire 4096 dans les registres, je ne sait pas si la librairie que tu utilises le permet, à tester.

[math7189]

Je vais essayer avec tes valeurs Etienne. Par contre il n'y a pas de moyen dans ma lib d'écrire 4096 dans les registres lorsque je quitte le programme.

Penses-tu que cela puisse se rajouter facilement?

[math7189]

Etienne, en utilisant tes valeurs, les servos moteurs, ne bougent quasiment pas, j'ai juste des petits à coup. J'utilise le même code j'ai juste remplacé la freq et les valeurs min et max.

[Etienne]

c'est bizarre! Malheureusement, je n'ai pas de quoi tester en ce moment. Ce que je peux te proposer, c'est un bout de code exhumé de mes archives et modifié (sans possibilité de tests, mais un code dérivé fonctionnait chez moi) pour tester des servos sur les sorties 0 et 1 du PCA9685

Code: Select all

# -*- coding: latin-1 -*-
#sudo nano /etc/modules
#i2c-dev (verifier quela ligne est présente)
#sudo apt-get update
#sudo apt-get install i2c-tools
#sudo adduser pi i2c
#sudo reboot
#sudo i2cdetect -y 1 --> You should see something at i1c@ 0x40
#sudo apt-get install python-smbus
#i2c exemples ! http://embeddedmicro.weebly.com/raspberry-pi.html
import time
import smbus
bus = smbus.SMBus(1)

print "PCA9685 test"
#IC i2c address and register map
PCA1addr = 0x40
PWM_reg_start_addr = 0x06
freq = 50.0 #Hz
pwm_min = 205 
pwm_max = 409

def init_PCA9685 (i2c_addr, pwm_freq, debug):
        if debug: print "init PCA9685 at 0x%x address and %dHz frequency"% (i2c_addr, pwm_freq)
        bus.write_byte(0x00, 0x06)#SWRST reset the circuit
        prescale = int(25000000/freq/4096)
        bus.write_byte_data(i2c_addr, 0xfe, prescale)  #PRESCALE 121 -> 50 Hz / 60 -> 100 Hz / 32 -> 185 Hz
        bus.write_byte_data(i2c_addr, 0x00, 0b00100001) #MODE1 put SLEEP bit to 0 and  AI autoincrement to 1
        if debug:
                print " - MODE1 =", bin(bus.read_byte_data(i2c_addr, 0x00)),
                a=bus.read_byte_data(i2c_addr, 0xfe)
                print " - PRESCALE =",  a
                f = 25000000/(4096*(float(a+1)))
                print " - freq =", f, " Hz  -  periode =", 1000/f, "msec"
        return()

def write_PCA9685 (i2c_addr, reg_addr, data_list, debug):
        list=[]
        for a in range(len(data_list)):
                list.append(data_list[a] - 256*int(data_list[a]/256))
                list.append(int(data_list[a]/256))
        bus.write_i2c_block_data(i2c_addr, reg_addr, list)
        return

init_PCA9685 (PCA1addr, freq, debug_flag)

for a in range (pwm_min, pwm_max):
        pwm_values = [0, a, 0, a]
        write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values, debug_flag)
        time.sleep(0.02)

for a in range (pwm_min, pwm_max):
        pwm_values = [0, a, 0, a]
        write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values, debug_flag)
        time.sleep(0.02)

pwm_values = [0, 4096, 0, 4096]
write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values, debug_flag)
print "end of test"

peut être cela pourra-t-il t'aider? Seule est utilisée la lib smbus pour écrire dans les registres.

[math7189]

Salut Etienne, merci pour ton code, ça marche niquel. Seul petit problème une fois le code terminé, je perds le contrôle du Rasp, je suis en SSH et je perds la connexion, je dois rebooter. Je ne sais pas si cela vient du code ou si j'ai un autre problème.

[Etienne]

nouvelle version de mon code sans la variable debug (peut être est-ce lié à ton pb, en tout cas c’était une erreur):

Code: Select all

# -*- coding: latin-1 -*-
#sudo nano /etc/modules
#i2c-dev (verifier quela ligne est présente)
#sudo apt-get update
#sudo apt-get install i2c-tools
#sudo adduser pi i2c
#sudo reboot
#sudo i2cdetect -y 1 --> You should see something at i1c@ 0x40
#sudo apt-get install python-smbus
#i2c exemples ! http://embeddedmicro.weebly.com/raspberry-pi.html
import time
import smbus
bus = smbus.SMBus(1)

print "PCA9685 test"
#IC i2c address and register map
PCA1addr = 0x40
PWM_reg_start_addr = 0x06
freq = 50.0 #Hz
pwm_min = 205 
pwm_max = 409

def init_PCA9685 (i2c_addr, pwm_freq):
        bus.write_byte(0x00, 0x06)#SWRST reset the circuit
        prescale = int(25000000/freq/4096)
        bus.write_byte_data(i2c_addr, 0xfe, prescale)  #PRESCALE 121 -> 50 Hz / 60 -> 100 Hz / 32 -> 185 Hz
        bus.write_byte_data(i2c_addr, 0x00, 0b00100001) #MODE1 put SLEEP bit to 0 and  AI autoincrement to 1
        return()

def write_PCA9685 (i2c_addr, reg_addr, data_list):
        list=[]
        for a in range(len(data_list)):
                list.append(data_list[a] - 256*int(data_list[a]/256))
                list.append(int(data_list[a]/256))
        bus.write_i2c_block_data(i2c_addr, reg_addr, list)
        return

init_PCA9685 (PCA1addr, freq)

for a in range (pwm_max, pwm_min):
        pwm_values = [0, a, 0, a]
        write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values)
        time.sleep(0.02)

for a in range (pwm_max, pwm_min):
        pwm_values = [0, a, 0, a]
        write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values)
        time.sleep(0.02)

pwm_values = [0, 4096, 0, 4096]
write_PCA9685(PCA1addr, PWM_reg_start_addr, pwm_values)
print "end of test"

[math7189]

Pas mieux, même pire, il reboot direct après avoir écrit les lignes:

PCA9685 test
packet_write_wait:

[Etienne]

? il reboot !... pas facile le diagnostique à l'aveugle, j'ai trouvé une erreur dans mon script ligne 25 :

Code: Select all

        prescale = int(25000000/pwm_freq/4096)

normalement il doit y avoir un message d'erreur. Y a t il d'autres programmes qui tournent? d'autres circuits sur le bus i2c?
Tu peux mettre des "print" pour voir si ça plante à l'appel de la fonction d'init ou après?

[math7189]

Je ne comprends pas maintenant le programme ne marche plus du tout, en ajoutant des print dans les fonctions, il affiche bien l'ensemble des print jusqu'à la fin du programme, mais les servos ne bougent pas. Pourtant en utilisant la lib ils marchent.

Y aurait-il quelque chose qui se serait désactivé qui fait que je ne peux plus controler avec SMBUS?

[math7189]

Après un apt-get upgrade et apt-get update, le programme fonctionne à nouveau et cette fois ci il ne crash plus!

Je vais pouvoir m'amuser un peu avec maintenant! Sinon j'ai une dernière petite question, connais-tu un moyen de passer un angle plutôt que le pulse? Ca serait plus simple pour les mouvements de la tête du robot.

[Etienne]

En théorie, 205 correspond à 0 degré et 409 à 180 degrés (ou l'inverse suivant le sens que tu considères).
il suffit donc de faire une fonction de conversion du genre:

Code: Select all

pwm_min = 205
pwm_max = 409

pwm = deg*(pwm_max - pwm_min)/180+pwm_min
if pwm < 205: pwm = pwm_min   # evite de depasser la valeur min du servo
if pwm > 409: pwm = pwm_max  # evite de depasser la valeur max du servo

après, les valeurs min max et 180 degres sont succeptibles de varier en fonction du servo, il faut donc les étalonner.

[math7189]

Merci beaucoup Etienne pour ton aide! J'ai encore quelques soucis parfois quand je lance le programme, je retombe dans le cas où je perds a connexion en pleine execution.

Je vais essayer de voir si cela provient d'ailleurs.

Merci pour ton aide.

Math

[trolly]

Bonjour,
désolé pour le UP,

Mais je vais développer mon robot avec un raspberry pi, et un contrôleur PCA9685.

Est ce quelqu'un peut m'expliquer comment je devrai le connecter au raspberry ?

[Etienne]

commence par piloter un servo, exemple d'instruction avec plan de câblage: https://learn.adafruit.com/adafruit-16- ... p?view=all.