Ingeniería de Sistemas

Inteligencia Artificial

[Proyecto Carrito Inteligente en Arduino]

[Informe]

[Inteligencia Artificial]
Autores:
Flores Paz Antony
Samillan Flores Alexis Smith
Vásquez Carlos Yanira
Yovera Santisteban José Eduardo

[04 de Noviembre del 2019]

Resumen.
El contenido de este informe se presenta el diseño e implementación en la plataforma de Arduino
de varios algoritmos básicos relacionados con algunas funcionalidades necesarias para la
navegación autónoma de vehículos, tales como el seguimiento de trayecto, y la evitación de
obstáculos.
Las implementaciones se han realizado en dos prototipos diferentes, con distintas características
físicas y de movimiento, y con diferentes sensores, de tal forma que cada prototipo ha necesitado
su propia implementación de cada funcionalidad, incluso a veces con algoritmo diferente.
Además, esos algoritmos básicos se han combinado para obtener un prototipo funcional de un
coche que pueda hacer un seguimiento a una persona determinada, el cual interactúa en tiempo
real.

Palabras Claves.

Arduino, algoritmos, sensores, implementación, prototipo.

 [Carrito Inteligente]

TABLA DE CONTENIDO.

1. INTRODUCCIÓN ................................................................................................................... 3
2. DESCRIPCIÓN DEL SISTEMA ............................................................................................ 5
3. MATERIALES UTILIZADOS ............................................................................................... 6
4. PROGRAMA DEL CÓDIGO EN ARDUINO. ..................................................................... 10
5. RESULTADOS DE LA SIMULACIÓN. .............................................................................. 17
6. CONCLUSIONES ................................................................................................................. 18
7. RECOMENDACIONES ........................................................................................................ 19
8. AGRADECIMIENTOS ......................................................................................................... 20
9. BIBLIOGRAFÍA ................................................................................................................... 21

2 / 21
 [Carrito Inteligente]

1. INTRODUCCIÓN

En los últimos años se han desarrollado innumerables aplicaciones en las que es necesario
contar con los conocimientos básicos en el desarrollo y programación de microcontroladores. La
mayoría de los sistemas programables actuales tienen por lo menos un microcontrolador
encargado del control operativo del sistema.

Existen en el mercado muchos fabricantes de microcontroladores, por mencionar algunos:

MICROCHIP, ATMEGA, MOTOROLA entre otras. Estos fabricantes proveen del software
especializado para la programación de sus microcontroladores y otorgan gran cantidad de
información para el usuario.

Actualmente, ARDUINO, una empresa italiana, ha desarrollado placas micro controladas

educativas con grandes prestaciones. Esta placa posee microcontroladores ATMEGA
encargados del control de la placa. Hay disponibles gran cantidad de proyectos que se han
desarrollado a través de esta placa.

En el proyecto realizado fue necesario el uso de la placa Arduino.

Nosotros alumnos de Ingeniería de Sistemas a través del curso de Inteligencia Artificial hemos
puesto en práctica lo aprendido, esto nos ayuda de introducción al fascinante mundo de la
robótica.

El “robot” que se propone, es un dispositivo móvil con cuatro ruedas, dos movidas por un motor
(ruedas motrices), y las otras 2 de la misma forma. Estos motores girarán o no, dependiendo del
movimiento que la persona realice, ya que tiene la función de seguir a una persona especificada.

En esta sección se espera que el autor describa en forma más amplia a como se presentó en el
resumen, algunos aspectos como el contexto de la investigación, el problema a resolver, la forma
propuesta de resolver, algunos antecedentes, entre otros.

1.1 Situación Problemática:

El desarrollo de la robótica educativa en el Perú ha ido creciendo en los últimos años, con el
objetivo de contribuir al desarrollo de habilidades y destrezas en los estudiantes, en su
formación académica.

Actualmente se realiza el proyecto con la necesidad de contribuir una ayuda a las personas
que deseen hacer el seguimiento a una persona específica, con ello se podrá detectar si la
persona se encuentra en movimiento o en estado de reposo.

Con esta perspectiva, surge la propuesta de crear un carrito inteligente o robot al alcance de
todos, cuyas piezas deben ser principalmente de bajo costo, con una orientación del proceso
de desarrollo y funciones a seguir.

