DISEÑO E IMPLEMENTACIÓN DE UN

EQUIPO DE ROBOTS SOCCER

Xavier David Rógel Noroña, Erick Rene Taco Jiménez, Emilia Abigail Meza
Paredes, Bryan Andrés Solórzano Tupiza

Control con Microprocesadores, Departamento de Automatización y Control industrial, Escuela

Politécnica Nacional

xavier.rogel@epn.edu.ec bryan.solorzano@epn.edu.ec
emilia.meza@epn.edu.ec erick.taco@epn.edu.ec
Quito, Ecuador

Resumen – por lo que es necesario ganar la destreza con horas de manejo

En el presente documento se detalla la construcción de un
equipo de “Robot Soccer “ el mismo que consta de 3 robots
individuales , los cuales son controlados inalámbricamente , por
lo que cada robot necesita de un control y usuario individual
para que participen como equipo. Los robots necesitan de una
gran movilidad y de algún mecanismo para realizar un empujón
hacia una pelota , por lo que se usa 2 motores para la movilidad
del robot en los 4 ejes y el ultimo para acoplar a una aspa la cual
va a empujar la pelota .
Se presenta en el documento en el documento los parámetros
que fueron que se consideraron para que los robots Soccer
cumplan con los objetivos , el principal es fomentar
la programación e informática necesaria para controlar un
robot , aprender a pensar de manera lógica, creando relaciones
entre los sensores y motores que le ayudan a crear un
pensamiento inductivo y deductivo a los infantes , por lo que
estos robots , al tener una gran movilidad y al ser necesario
realizar un trabajo en equipo con los mismo permite interesar al
los menores en la tecnología para abrir esa brecha y ellos en un
futuro sean los desarrolladores de proyectos tecnológicos
innovadores.
de los robots.
En el juego es necesario contar con 2 equipos , los mismo se
conforma por 3 robots Soccer cada uno a demás , ese
necesario que lleven algún distintivo similar los tres lo que
equivale a un uniforme además que se lleva la puntuación de
igual forma, la cancha cuenta con 2 arcos , de igual forma se
conserva alguna reglas como los penales en caso de falta.
Se eligió esta categoría de emulación de “ Futbol Soccer ‘’
debido que al ser deporte más conocido y practicado de
igual forma es el presenta un mayor aceptación por los niños
en especial latino América, de esta forma nos permite llamar
la atención e interés de los niños ante la tecnología para este
caso seria los Robots Soccer.
Se conoce que los video juegos también son parte de la
juventud actual , de forma que para la selección del mando
inalámbrico para este caso , se utiliza un mando de una
consola muy conocida , la misma que es familiar para la
mayoría de los niños y permite realizar un control eficaz en
los robots soccer

I. INTRODUCCIÓN

En la actualidad , como se conoce ha existido un gran

desarrollo tecnológico , por lo que se implementado cada vez .
nuevas formas en la que se presenta la tecnología la misma
que es parte la vida cotidiana de cada una de las personas.

Partiendo de lo anterior, se toma como referencia al deporte

más practicado y conocido en el mundo “Futbol Soccer” y se
toma la misma idea para la creación de una emulación de
aquel deporte con robots controlados inalámbricamente.

Al utilizar la misma idea , también fue necesario implementar

algunas reglas propias para que todos los robots cuente con
las mismas condiciones , además como se conoce en los
deporte lo más importante es la destreza y el trabajo en equipo
 II. ALCANCE FIG2.- Impresión culminada

El proyecto tiene como finalidad fomentar la creatividad y el

pensamiento lógico en los niños. Para ello empleamos un
equipo de robots soccer, y de esta manera estimular el interés
en los niños.
Esta es una alternativa para que nuestros futuros profesionales
no se queden rezagados en el mundo de la tecnología.
Se realizó las placas de control del robot como si fuera la
tapa del mismo, esto para optimizar espacio, ya que el
prototipo es de 10cm x 10cm y el espacio debía ser
aprovechado al máximo.

Con esto podemos fomentar la capacidad de ordenar ideas en

los niños, ósea que sean más organizados en las actividades
que realizan. También fomenta las relaciones sociales con
otros niños, si por ejemplo se realiza en un aula y se crean
grupos de trabajo, donde cada niño aporta ideas o propuestas.

III. HARDWARE

Con respecto al hardware, lo primero fue la realización de

los planos en la plataforma de inventor de AutoCAD, para la
posterior laminación de los mismos en el software de
inventor y su impresión en 3D por medio del hilo PLA de
color plomo. FIG3.- Colocación de la Placa

