NAIN 1.0 - el robot humanoide básico que usa Arduino: 6 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Nain 1.0 tendrá básicamente 5 módulos desmontables-

1) Armado - que se puede controlar mediante servos.

2) Ruedas - que se pueden controlar con motores de corriente continua.

3) Pierna: Nain podrá cambiar entre ruedas o piernas para moverse.

4) Cabeza: su cabeza se puede controlar con varios movimientos de cabeza.

5) Módulo de cámara, que se puede conectar para el acceso al reconocimiento facial.

Junto con esto, NAIN podrá hablar e interactuar con los usuarios y podrá mostrarle la hora mediante su reloj incorporado. Tendrá un control inalámbrico mediante Wi-Fi / Bluetooth.

Paso 1: componentes necesarios

1. Servomotores -4
2. Arduino Mega - 1
3. Frambuesa Pi - 1
4. Cámara USB -1
5. Altavoz -1
6. Motores DC -2
7. L293D -1
8. Paquete de batería - 1
9. Ruedas -2
10. Ruedas giratorias - 2

Junto con estos, necesitará tiras cuadradas de aluminio para hacer que el cuerpo y los tornillos y tuercas se ajusten correctamente.

Paso 2: Estructura corporal

La estructura de la carrocería estará hecha de varillas cuadradas de aluminio livianas que ayudarán a ensamblarla fácilmente.

A partir de ahora, móntelos como se muestra en la figura y también corte los espacios adecuados para que los servomotores se unan a los brazos.

Coloque una base de madera hexagonal en la parte inferior.

Debajo de la base de madera, coloque los motores de CC y las ruedas como lo hacemos en cualquier robot seguidor de línea.

Curiosamente, agregue dos ruedas giratorias, una en la parte delantera y otra en la parte posterior del robot.

Paso 3: cableado y codificación

Para conectar los diferentes módulos, consulte los códigos adjuntos en esta parte.

Primero probamos cada módulo usando códigos independientes y luego los combinamos todos en uno y controlamos el movimiento de ruedas y brazos usando un módulo bluetooth.

Paso 4: Raspberry Pi y reconocimiento de imágenes

El reconocimiento de imágenes se realiza mediante una cámara USB y una Raspberry Pi.

Para eso, necesitará instalar la biblioteca OPEN CV en su Pi.

Puede hacerlo desde aquí:

Luego, deberá realizar el reconocimiento de imágenes utilizando Haar Cascade.

Puede hacerlo desde aquí:

Después de estudiar el enlace anterior y seguir eso, he realizado algunos cambios en el código final que he usado y que estoy pegando a continuación:

GENERADOR DE CONJUNTOS DE DATOS:

importcv2

cam = cv2. VideoCapture (0)

detector = cv2. CascadeClassifier ('Clasificadores / face.xml')

i = 0

desplazamiento = 50

name = raw_input ('ingrese su identificación')

mientras que es cierto:

ret, im = cam.read ()

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

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

para (x, y, w, h) en caras:

yo = yo + 1

cv2.imwrite ("dataSet / face." + nombre + '.' + str (i) + ".jpg", gris [desplazamiento y: desplazamiento y + h + desplazamiento x: desplazamiento x + w + desplazamiento])

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

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

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

rotura

# romper si el número de muestra es más de 20

elif (i> 20):

rotura

cam.release ()

cv2.destroyAllWindows ()

Creará un conjunto de datos de sus fotos que se utilizará para la autenticación.

ENTRENADOR:

importcv2, os

importar numpy como np

de la imagen de importación PIL

reconocedor = cv2.face.createLBPHFaceRecognizer ()

cascadePath = "Clasificadores / face.xml"

faceCascade = cv2. CascadeClassifier (cascadePath);

ruta = 'conjunto de datos'

def get_images_and_labels (ruta):

image_paths = [os.path.join (ruta, f) para f en os.listdir (ruta)]

# imágenes contendrán imágenes de caras

imágenes =

# etiquetas contendrá la etiqueta que está asignada a la imagen

etiquetas =

para image_path en image_paths:

# Leer la imagen y convertirla a escala de grises

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

# Convierta el formato de imagen en una matriz numpy

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

# Obtener la etiqueta de la imagen

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

# nbr = int (''. join (str (ord (c)) para c en nbr))

imprimir nbr

# Detecta el rostro en la imagen

caras = faceCascade.detectMultiScale (imagen)

# Si se detecta un rostro, agregue el rostro a las imágenes y la etiqueta a las etiquetas

para (x, y, w, h) en caras:

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

tags.append (nbr)

cv2.imshow ("Añadiendo caras al conjunto de entrenamiento…", imagen [y: y + h, x: x + w])

cv2.waitKey (10)

# devuelve la lista de imágenes y la lista de etiquetas

devolver imágenes, etiquetas

imágenes, etiquetas = get_images_and_labels (ruta)

cv2.imshow ('prueba', imágenes [0])

cv2.waitKey (1)

Recognizer.train (imágenes, np.array (etiquetas))

Recognizer.save ('entrenador / entrenador.yml')

cv2.destroyAllWindows ()

DETECTOR

importcv2

importar numpy como np

importar sistema operativo

c = 0

reconocedor = cv2.face.createLBPHFaceRecognizer ()

Recognizer.load ('trainer / trainer.yml')

cascadePath = "Clasificadores / face.xml"

faceCascade = cv2. CascadeClassifier (cascadePath);

cam = cv2. VideoCapture (0)

fontface = cv2. FONT_HERSHEY_SIMPLEX

fontscale = 1

fontcolor = (255, 255, 255)

mientras que es cierto:

ret, im = cam.read ()

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

caras = faceCascade.detectMultiScale (gris, 1.2, 5)

para (x, y, w, h) en caras:

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

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

si (Id <70):

si (Id == 1):

Id = "Shashank"

elif (Id == 2):

si (c == 0):

Id = "Shivam"

c = c + 1

os.system ("espeak 'Bienvenido Acceso a Shivam concedido'")

demás:

Id = "Shivam"

demás:

Id = "Desconocido"

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

cv2.imshow ('im', im)

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

rotura

cam.release ()

cv2.destroyAllWindows ()

Paso 5: LCD y altavoz

También he utilizado una pantalla LED I2C y un altavoz.

El LED se controla a través de Arduino Mega y su código se proporciona en el código final.

Para Speaker, está conectado con Raspberry Pi y usa eSpeak Utility.

Puede encontrar su referencia aquí:

Paso 6: Pasos finales

Reúna todo y prepárese para la explosión.