1.2 Justificación:
La Inteligencia Artificial, es un medio, para que los alumnos desarrollen competencias y
habilidades transversales, en su formación básica. Según expertos desarrolla en el
estudiante las siguientes habilidades:
 La inteligencia lógica-matemática: aplicando cálculos numéricos y siguiendo patrones
lógicos de programación.
 La capacidad de atención, memoria y concentración.
 La inteligencia espacial apreciando con certeza la imagen y sensibilizándose al color, la
línea, la forma, la figura, el espacio y sus interrelaciones.
 La inteligencia física-cenestésica al hacer trabajos de construcción utilizando el sentido del
tacto con percepción de medidas y volúmenes.
 La inteligencia lingüística ampliando su vocabulario y empleando eficazmente palabras
técnicas en la sustentación de sus trabajos.
3 / 21
 [Carrito Inteligente]

 La inteligencia interpersonal mediante la socialización en trabajos colaborativos y en equipo.

 La inteligencia intrapersonal al reconocer por él mismo sus virtudes y defectos al asignarle
un rol determinado dentro de un grupo.
 La capacidad de aprendizaje en forma divertida, despertando así su interés y curiosidad por
los principios científicos y tecnológicos que rigen el mundo que les rodea.
 Desarrollan y fortalecen su autoestima, liderazgo, tolerancia, respeto, personalidad,
responsabilidad, autodescubrimiento, democracia, cooperación, habilidad mental y su
capacidad negociadora.
 La virtud del orden que les ayuda a ser más organizados para lograr sus objetivos.
 Desarrolla sus habilidades sociales, comunicativas e investigación.

Por lo anterior, es un plan estratégico para elevar el nivel tecnológico en nuestro País, se ha
impulsado el proyecto de Inteligencia Artificial ; en un primer nivel en el área básica, pero con
el objetivo de abarcar el 100% de toda la formación de la persona.

4 / 21
 [Carrito Inteligente]

2. DESCRIPCIÓN DEL SISTEMA:

Se a trabajado en dos Arduino diferente, uno se llamara Maestro y el otro Esclavo.

El Arduino Maestro, estará conectado con el módulo Bluetooth, con la brújula y también con el
protoboard por medio de los cables macho- hembra, macho-macho o hembra-hembra.

El Arduino Esclavo estará conectado con el módulo Bluetooth, con el sensor de ultrasonido, con
el puente H y a su vez con el protoboard por medio de los cables macho- hembra, macho-macho
o hembra-hembra.

El software de Arduino está estructurado en dos partes principales: la declaración y configuración

de los pines y la ejecución de las instrucciones.

Primero se asignan valores enteros a las diferentes variables correspondientes con los pines de
Arduino, y se crean otras variables que serán usadas en el transcurso de la aplicación.

La función setup() se encarga de inicializar el puerto serial, para que sea posible la comunicación
entre el Maestro y el Esclavo, y de configurar los pines declarados anteriormente como pines de
entrada o de salida. La función setup() se ejecuta una única vez al iniciar el programa, antes de
pasar a la segunda función loop().

La función loop() realiza la ejecución de las instrucciones del programa un número ilimitado de
veces, ya que se trata de un bucle infinito, del que únicamente se podría salir bajo una cierta
condición.

La comunicación por el puerto serial se realiza a través del módulo Bluetooth, que es el encargado
de recibir los datos procedentes del Maestro para enviárselos al Arduino esclavo.

Una vez configurados los pines, se pasa a la ejecución en modo bucle infinito del programa, donde
el Arduino comienza a recibir datos a través del puerto serial. Estos datos son caracteres que se
envían desde el Maestro. Dependiendo del carácter recibido en cada iteración del bucle, el vehículo
realizará una operación determinada durante un periodo de tiempo, y durará hasta que el Maestro
realice otro movimiento.

Movimiento hacia adelante, hacia atrás y detención

Los movimientos hacia adelante y atrás están basados en el control del giro de los motores, es
decir, en el puente H, el movimiento de detención depende del Sensor ultrasonido que hará que el
Esclavo pueda detenerse.

5 / 21
 [Carrito Inteligente]

3. MATERIALES UTILIZADOS

 4 Ruedas

 2 Protoboard:
Es una especie de tablero con orificios, en la cual se pueden insertar componentes
electrónicos y cables para armar circuitos. Como su nombre lo indica, esta tableta sirve
para experimentar con circuitos electrónicos, con lo que se asegura el buen
funcionamiento del mismo

 2 Arduino UNO:
Es una plataforma de hardware libre, basada en una placa con un microcontrolador y un
entorno de desarrollo (software), diseñada para facilitar el uso de la electrónica en
proyectos multidisciplinares.

6 / 21
 [Carrito Inteligente]

 2 Módulos Bluetooth HC-05:

El módulo de bluetooth HC-05 es el que ofrece una mejor relación de precio y
características, ya que es un módulo Maestro-Esclavo, quiere decir que además de recibir
conexiones desde una PC o tablet, también es capaz de generar conexiones hacia otros
dispositivos bluetooth. Esto permite por ejemplo, conectar dos módulos de bluetooth y
formar una conexión punto a punto para transmitir datos entre dos microcontroladores o
dispositivos.

 2 Motores DC:
Los motores DC (Direct Current) o también llamados CC (Corriente Continua) son muy
utilizados en robótica. Los hay de distintos tamaños, formas y potencias, pero todos se
basan en el mismo principio de funcionamiento. Accionar un motor DC es muy simple y
solo es necesario aplicar la tensión de alimentación entre sus bornes. Para invertir el
sentido de giro basta con invertir la alimentación y el motor comenzará a girar en sentido
opuesto. A diferencia de los motores paso a paso y los servomecanismos, los motores
DC no pueden ser posicionados y/o enclavados en una posición específica. Estos
simplemente giran a la máxima velocidad y en el sentido que la alimentación aplicada se
los permite

7 / 21
 [Carrito Inteligente]

 1 brújula digital HMC5883L:

Una brújula digital es un sensor que mide el valor del campo magnético en tres ejes. Con
esta medición, es posible estimar la orientación del dispositivo respecto al campo
magnético de la tierra

 1 puente H L293D:
El integrado L293D incluye cuatro circuitos para manejar cargas de potencia media, en
especial pequeños motores y cargas inductivas, con la capacidad de controlar corriente
hasta 600 mA en cada circuito y una tensión entre 4,5 V a 36 V.

 1 Docena de Cables macho-macho

 1 Docena de Cables macho-hembra

8 / 21
 [Carrito Inteligente]

 1 Docena de Cables hembra-hembra

 1 Sensor de Ultrasonido:
El sensor HC-SR04 es un módulo que incorpora un par de transductores de ultrasonido
que se utilizan de manera conjunta para determinar la distancia del sensor con un objeto
colocado enfrente de este. Quizá la característica más destacada del HC-SR04 es que
puede ser adquirido por una baja suma de dinero y esto mismo lo ha hecho muy popular.
Afortunadamente el módulo HC-SR04 es bastante fácil de utilizar a pesar de su bajo
precio y no demanda gran cantidad de trabajo ponerlo a funcionar.

9 / 21
 [Carrito Inteligente]

4. PROGRAMA DEL CÓDIGO EN ARDUINO.

1ero Maestro:

// Código brújula digital con sensor magnetómetro HMC5883

//
// Se añadió Leds para que indiquen la dirección y así no depender
// del monitor Serial.
//
#include <SoftwareSerial.h>
SoftwareSerial mySerial(10,11);//rx,tx
#include <Wire.h>
#include <HMC5883L.h> //Include a biblioteca HMC5883L.h
#include <Adafruit_HMC5883_U.h>

int direccion=0;
int caminar=0;
HMC5883L brujula; //Instancia a biblioteca para a búsqueda

int i; //Variable para contar

float grados; //Variable para almacenar el valor evaluado
float preciso; //Variable para mejorar la precisión de valor medido

// Asignación de una identificación a la brújula

Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);

void displaySensorDetails(void)
{
sensor_t sensor;
mag.getSensor(&sensor);
Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name);
Serial.print ("Driver Ver: "); Serial.println(sensor.version);
Serial.print ("ID unica: "); Serial.println(sensor.sensor_id);
Serial.print ("Valor Maximo: "); Serial.print(sensor.max_value); Serial.println(" uT");
Serial.print ("Valor Minimo: "); Serial.print(sensor.min_value); Serial.println(" uT");
Serial.print ("Resolucion: "); Serial.print(sensor.resolution); Serial.println(" uT");
Serial.println("------------------------------------");
Serial.println("");
delay(500);

