Table des matières:
2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-13 06:57
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
- Servomoteurs -4
- Arduino Méga - 1
- Framboise Pi - 1
- Caméra USB -1
- Haut-parleur -1
- Moteurs à courant continu -2
- L293D -1
- Batterie - 1
- Roues -2
- 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.