la.couenne

Re tous

 

Alors j'ai bien reçue ma fiche à monter soit-même, mais sans pince à sertir c'est juste impossible

 

Les connecteurs sont tellement proches, j'ai toujours eu 2 voir même 3 fils qui se touchent...

 

 

Du coup j'ai pris un fils HDMI qui se roule, j'ai enlevé l'enrouleur, et mis le tout comme ça:

C'est un fils plat, donc il est très souple et facile à installer..

 

Voilou pour les dernières infos  

Donc pour faire tourner la tête j'utilise le module PCA9685 , que je branche de cette façon:

 

Pour installer OpenCV sur le raspberry, dans la console taper:

 sudo apt-get install python-opencv

 sudo apt-get install libopencv-dev

 

Et maintenant pour la détection du visage en Python avec OpenCV:

#!/usr/bin/python
# suivi du regard
import Adafruit_PCA9685  # Le module PCA9685 pour le ctrl des servo
import cv2  # OpenCV pour le ttt des img
#import numpy as np
import time


pwm = Adafruit_PCA9685.PCA9685()  # Initialiser en utilisant l adresse I2C par defaut (0x40)
pwm.set_pwm_freq(60)  # Set frequency to 60hz, good for servos
# Ebat max des servo:
servo_max_droit = 250
servo_max_gauche = 550
servo_max_haut = 500
servo_max_bas = 900

# on recentre les 2 servo:
pwm.set_pwm(0, 0, 400) # pour horizontal: (num_du_servo_0, 0, impulsions)
pwm.set_pwm(1, 0, 600) # pour vertical: (num_du_servo_1, 0, impulsions)
servo_actuel_horizontal = 400  # on modifiera cette variable pour deplacer la tete
servo_actuel_vertical = 600
time.sleep(1)

# Chemin du fichier .xml qui contient des modeles de visages (classifier)
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

capture = cv2.VideoCapture(0) # flux de la webcam (utiliser VideoCapture(1) pour faire plusieurs flux)

while 1:
    ret, img = capture.read() # on recupere une image du flux video
    #image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # on la met en nuances de gris pour gagner du temps de traitement
    image = img # tester si c est vraiment utile de ne pas la laisser en couleur...

    newsize = (int(image.shape[1]/1.5), int(image.shape[0]/1.5)) # nouvelle taille: essayer entre 1.5 et 2
    image = cv2.resize(image, newsize) # fonction qui redimensionne pour gagner en temps de calcul

    # la fonction detectMultiScale retourne les positions de visages detecter avec les modeles contenu dans le .xml
    faces = face_cascade.detectMultiScale(image, 1.4, 3) # voir internet pour les differents parametres


    for (x,y,w,h) in faces: # on recupere les coordonnees de la tronche detectee
        cv2.rectangle(image,(x,y),(x+w,y+h),(255,7,8),2) # on dessine un rectangle
        print("X: " + str(x))
        print("Y: " + str(y))
        print("H: " + str(h) + " donc la distance")
        print("")


        # deplacements horizontaux de la tete:
        if x < 120:
            servo_actuel_horizontal = (servo_actuel_horizontal + 3)
            if servo_actuel_horizontal > servo_max_gauche:
                servo_actuel_horizontal = servo_max_gauche

        if x > 170:
            servo_actuel_horizontal = (servo_actuel_horizontal - 3)
            if servo_actuel_horizontal < servo_max_droit:
                servo_actuel_horizontal = servo_max_droit

        pwm.set_pwm(0, 0, servo_actuel_horizontal) # pour horizontal
        print("Nouvelle position du servo horizontal: " + str(servo_actuel_horizontal))


        # deplacements verticaux de la tete:
        print("Pr ctrl servo_actuel_vertical: " + str(servo_actuel_vertical))
        if y > 95:
            servo_actuel_vertical = (servo_actuel_vertical + 2)
            if servo_actuel_vertical > servo_max_bas:
                servo_actuel_vertical = servo_max_bas

        if y < 55:
            servo_actuel_vertical = (servo_actuel_vertical - 2)
            if servo_actuel_vertical < servo_max_haut:
                servo_actuel_vertical = servo_max_haut

        pwm.set_pwm(1, 0, servo_actuel_vertical) # pour vertical
        print("Nouvelle position du servo vertical: " + str(servo_actuel_vertical))


    cv2.imshow('Image capturee',image) # on affiche l image pour ctrl
    k = cv2.waitKey(30) & 0xff
    if k == 27: # si ESC on sort de la boucle
        break

capture.release()
cv2.destroyAllWindows()

Pour le suivi des couleurs (ici bleue):

#!/usr/bin/env python
# Suivi par la tete de la couleur bleue

import Adafruit_PCA9685  # Le module PCA9685 pour le ctrl des servo
import time
import cv2  # OpenCV pour le ttt des img
import numpy as np

pwm = Adafruit_PCA9685.PCA9685()  # Initialiser en utilisant l adresse I2C par defaut (0x40)
pwm.set_pwm_freq(60)  # Set frequency to 60hz, good for servos
# Ebat max des servo:
servo_max_droit = 250
servo_max_gauche = 550
servo_max_haut = 500
servo_max_bas = 900

# on recentre les 2 servo:
pwm.set_pwm(0, 0, 400) # pour horizontal: (num_du_servo_0, 0, impulsions)
pwm.set_pwm(1, 0, 600) # pour vertical: (num_du_servo_1, 0, impulsions)
servo_actuel_horizontal = 400  # on modifiera cette variable pour deplacer la tete
servo_actuel_vertical = 600
time.sleep(1)