void setup(void)
{
Serial.begin(9600);
mySerial.begin(9600);
Serial.println("Magnetometro HMC5883 Test"); Serial.println("");

/* Inicializamos el sensor */
if(!mag.begin()){
10 / 21
 [Carrito Inteligente]

// Si hay algún problema con el HMC5883 sale el aviso de que revise las conexiones
Serial.println("Ooops, no se ha detectado el HMC5883 ... revisa las conexiones!");
while(1);
}

Wire.begin(); //Inicia la comunicación I2C

//Configura a brújula
brujula = HMC5883L();
brujula.SetScale(1.3);
brujula.SetMeasurementMode(Measurement_Continuous);
//===================

// Muesta la información básica del sensor

displaySensorDetails();
}

void loop(void)
{
// Hacemos que el sensor tome una nueva muestra
sensors_event_t event;
mag.getEvent(&event);

float muestra = atan2(event.magnetic.y, event.magnetic.x);

preciso = 0; //A cero, la variable para una nueva lectura

/* Una vez se tiene la muestra tomada, a continuación se debe agregar el "Ángulo de

declinación" el ángulo de declinación es el "error" del campo magnético en su ubicación.

Puede encontrar el suyo aquí: https://www.magnetic-declination.com/

Si no encuentra su ángulo de declinación, comente las dos líneas siguientes, la brújula estará
ligeramente desviada*/

float declinacionAngulo = 0.13; // Valencia, angulo de declinación 0.13

muestra += declinacionAngulo;

// corrige los valores negativos

if(muestra < 0)
muestra += 2*PI;

// Comprueba si hay error debido a la adición de la declinación.

if(muestra > 2*PI)
muestra -= 2*PI;

// Convierte los radianes a grados

float avanzar = muestra * 180/M_PI;
Serial.print(avanzar,0);
delay(2000);
}

11 / 21
 [Carrito Inteligente]

2do Esclavo:

#include <Servo.h>
#include <NewPing.h>

#define EchoPin A1
#define TriggerPin A0
#define Maxdistancia 200
NewPing sonar(TriggerPin,EchoPin,Maxdistancia);
Servo Miservo;
#define DerechaAdelante 5
#define DerechaAtras 6
#define IzquierdoAdelante 10
#define IzquierdoAtras 11

int distancia; // para Calcular distacia

int velocidad = 255; // Velocidad de los motores (0-255)

int caminar=0;
int DATO =0;
int DIRECCION;
int cdato=0;
int cdireccion=0;
int variable =0;

void setup() {
// put your setup code here, to run once:
Miservo.attach(9);
Miservo.write(73);
delay(2000);
distancia = CalcularDistancia();
delay(100);
distancia = CalcularDistancia();
delay(100);
distancia = CalcularDistancia();
delay(100);
distancia = CalcularDistancia();
delay(100);
Serial.begin(9600);
/*
while(true){
DIRECCION =0;
DIRECCION =Serial.parseInt();

if(DIRECCION >0 && DIRECCION < 360){

Serial.println(DIRECCION);
break;

}
}
*/
}

void loop() {

12 / 21
 [Carrito Inteligente]

DATO = recuperarangulo(DIRECCION);
Serial.print("angulo sensor ");
Serial.println(DATO);
variable=angulo(DATO,DIRECCION);
Serial.print("variable ");
Serial.println(variable);
Serial.print("adireccion ");
Serial.println(DIRECCION);
if( DIRECCION >0 && DIRECCION < 360){
cdato=CuadranteDATO(variable);
cdireccion=CuadranteDIRECCION(DIRECCION);
if((cdato==1 && cdireccion ==4)||(cdato==4 && cdireccion ==1)){
if(cdireccion==1){
caminar = (360-variable)+DIRECCION;
if(caminar <=10){
distancia =CalcularDistancia();
if(distancia >30){
Adelante();
}else{
detener();
}
}else{
GirarIzquierda(caminar);
Adelante();
}
caminar=0;
}else{
caminar = (360-DIRECCION)+variable;
if(caminar <=10){
distancia =CalcularDistancia();
if(distancia >30){
Adelante();
}else{
detener();
}
}else{
GirarDerecha(caminar);
Adelante();
}
caminar=0;
}

}else{
caminar = variable-DIRECCION;
if(caminar>=0){
if(caminar <=10){
distancia =CalcularDistancia();
if(distancia >30){
Adelante();
}else{
detener();
} }else{
GirarIzquierda(caminar);
Adelante();
}

13 / 21
 [Carrito Inteligente]

caminar=0;
}else{
caminar =caminar*(-1);
if(caminar <=10){
distancia =CalcularDistancia();
if(distancia >30){
Adelante();
}else{
detener();
}
}else{
GirarDerecha(caminar);
Adelante();
}
caminar=0;
}
}
}else{
detener();
}
Serial.print("caminar " );

Serial.println(caminar);

DIRECCION=variable;
variable=0;

}
int recuperarangulo(int ubicacion){
int angulodado =0;
if(Serial.available()){
angulodado =Serial.parseInt();
if(angulodado >0 && angulodado < 360){
return angulodado;
}else{
return ubicacion;
}
}
}
int angulo(int angulo,int direc){
if(angulo>=0 && angulo<360){
angulo=angulo;
}else{
angulo = direc;
}
return angulo;
}