FIG4.- Espacio interno a utilizar

FIG1.- Impresión en 3D de los robots

Para la cuestión de la movilidad del robot, se utilizaron

llantas de 3mm de ancho y 2,5cm de radio , las cuales debían
estar un poco salidas de la estructura para que puedan
generar el movimiento de la misma, de igual forma se eligió
este tipo de llantas para una mejor optimización del espacio
de trabajo.
 FIG6.- robots en cancha
FIG5.- Llantas de los robots

Para el control de dichos motores se deberá presionar una
flecha de la palanca solo una vez y posteriormente R1 la cual
asemeja el funcionamiento exacto de como si estuviéramos
jugando un partido de futbol en la consola de PlayStation
Mientras se tenga aplastado el botón R1 la pwm que controla
la velocidad del motor (Pololu relación 50:1)
SISTEMA DE PATEO
Para el sistema de pateo en primer lugar se propuso un motor
solenoide , es decir que la patada se realiza de manera de
impulso directo, pero esto en la practica no es lo mas optimo
ya que el robot se demoraría demasiado en reaccionar a la
patada, por lo cual diseñamos un sistema con un motor dc de
los que generalmente se los encuentra en los discos duros o
sistemas de cd de computadoras equipos, dvds etc, lo cuales
son ideales para esta aplicación por su versatilidad y forma
del mismo

FIG6.- Palanca de PS2 utilizada

IV. PROTOCOLO DE PRUEBAS

MOVILIDAD

La primera complicación que nos encontramos fue la

movilidad, ya que si las llantas no estaban sobresalidas un FIG7.- motor dc de la patada
poco de la basa del robot , este no podría moverse, asi que se
procedio a limar la base de las ruedas y de igual manera
tenían que estra lo mas fijo y rectas posibles para que puedan SISTEMA DE ALIMENTACION
moverse a nuestra voluntad
 Para el análisis de software que hemos utilizado en esta
investigación necesariamente debemos realizar un
diagrama de entradas y salidas donde se detallen y
especifiquen cada uno de los pines específicos que
vamos a utilizar y en base a esto escoger un sistema o
microcontrolador que pueda cumplir con los requisitos
del proyecto.

Analís de entradas y salidas

DESCRIPCION IN OUT puerto
motor para llanta izquierda 1 PB0
motor para llanta derecha 1 PB1
motor para patada 1 PB2
FIG7.- Baterías de cada robot Comunicación con palanca de play 2
Data 1 Pb3
Comand 1 PB4
Attention 1 PB5
clock 1 PB6
Vibration 1 C0
Tabla.no1. Analís de entradas y salidas

De acuerdo con el Analís de entradas y salidas este proyecto

se ha llevado a cabo en una tarjeta embebida de 32 bits por
lo que ha sido necesario utilizar una tarjeta de desarrollo
(STMStm 32 nucleo l4), por su versatilidad y facilidad de
programación.
FIG8.- Micro módulo step down

Para el sistema de alimentación se utilizaron

baterías LIPO de 300mha hora y 2 celdas es decir de 7,4
voltios, los cuales son suficientes para aguantar un promedio
de 20 minutos del robot jugado continuamente

Por otra parte decidimos incluir un sistema de alimentación

para el microprocesador que debía generar 5 voltios, lo cual
la primera opción fue un regulador de voltaje 7805, pero esto
no era lo más óptimo debido a que había mucho desgaste de
Características:
energía y se sobrecalentaba el disipador de calor del
encapsulado, por lo tanto colocamos este circuito en smd de
un reductor de voltaje, el cual tiene la opción de calibrar el
voltaje de salida a 3,5 y 7 voltios dependiendo de la entrada.
V. HOMOLOGACIÓN DE ROBOTS SOCCER
Se verifico que se cumplieran satisfactoriamente las
especificaciones técnicas del robot, las cuales son que el robot
puede ser de 10cm x 10cm sin tener en consideración la altura.
Además todos los robots deben poseer en su cara superior una
región de 3.5cm x 3.5cm de un color único que identifique a
su equipo.
VI. ANALISIS DE SOFTWARE
Fig.8.1. Tarjeta embebida seleccionada
▪ Microcontroladores STM32 en paquetes de 32 pines
▪ Tres LED: comunicación USB (LD1), LED de
alimentación (LD2) y LED de usuario (LD3)
▪ Botón de reinicio
▪ Conector de expansión de placa:
▪ Arduino ™ Nano
▪ Opciones flexibles de fuente de alimentación: ST-
LINK USB V BUS o fuentes externas
▪ Programador / depurador ST-LINK / V2-1
incorporado con capacidad de re-enumeración
USB: almacenamiento masivo, puerto COM virtual
y puerto de depuración
▪ Apoyo de una amplia variedad de entornos de
desarrollo integrado (IDE), incluyendo IAR ™,
Keil ® , IDE basados en GCC, Brazo ®mbed ™
▪ Compatible con Arm ® Mbed Enabled ™ (solo para
algunos números de pieza de Nucleo)
 Se debe recalcar que los materiales obtenidos fueron