# on extrait la position X et Y de la couleur bleue
capture = cv2.VideoCapture(0) # flux de la webcam (utiliser VideoCapture(1) pour faire plusieurs flux)

while 1:
    ret, image = capture.read() # on recupere une image du flux video
    newsize = (int(image.shape[1]/1.5), int(image.shape[0]/1.5)) # nouvelle taille: essayer entre 1.5 et 2
    image = cv2.resize(image, newsize) # fonction qui redimensionne pour gagner en temps de calcul

    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) # on converti l image en HSV dans $hsv

    # on definit des seuils de couleurs bleues en HSV
    bleu_bas = np.array([110,50,50])
    bleu_haut = np.array([130,255,255])

    bleu = cv2.inRange(hsv, bleu_bas, bleu_haut) # on filtre que le bleu dans l image $hsv que l on met dans $bleu
    cv2.imshow('Ctrl vision de la couleur',bleu) # on affiche l image pour ctrl


    # on trouve le contour de la couleur
    contour = cv2.findContours(bleu.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]


    # et on calcule un cercle autour de ce contour
    centre = max(contour, key=cv2.contourArea)
    ((x, y), radius) = cv2.minEnclosingCircle(centre)


    if radius > 10: # seuil minimum avant de dessiner le cercle
        cv2.circle(image, (int(x), int(y)), int(radius), (0, 255, 255), 2)  # cercle jaune
        cv2.circle(image, (int(x), int(y)), int((radius / radius) + 1), (255, 255, 255), 2)  # point blanc
        print("Distance: " + str(radius))
        print("X: " + str(x))
        print("Y: " + str(y))
        print("")



    x = int(x)
    y = int(y)
    # deplacements horizontaux de la tete:
    if x < 150:
        servo_actuel_horizontal = (servo_actuel_horizontal + 3)
        if servo_actuel_horizontal > servo_max_gauche:
            servo_actuel_horizontal = servo_max_gauche

    if x > 300:
        servo_actuel_horizontal = (servo_actuel_horizontal - 3)
        if servo_actuel_horizontal < servo_max_droit:
            servo_actuel_horizontal = servo_max_droit

    pwm.set_pwm(0, 0, servo_actuel_horizontal) # pour horizontal
    print("Nouvelle position du servo horizontal: " + str(servo_actuel_horizontal))


    # deplacements verticaux de la tete:
    print("Pr ctrl servo_actuel_vertical: " + str(servo_actuel_vertical))
    if y > 190:
        servo_actuel_vertical = (servo_actuel_vertical + 2)
        if servo_actuel_vertical > servo_max_bas:
            servo_actuel_vertical = servo_max_bas

    if y < 80:
        servo_actuel_vertical = (servo_actuel_vertical - 2)
        if servo_actuel_vertical < servo_max_haut:
            servo_actuel_vertical = servo_max_haut

    pwm.set_pwm(1, 0, servo_actuel_vertical) # pour vertical
    print("Nouvelle position du servo vertical: " + str(servo_actuel_vertical))


    cv2.imshow('image',image)


    k = cv2.waitKey(30) & 0xff
    if k == 27: # si ESC on sort de la boucle
        break

capture.release()
cv2.destroyAllWindows()

Voilà, j'ai essayé de commenter un maximum le code, maintenant je le redis je débute donc il n'est pas très joli mon code, faut pas hésiter à le critiquer :-)

 

 

Pour les moteurs, pour l'instant j'ai fait un pont en H avec des piles AA, mais ça ne marche pas trop, ça me fait des big a'coup, faut que j'y travaille encore..  Je mets quand même le schéma:

 

Sources:

http://docs.opencv.org/3.1.0/df/d9d/tutorial_py_colorspaces.html

Oui j'ai suivi un peu ton travail Oliver17 et j'ai bcp aimé! 
 
Voici en attendant une petite vidéo vite faite de mon robot, et je mettrais + d'info sur sa conception dès que j'arrive à faire qque chose de concert.

 
 
Avec OpenCV je parviens à suivre le regard, suivre une couleur, et reconnaître un visage (mais créer un décalage de 5 à 6 sec), le tout en python.
 
Mon but serait de repérer le regard, et récupéré la couleur du t-shirt afin que le robot suivie la personne... Tout un programme
 
A tout bientôt!

Hello,

 

Comme j'avais dit que je reviendrais donner des nouvelles, me revoilà

 

Donc j'ai viré mes 2 servo à rotation continue puisque je n'arrive à rien, j'ai fait un pont en H avec une puce L293D et 2 moteurs 6v.

 

Forcément je perds en précision, mais je crois que ça va quand même pas trop mal..

 

Je reprends donc mon code OpenCV, mon but est de repéré les yeux, afin de récupérer l'histogramme des couleurs d'un rectangle situé sous la tête (la couleur du t-shirt) afin de bêtement suivre cette couleur -> donc suivre la personne..

 

Si mon projet est concluant, je referai un post pour le présenter

 

Merci à tous pour votre aide en tout cas!

et bon bidouillage

Bonjour à tous!

 

Alors moi j'ai découvert ce forum en cherchant sur le net une réponse à l'une de mes (nombreuses) questions. Et avant de la poser, je vais déjà me présenter un peu  

 

J'ai 38 ans, j'aime surtout faire mes projets à base de cartes Raspberry Pi, que je trouve simplement fascinantes.. Actuellement je suis sur un projet de Robot fait avec des pièces Makeblock :

 

 

Sinon mes derniers projets en date, tournent autour des jeux développés avec Pygame:

 

Voilà, à tout bientôt sur le forum

Bonne journée à tous!

Pascal