int CuadranteDATO(int valor){

int CUADRANTE=0;
if(valor >=0 && valor <=90){
CUADRANTE =1;
}else{
if(valor >90 && valor <=180){
CUADRANTE =2;

14 / 21
 [Carrito Inteligente]

}else{
if(valor >180 && valor <=270){
CUADRANTE =3;
}else{
if(valor >270 && valor <360){
CUADRANTE =4;
}
}
}
}
return CUADRANTE;
}

int CuadranteDIRECCION(int val){

int CUADRANTE=0;
if(val>0 && val <=90){
CUADRANTE =1;
}else{
if(val >90 && val <=180){
CUADRANTE =2;
}else{
if(val >180 && val <=270){
CUADRANTE =3;
}else{
if(val >270 && val <360){
CUADRANTE =4;
}
}
}
}

return CUADRANTE;
}
int GirarDerecha(int tiempo){
analogWrite(DerechaAdelante ,0);
analogWrite(DerechaAtras,velocidad);
analogWrite(IzquierdoAdelante ,velocidad);
analogWrite(IzquierdoAtras,0);
delay(tiempo*15);
}

int GirarIzquierda(int tiempo){

analogWrite(DerechaAdelante ,velocidad);
analogWrite(DerechaAtras,0);
analogWrite(IzquierdoAdelante ,0);
analogWrite(IzquierdoAtras,velocidad);
delay(tiempo*15);
}
void Adelante(){
analogWrite(DerechaAdelante ,velocidad);
analogWrite(DerechaAtras,0);
analogWrite(IzquierdoAdelante ,velocidad);
analogWrite(IzquierdoAtras,0);
}
void Atras(){
analogWrite(DerechaAdelante ,0);

15 / 21
 [Carrito Inteligente]

analogWrite(DerechaAtras,velocidad);
analogWrite(IzquierdoAdelante ,0);
analogWrite(IzquierdoAtras,velocidad);
}