adquiridos de diferentes lugares de la Ciudad de Quito y de
la página web Megasytem, previo a la realización de una
comparación de precios tomando como referencia el criterio
grupal lo que se creyó más económico y conveniente.

Fig.8.2. Diagrama de flujo
Después de hacer un correcto análisis de entadas y salidas y
haber realizado el diagrama de flujo del programa, se ha
procedido a escoger la tarjeta embebida que vamos a utilizar,
para esto utilizaremos una tarjeta STM 32 NUCLEO IL,
La programación de esta tarjeta le hemos realizado con el
EmBlocks 2.3, por su versatilidad en librerías que me
permiten una eficiencia en la programación.
VIII. CONCLUSIONES
Se diseñó y construyó un equipo de Robot soccer
controlado mediante comunicación inalámbrica, con
la capacidad de moverse en todas las direcciones e
incluye un sistema de patada de fácil manejo.
Se integró conocimientos de electrónica,
programación e informática con algoritmos de
control los cuales permitieron desarrollar
pensamientos y destrezas para manejar el equipo.
Finalmente se puede afirmar que se fomentó el
interés no solo de adultos y adolescentes por el uso
de la tecnología, si no que de forma satisfactoria se
atrajo la atención de generaciones más jóvenes como
niños entre 8 y 12 años los cuales manipularon los
prototipos de robot soccer aflorando sus habilidades
con la tecnología.

IX. REFERENCIAS

[1] Serial Real Time Clock DS1307. [Online].

Available: https://hispavila.com/wp-content/uploads
/2015/08/ds1307_esp.pdf.

[2] Nelson. S. Control con Microprocesadores. (2015).

Fig.8.3. software de programación EmBlocks 2.3

Anexo. Código de programación

VII. ANALISIS ECONOMICO

Al momento de realizar un análisis económico de fabricación

del equipo de Robot soccer, se puede evaluar y conocer si el
proyecto es viable y aplicable para otros concursos de
robótica o incluso en áreas escolares, para esto se tomaron los
costos de materiales, costos estructurales, elementos
implementados y costos operativos.
Emilia Meza nació en Quito, Ecuador en
1995. Se graduó del bachillerato con
mención en Físico Matemático del
Colegio Experimental Eugenio Espejo en
el año 2013. En el mismo año rindió la
prueba de SENECYT para ingresar a una
institución de educación superior
obteniendo la nota de 950/1000; la cual le
acreditó como estudiante de alto
rendimiento (GAR). Desde el año 2014 cruza sus estudios de
pregrado hasta la fecha en la Universidad Politécnica
Nacional en la Carrera de Ingeniería Electrónica y Control.
Sus intereses incluyen Instrumentación y desarrollo de
sistemas embebidos. Además tiene conocimientos de idiomas
Tabla1. Costos Referenciales del Equipo de Soccer
chino e inglés.

David Rógel Noroña, nació en Quito
Ecuador el 2 de Agosto de 1995. Realizo sus
estudios secundarios en el colegio Municipal
Sebastián de Benalcazar obteniendo el título
de bachillerato Nacional en Físico
Matemático. Actualmente cursa la carrera de
Ingeniería Electrónica y Control en la Escuela
Politécnica Nacional. Áreas de interés: Robótica, Sistemas
Embebidos, control industrial, Domótica y Electrónica de
Potencia
Erick Taco, nació Quito-Ecuador el 01 de
septiembre de 1994. Realizó sus estudios
secundarios en el Colegio Técnico ‘’Don
Bosco ‘’, Kennedy. Actualmente se
encuentra cursando sus estudios
universitarios en la Escuela Politécnica
Nacional, localizada en Quito-Ecuador.
(erick.taco@epn.edu.ec)
*************************************************
*********************/
// LINBRERIAS DE CONFIGURACION DE PINES Y
TIMERS
#include "stm32f4xx_conf.h" ///
#include "stm32f4xx.h" /// STM_STUP
#include "stm32f4xx_conf.h"
#include "stm32f4xx_rcc.h" /// VELOCIDAD DE LOS
PINES
#include "stm32f4xx_exti.h" ///VECTOR DE
INTERRUPCIONES
#include "stm32f4xx_tim.h" /// CONFIGURACION DE
TIMER
#include "stm32f4xx_gpio.h" ///PINES I/O
#include "stm32f4xx_syscfg.h" /// VECTOR DE
ESCRITURA DE INTERRUPCIONES

