NAIN 1.0 - le robot humanoïde de base utilisant Arduino : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Nain 1.0 aura essentiellement 5 modules détachables-

1) Bras - qui peut être contrôlé via des servos.

2) Roues - qui peuvent être contrôlées avec des moteurs à courant continu.

3) Jambe - Nain pourra basculer entre les roues ou les jambes pour le mouvement.

4) Tête – Sa tête peut être contrôlée pour divers hochements de tête.

5) Module de caméra - qui peut être interfacé pour l'accès à la reconnaissance faciale.

Parallèlement à cela, NAIN pourra parler et interagir avec les utilisateurs et peut vous montrer l'heure grâce à son horloge intégrée. Il disposera d'un contrôle sans fil utilisant le Wi-fi/Bluetooth.

Étape 1: Composants nécessaires

1. Servomoteurs -4
2. Arduino Méga - 1
3. Framboise Pi - 1
4. Caméra USB -1
5. Haut-parleur -1
6. Moteurs à courant continu -2
7. L293D -1
8. Batterie - 1
9. Roues -2
10. Roues pivotantes - 2

Parallèlement à cela, vous aurez besoin de bandes carrées en aluminium pour fabriquer le corps et de vis et écrous pour les ajuster correctement.

Étape 2: Structure du corps

La structure de la carrosserie sera constituée de tiges carrées en aluminium léger qui faciliteront son assemblage.

À partir de maintenant, assemblez-les comme indiqué sur la figure et découpez également des espaces appropriés pour les servomoteurs à fixer dans les bras.

Fixez une base en bois hexagonale en bas.

Sous la base en bois, fixez les moteurs à courant continu et les roues comme nous le faisons dans n'importe quel robot suiveur de ligne.

Fait intéressant, ajoutez deux roues pivotantes, une à l'avant et l'autre à l'arrière du robot.

Étape 3: Câblage et codage

Pour câbler les différents modules se référer aux codes joints dans cette partie.

Tout d'abord, nous avons testé chaque module à l'aide de codes autonomes, puis nous les avons tous combinés en un seul et avons contrôlé le mouvement des roues et des bras à l'aide d'un module Bluetooth.

Étape 4: Raspberry Pi et reconnaissance d'image

La reconnaissance d'image est effectuée à l'aide d'une caméra USB et d'un Raspberry Pi.

Pour cela, vous devrez installer la bibliothèque OPEN CV sur votre Pi.

Vous pouvez le faire à partir d'ici -

Ensuite, vous devrez effectuer une reconnaissance d'image à l'aide de haar cascade.

Vous pouvez le faire à partir d'ici -https://thecodacus.com/category/opencv/#. WvsNC4iFPDc

Après avoir étudié le lien ci-dessus et suite à cela, j'ai apporté quelques modifications au code final que j'ai utilisé et que je colle ci-dessous -

GÉNÉRATEUR DE JEU DE DONNÉES:

importcv2

cam = cv2. Capture vidéo(0)

detect=cv2. CascadeClassifier('Classifiers/face.xml')

i=0

décalage=50

name=raw_input('entrez votre identifiant')

tant que vrai:

ret, im =cam.read()

gray=cv2.cvtColor(im, cv2. COLOR_BGR2GRAY)

faces=detector.detectMultiScale(gris, scaleFactor=1.2, minNeighbors=5, minSize=(100, 100), flags=cv2. CASCADE_SCALE_IMAGE)

for(x, y, w, h) dans les faces:

i=i+1

cv2.imwrite("dataSet/face."+nom +'.'+ str(i) + ".jpg", gray[y-offset:y+h+offset, x-offset:x+w+offset])

cv2.rectangle(im, (x-50, y-50), (x+w+50, y+h+50), (225, 0, 0), 2)

cv2.imshow('im', im[y-offset:y+h+offset, x-offset:x+w+offset])

si cv2.waitKey(100) & 0xFF == ord('q'):

Pause