void detener(){
analogWrite(DerechaAdelante ,0);
analogWrite(DerechaAtras,0);
analogWrite(IzquierdoAdelante ,0);
analogWrite(IzquierdoAtras,0);

int CalcularDistancia(){
delay(70);
int cm = sonar.ping_cm();
Serial.println(cm);

if(cm==0){
cm =250;
}
Serial.print("Distancia normal = ");
Serial.println(cm);
return cm;
}

int MirarDerecha(){
Miservo.write(12);
delay(500);
int distancia = CalcularDistancia();
delay(100);
Miservo.write(73);
Serial.print(" Distancia derecha = ");
Serial.println(distancia);
return distancia;
}

int MirarIzquierda(){
Miservo.write(160);
delay(500);
int distancia = CalcularDistancia();
delay(100);
Miservo.write(73);
Serial.print(" Distancia IZQUEIRDA = ");
Serial.println(distancia );
return distancia;
}

16 / 21
 [Carrito Inteligente]

5. RESULTADOS DE LA SIMULACIÓN.

Maestro:
- Los resultados obtenidos después de haberlo
puesto en marcha lo podemos ver en la figura
presente que tiene el manómetro o brújula, es una
librería que con respecto al norte nos da un
ángulo, el ángulo se almacena en este Arduino y
se comparte con el Arduino Esclavo por el modo
bluetooth.

Esclavo:
- Una vez recepcionado el ángulo, se realiza
el código que según el ángulo haya
captado, haciéndole que gire el carrito a la
derecha o a la izquierda, corra o se
detenga por el sensor de ultrasonido que
permite esta función, y si cambia el ángulo
este gira.

17 / 21
 [Carrito Inteligente]

6. CONCLUSIONES

El desarrollo de la robótica en los últimos años ha sido muy significativa, sobre todo enfocada a
la educación .Permitiendo desarrollarla inventiva de los estudiantes, mediante la construcción de
robots con fines educativos. Por tanto es posible la construcción de pequeños robots, con el
enfoque educativo a partir de elementos electrónicos básicos, como diodos led, transistores
bipolares, relés, Arduino.

El Arduino UNO se utiliza como el cerebro del robot, ya que permite desarrollar muchas
aplicaciones de fácil construcción a bajo costo. El uso del Arduino para la construcción de robots
se ha incrementado en la actualidad combinándolo con otros elementos electrónicos pueden
construirse estructuras robóticas que realizan diversas funciones. Es posible desarrollar un
software para programar el Arduino que facilita el cargar las instrucciones o código de
programación al Arduino. Para desarrollar el carrito inteligente o robot es necesario tener
conocimientos básicos de electrónica, Arduino, para comprender el proceso comenzando con la
interconexión de dispositivos electrónicos básicos con el Arduino UNO para finalmente crear el
proyecto final.

Por ello se desarrolló el informe presente que incluye los pasos para desarrollar el proyecto, para
capacitar a las personas que se involucren en el desarrollo de proyectos de inteligencia artificial
Este carrito inteligente es básico y puede ir agregando funciones utilizando dispositivos
electrónicos. Con la investigación se ha contribuido a motivar a los actuales y futuros ingenieros,
licenciados y técnicos para que realicen investigación en el área técnica y busquen soluciones
confiables y de fácil comprensión, utilizando herramientas tecnológicas que diversifican las
técnicas de enseñanza-aprendizaje en la educación básica, media y superior.

El software desarrollado es una alternativa para que educandos, estudiantes, aficionados,

desarrolladores, novatos, etc. implementen el área de la robótica en sus áreas de estudio. Se ha
comprobado con la experiencia, que la técnica de enseñar haciendo resulta más efectiva y
didáctica. Con este proyecto se fortalecen las diferentes áreas de estudio, de una manera divertida
y entretenida para enseñar, aprender haciendo, probando y ejecutando. La herramienta desarrollada
aporta al mejoramiento de la metodología utilizada para la enseñanza y el aprendizaje de niños,
jóvenes y adultos de los diferentes niveles de la educación (Básica, Tercer Ciclo, Educación Media
y Educación Superior).

18 / 21
 [Carrito Inteligente]

7. RECOMENDACIONES

 Para poder desarrollar el robot deberá comprender el funcionamiento de los dispositivos

electrónicos que se han utilizado.

 Deberán capacitase sobre el uso del software ya que es básico tener noción de las funciones de
Arduino y poder desarrollar las diferentes funciones.

 La estructura utilizada para la construcción de carro robótico puede variar, ya que pueden
utilizarse diferentes materiales en la estructura. Así como puede cambiar el diseño del carro, de
acuerdo a las disponibilidad del material que se tenga.

 Puede agregarse otras funciones al carro robótico dependiendo de la iniciativa y creatividad de

cada persona que participe del proyecto.

19 / 21
 [Carrito Inteligente]

8. AGRADECIMIENTOS

 En primer lugar, quisiéramos agradecer a nuestro docente del proyecto, el Ingeniero Juan
Villegas Cubas sin el cual hubiese sido imposible destrabar algunos inconvenientes
encontrados en la etapa del desarrollo del proyecto. Su buena predisposición y
compromiso con el proyecto han sido determinantes para que se pueda completar el
trabajo.

 En segundo lugar, pero no por eso menos importante, agradecemos a todas las personas
de que colaboraron con este proyecto.

20 / 21
 [Carrito Inteligente]

9. BIBLIOGRAFÍA

Manual de Programación Arduino Traducido y adaptado:

José Manuel Ruiz Gutiérrez
Published: First Edition August 2007.

Robótica Educativa - EDULEGO

Luis Eliezer García,
Available at: http://edulego.com/servicios/robotica-educativa/

Robot Arduino, todos los detalles para empezar.

PE, I. (2014). Robot Arduino, todos los detalles para empezar.
Available at: http://comohacer.eu/crea-un-robot-arduino-con-nuestro

21 / 21