#include "stm32f4xx_usart.h"

Bryan Solórzano, nació Quito-Ecuador el #include "stm32f4xx_adc.h"

19 de noviembre de 1994. Realizó sus
#include "stm32f4xx_dac.h"
estudios secundarios en el Colegio Santiago
de Guayaquil. Actualmente se encuentra #include "defines.h"
cursando sus estudios universitarios en la
Escuela Politécnica Nacional, localizada en #include "tm_stm32f4_delay.h"
Quito-Ecuador.
(Bryan. Solórzano @epn.edu.ec) #include "tm_stm32f4_hd44780.h"

// SPI ACELEROMETRO STM

#include "tm_stm32f4_lis302dl_lis3dsh.h"

// CONFIGURACION DE COM SERIAL

#include "usbd_cdc_core.h" /// CORE STM32 UCLEO 32

Gabriel Estupiñán Preciado, nació en Quito-
Ecuador el 10 de noviembre de 1994. Realizó sus estudios #include "usbd_usr.h" /// REGISTRO DE OTG
secundarios en el Colegio Técnico Experimental. Es estudiante en la
#include "usbd_desc.h" /// NO ME ACUERDO
Escuela Politécnica Nacional en Ingeniería en Electrónica y Control.

Áreas de interés: Programación #include "usbd_cdc_vcp.h" /// RS 232

(angel.estupinan@epn.edu.ec)
#include "usb_dcd_int.h" /// HACIA LA STM
DECODIFICACION

#define BUFFERSIZE (2) /// CUANTOS DATOS EN COLA

PUEDO TENER
CODIGO DE PROGRAMACION:
#define datos 1000 /// VARIABLE CREADA POR MI
Last committed: $Revision: 00 $
__ALIGN_BEGIN USB_OTG_CORE_HANDLE
Last changed by: $Author: $
USB_OTG_dev __ALIGN_END; /// ALINEANDO EL
Last changed date: $Date: $ NUCLEO PARA QUE PUEDA COMUNICARSE

ID: $Id: $
int64_t X,Y,Z,dato,i,cont=0,X1,Y1,Z1; /// VARIABLES
PARA E ACELOROMETRO
int64_t XT,YT,ZT,XT1,YT1,ZT1; RESULTADO GENERAL PARA LAS PWMS DE LOS
MOTORES
uint8_t valores[3];
X=POSICION.X;Y=POSICION.Y;Z=POSICION.Z;
uint16_t PWM1=0,PWM2=0,TOTAL,velocidad;
XT=XT+X;YT=YT+Y;ZT=ZT+Z;
uint8_t valor;
}
char msm[16];
X1=XT/datos;Y1=YT/datos;Z1=ZT/datos;
void config_init(void); /// RUTINA DE CONFIGURACION
DE PUERTOS XT=0;YT=0;ZT=0;

// OBSERVAR DATOS REALES DE MEDICION CON