# pause si le numéro d'échantillon est supérieur à 20

elif (i>20):

Pause

cam.release()

cv2.destroyAllWindows()

Il créera un ensemble de données de vos photos qui sera utilisé pour l'authentification.

FORMATEUR:

importcv2, os

importer numpy en tant que np

à partir de l'image d'importation PIL

reconnaissance = cv2.face.createLBPHFaceRecognizer()

cascadePath = "Classificateurs/face.xml"

faceCascade = cv2. CascadeClassifier(cascadePath);

chemin = 'ensemble de données'

def get_images_and_labels(chemin):

image_paths = [os.path.join(path, f) pour f dans os.listdir(path)]

# images contiendra des images de visage

image =

# étiquettes contiendra l'étiquette attribuée à l'image

étiquettes =

pour image_path dans image_paths:

# Lisez l'image et convertissez-la en niveaux de gris

image_pil = Image.open(image_path).convert('L')

# Convertir le format de l'image en tableau numpy

image = np.array(image_pil, 'uint8')

# Obtenir le libellé de l'image

nbr = int(os.path.split(image_path)[-1].split(".")[1].replace("face-", ""))

#nbr=int(''.join(str(ord(c)) pour c dans nbr))

nb d'impression

# Détecter le visage dans l'image

faces = faceCascade.detectMultiScale(image)

# Si un visage est détecté, ajoutez le visage aux images et l'étiquette aux étiquettes

pour (x, y, w, h) dans les faces:

images.append(image[y: y + h, x: x + w])

labels.append(nbr)

cv2.imshow("Ajout de visages à l'ensemble de formation…", image[y: y + h, x: x + w])

cv2.waitKey(10)

# renvoie la liste des images et la liste des étiquettes

retourner des images, des étiquettes

images, labels = get_images_and_labels(chemin)

cv2.imshow('test', images[0])

cv2.waitKey(1)

reconnaître.train(images, np.array(étiquettes))

reconnaître.save('trainer/trainer.yml')

cv2.destroyAllWindows()

DÉTECTEUR

importcv2

importer numpy en tant que np

importer le système d'exploitation

c=0

reconnaissance = cv2.face.createLBPHFaceRecognizer()

reconnaître.load('trainer/trainer.yml')

cascadePath = "Classificateurs/face.xml"

faceCascade = cv2. CascadeClassifier(cascadePath);

cam = cv2. Capture vidéo(0)

fontface = cv2. FONT_HERSHEY_SIMPLEX

échelle de police = 1

couleur de police = (255, 255, 255)

tant que vrai:

ret, im =cam.read()

gray=cv2.cvtColor(im, cv2. COLOR_BGR2GRAY)

faces=faceCascade.detectMultiScale(gris, 1,2, 5)

for(x, y, w, h) dans les faces:

cv2.rectangle(im, (x-50, y-50), (x+w+50, y+h+50), (225, 0, 0), 2)

Id = reconnaisseur.predict(gris[y:y+h, x:x+w])

si(Id<70):

si(Id==1):

Id="Shahank"

elif(Id==2):

si(c==0):

Id="Shivam"

c=c+1

os.system("parler 'Bienvenue à Shivam Accès Accordé'")

autre:

Id="Shivam"

autre:

Id="Inconnu"

cv2.putText(im, str(Id), (x, y+h), fontface, fontscale, fontcolor)

cv2.imshow('je', je suis)

si cv2.waitKey(10) & 0xFF==ord('q'):

Pause

cam.release()

cv2.destroyAllWindows()

Étape 5: LCD et haut-parleur

J'ai également utilisé un écran LED I2C et un haut-parleur.

La LED est contrôlée via Arduino Mega et son code est donné dans le code final.

Pour Speaker, il est connecté au Raspberry Pi et utilise eSpeak Utility.

Vous pouvez trouver sa référence ici -

Étape 6: Étapes finales

Assemblez le tout et préparez-vous pour le coup.