SERIAL
int main(void)
VCP_put_char(X);
{
VCP_put_char(Y);
SystemInit(); /// CONFIGURACION DE FABRICA
VCP_put_char(Z);
config_init();
// APLICAMOS EL PID DEL CONTROLADOR PARA
Set_USB(); /// LLAMAR A RUTINA COMPARAR Y SACAR UN VALOR DE PWM PARA LOS
// INICIALIZACION DEL ACELEROMETRO CONTROLADORES
STM32F407VG LIS3DSH

TM_LIS302DL_LIS3DSH_t POSICION;

if (TM_LIS302DL_LIS3DSH_Detect() == VCP_get_char(&dato,1);
TM_LIS302DL_LIS3DSH_Device_LIS302DL){TM_LIS30
2DL_LIS3DSH_Init(TM_LIS302DL_Sensitivity_2_3G,
TM_LIS302DL_Filter_2Hz);}
}
else if (TM_LIS302DL_LIS3DSH_Detect() ==
TM_LIS302DL_LIS3DSH_Device_LIS3DSH){TM_LIS302 }
DL_LIS3DSH_Init(TM_LIS3DSH_Sensitivity_2G,
TM_LIS3DSH_Filter_800Hz);}
void config_init(void)
else {/*SI EL DISPOSITIVO NO ES RECONOCIDO */
while (1);} {

while(1) // DEFINICION DE SALIDAS PARA EL CONTROL DE

LOS MOTORES Y PWM
{
// DEFINICIONES PARA LAS SALIDA
/* MOTOR1_DERECHA PD10 Y PD11 MOTOR2
// PRUEBA DE DATOS CON LCD IZQUIERDA PD12 Y PD14

sprintf(&msm,"X:%d Y:%d Z:%d",X,Y,Z); GPIO_InitTypeDef salidass;

TM_HD44780_Puts(0,1,msm);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,E
*/ NABLE);

// OBTENGO DATOS DE POSICIONES X,Y,Z

salidass.GPIO_Pin=GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_
for(i=0;i<=datos;i++) 12|GPIO_Pin_14;
{ salidass.GPIO_OType=GPIO_OType_PP;
TM_LIS302DL_LIS3DSH_ReadAxes(&POSICION); salidass.GPIO_Mode=GPIO_Mode_OUT;
// DETERMINACION DE LOS PARAMETROS Y salidass.GPIO_PuPd=GPIO_PuPd_NOPULL;
LINEALIZACION DE X,Y,Z Y OBTENER UN
 salidass.GPIO_Speed=GPIO_Speed_100MHz; TIM_TimeBaseInit(TIM4, &timer);

GPIO_Init(GPIOD,&salidass); TIM_Cmd(TIM4, ENABLE);/// habilitar timer

GPIO_InitTypeDef pwms; // PWM MODE 2 = CLEAR ON MATCH,PWM MODE 1 =

SET ON MATCH

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, TIM_OCInitTypeDef configtimer;

ENABLE);
configtimer.TIM_OCMode = TIM_OCMode_PWM2;
// DEFINICION DE PINES PARA MODO ALTERNO DE
TAL FORMA QUE PUEDA DEFINIRSE EL TIPO PWM configtimer.TIM_OutputState =
TIM_OutputState_Enable;/// HABILITAR SALIDA
GPIO_PinAFConfig(GPIOD, GPIO_PinSource13,
GPIO_AF_TIM4); configtimer.TIM_OCPolarity =
TIM_OCPolarity_Low;///ESTADO DE PIN
GPIO_PinAFConfig(GPIOD, GPIO_PinSource15, INICIALIZACION
GPIO_AF_TIM4);
// EL TIMER 4 POSEE 4 OCX POR LO QUE SE PODRIA
// CONFIGURO SALIDAS PINES COMO SALIDAS PARA SACAR 4 PWMS
PWMS PD13 Y PD15 MOTOR1 Y MOTOR 2
RESPECTIVAMENTE configtimer.TIM_Pulse = 0;

pwms.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_15; TIM_OC2Init(TIM4, &configtimer);

pwms.GPIO_OType = GPIO_OType_PP; TIM_OC2PreloadConfig(TIM4,

TIM_OCPreload_Enable);
pwms.GPIO_PuPd = GPIO_PuPd_NOPULL;
configtimer.TIM_Pulse = 0;
pwms.GPIO_Mode = GPIO_Mode_AF;
TIM_OC4Init(TIM4, &configtimer);
pwms.GPIO_Speed = GPIO_Speed_100MHz;
TIM_OC4PreloadConfig(TIM4,
GPIO_Init(GPIOD, &pwms); TIM_OCPreload_Enable);

// CONFIGURO TIMER 4 PARA GENERACION DE LAS // MODO ENCODER PARA TOMA DE VELOCIDAD DEL
PWMS ENCODER PC6

TIM_TimeBaseInitTypeDef timer; /*GPIO_InitTypeDef encoder;

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,
ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC,E
NABLE);
// TIMER 4 ESTA CONECTADO A APB1 LA CUAL
DUPLICA EL DOBLE LA FRECUENCIA QUE TIENE LA encoder.GPIO_Pin=GPIO_Pin_6;
TARJETA DE 42MHZ A 84 MHZ
encoder.GPIO_OType=GPIO_OType_PP;
timer.TIM_Prescaler = 0;
encoder.GPIO_Mode=GPIO_Mode_AF;
timer.TIM_CounterMode = TIM_CounterMode_Up;
encoder.GPIO_PuPd=GPIO_PuPd_UP;
// EL SETCOMPARE SOLO PUEDE VARIAR DE 0 A
65535 PUES EL TIMER 4 ES DE RESOLUCION DE 16 encoder.GPIO_Speed=GPIO_Speed_100MHz;
BITS GPIO_Init(GPIOC,&encoder);
// PWMFR = TIMERFR / (TIMERPERIODO +
1),TIMERPERIODO= TIMERFR / PWMFR - 1 ,SI GPIO_PinAFConfig(GPIOC,GPIO_PinSource6,GPIO_AF_
QUISIERAMOS UNA FRECUENCIA DE 10Khz EL TIM8);
PERIODO DE LO CALCULARIA TIMERPERIODO =
84000000 / 10000 - 1 = 8399
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM8,EN
timer.TIM_Period = 8399; ABLE);
timer.TIM_ClockDivision = TIM_CKD_DIV1;

timer.TIM_RepetitionCounter = 0;
 salidas11.GPIO_PuPd=GPIO_PuPd_NOPULL;
TIM_EncoderInterfaceConfig(TIM8,TIM_EncoderMode_TI
12,TIM_ICPolarity_BothEdge,TIM_ICPolarity_BothEdge); salidas11.GPIO_Speed=GPIO_Speed_100MHz;

//TIM_SetAutoreload(TIM8,0xffff); GPIO_Init(GPIOD,&salidas11);

TIM_Cmd(TIM8,ENABLE); // INICIALIZACION DE LCD

*/ TM_HD44780_Init(16,2);

/* TIM_TimeBaseInitTypeDef unsegundo; // ESPERA TM_HD44780_Puts(0,0,"MANEJO DE PRUEBA");

250ms Y SALTA HACIA LA INTERRUPCION QUE HACE TM_HD44780_Puts(0, 1,"*****CON LCD****");
QUE CALCULES LA VELOCIDAD
Delayms(1000);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7,EN TM_HD44780_Clear();
ABLE);
TM_HD44780_CursorOn();
unsegundo.TIM_ClockDivision=TIM_CKD_DIV1;
TM_HD44780_BlinkOn();
unsegundo.TIM_CounterMode=TIM_CounterMode_Up;
*/
unsegundo.TIM_Prescaler=0;//1024
}
unsegundo.TIM_RepetitionCounter=0;

unsegundo.TIM_Period=1000;//36000;//145 para 100hz

void Set_USB(void){
//20400
/* Setup USB */
TIM_TimeBaseInit(TIM7,&unsegundo);
USBD_Init(&USB_OTG_dev,USB_OTG_FS_CO
TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE);
RE_ID,&USR_desc,&USBD_CDC_cb,&USR_cb);
TIM_Cmd(TIM7,ENABLE);
}
NVIC_InitTypeDef tim1interrupt;

tim1interrupt.NVIC_IRQChannel=TIM7_IRQn;
void OTG_FS_IRQHandler(void)
tim1interrupt.NVIC_IRQChannelCmd=ENABLE;
{
tim1interrupt.NVIC_IRQChannelPreemptionPriority=0;
USBD_OTG_ISR_Handler (&USB_OTG_dev);
tim1interrupt.NVIC_IRQChannelSubPriority=1;
}
NVIC_Init(&tim1interrupt);

void OTG_FS_WKUP_IRQHandler(void)
*/
{
/*
if(USB_OTG_dev.cfg.low_power)
// DEFINO SALIDAS PARA EL LCD
{
GPIO_InitTypeDef salidas11;
*(uint32_t *)(0xE000ED10) &= 0xFFFFFFF9 ;

SystemInit();
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,E
NABLE); USB_OTG_UngateClock(&USB_OTG_dev);

}
salidas11.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_
2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5; EXTI_ClearITPendingBit(EXTI_Line18);

salidas11.GPIO_OType=GPIO_OType_PP; }

salidas11.GPIO_Mode=GPIO_Mode_OUT;
void TIM7_IRQHandler(void)
{

//velocidad=TIM_GetCounter(TIM8)*0.05906628024;

//velocidad= velocidad*0.1180555556+130;

//TIM_SetCounter(TIM8,0);

velocidad=TIM_GetCounter(TIM8);

TIM_ClearITPendingBit(TIM7,TIM_IT_Update);

TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE);