INSTITUTO POLITECNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERIA MECÁNICA Y ELÉCTRICA, ZACATENCO

Ingeniería en Comunicaciones y Electrónica

Microprocesadores

Práctica Torreta

TAFOYA HERNANDEZ NATAN GAMALIEL

6CV3
OBJETIVO: Implementar Torreta con 2 melodias distintas con opción a controlar un motor
a pasos
DESARROLLO:
Primero, debemos conectar en la BluePill tal y como nos indica el programa:
/**
#####################################################################
########
** @file
** Archivo : main.cpp
** Proyecto : Bluepill_Torreta_Enhenced
** Procesador : STM32F103C8T6
** Plataforma : Bluepill
** Herramienta : Mbed Keil Studio Cloud
** Compilador : Mbed Online C Compiler
** Version : Keil Studio Cloud 1.6.16
** Fecha/Hora : 18-12-2019, 11:48, # CodeG
** @brief
** Descripción :
** Este proyecto es la versión mejorada de la Torreta y el
Medidor
** de Barras, compartiendo los mismos pines del puerto
definido para
** ambos.
** Muestra la utilización de un registro retentivo (Latch)
para retener
** datos mientras otro proceso utiliza el mismo bus de datos.
** El primero se actualiza por medio de la interrupción del
Ticker,
** el cual retiene su valor a través de un Latch
Transparente.
** La Barra de Led's se actualiza directamente después de
cada ciclo
** de Conversión del ADC asociado al Potenciómetro. La
Torreta junto
** con con el Latch Transparente SN74HC573 y la Barra de
Led's
** comparten el mismos bus de datos.
** Uno es una secuencia y el otro es un proceso cíclico que
actualiza
** cada vez que el ADC genera un nuevo valor obtenido de la
posición
** de un potenciometro.
** Componentes : GPIO, Timer, etc .
** Configuraciones : Includes, Stacks y Drivers externos
** Autores :
** ATEAM Development Group:
** - Antulio Morgado Valle
**
** Versión : Beta
** Revisión : A
** Release : 0
** Bugs & Fixes :
** Date : 20/10/2019
** Added support for Led_RGB
** 22/09/2018
** Added LCD Menu, Beta version (with bugs)
**
**
#####################################################################
######*/
/*
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::::::::
: Includes
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::::::::
*/
#include "stm32f103c8t6.h"
#include "mbed.h"
#include "Escalas.h"
#include <cstdint>
/*
:....................................................................
...........
: Definiciones
:....................................................................
...........
*/
#define LED_ON 1 // Estado para el Led Encendido
#define LED_OFF 0 // Estado para el Led Apagado
#define BUZZ_ON 1 // Estado para Buzzer Encendido
#define BUZZ_OFF 0 // Estado para Buzzer Apagado
#define BUZZ_TYPE 1 // Tipo de Buzzer: 0=Pasivo,
1=Activo
#define ON 0 // Estado para boton presionado
#define OFF 1 // Estado para boton sin
presionar
#define HOLD 2 // Estado para boton mantenido
#define RELEASE 3 // Estado para boton liberado
#define REPEAT 4 // Estado para boton repetido
#define FALSE 0 // Estado FALSO
#define TRUE 1 // Estado VERDADERO
#define DELAY 500 // Tiempo de retardo entre
secuencias (en ms)
#define TICKER_RATE 1000 // Periodo de Interrupción (us)
#define BAUD_RATE 115200 // Velocidad de Transmisión
(Bauds)
// Velocidades Permitidas:
// 300, 600, 1200, 2400, 4800,
9600,
// 14400, 19600, 28800, 38400,
57600
// 115200, 230400
/*
*====================================================================
===========
*
* C O N F I G U R A C I O N D E P U E R T O S
*
*====================================================================
===========
*/
Ticker Barrido; // Interrupción del Timer
AnalogIn Pot1(PA_1); // Potenciometro ADC12_IN1
DigitalOut Led_Monitor (LED1); // Led monitor de la Tarjeta
STM32F103C8
DigitalOut latch_enable(PB_5); // Latch Enable SN74HC573
//BusOut
Barra_Leds(PA_8,PA_9,PA_10,PA_11,PA_12,PA_15,PB_3,PB_4); // (lsb ->
msb)
BusOut
Barra_Leds(PB_4,PB_3,PA_15,PA_12,PA_11,PA_10,PA_9,PA_8); // (msb ->
lsb)
//BusOut Barra_Leds(D0,D1,D2,D3,D4,D5,D6,D7); // Utilizando las
definiciones Arduino
PwmOut Buzzer(PB_0); // PB1_TIM3_CH3
PwmOut Led_Rojo(PB_1); // PB1_TIM3_CH4
PwmOut Led_Verde(PA_7); // PA7_TIM3_CH2
PwmOut Led_Azul(PA_6); // PA6_TIM3_CH1
Serial PC_Terminal (PA_2, PA_3); // Tx, Rx - Terminal Serial
(TTL Level)
PwmOut Motor_1(PB_12); //Motor 1
PwmOut Motor_2(PB_13); //Motor 2
/*
#====================================================================
===========
|
| A R E A D E D A T O S
|
#====================================================================
===========
*/
/*
+--------------------------------------------------------------------
-----------
| Variables Globales de Usuario
+--------------------------------------------------------------------
-----------
*/

float badRomance[] = {SOL4, SOL4, SOL4, RE4, MI4, FA4, // RAH RAH
AH-AH-AH
MI4, MI4, MI4, FA4, SOL4, // ROMA,
ROMA-MA
SOL4, SOL4, MI4, MI4, FA4}; // GA-GA
OOH-LA-LA
float felizCumple[] = {
SOL4, SOL4, LA4, SOL4, DO5, SI4, // Feliz cumpleaños a ti
SOL4, SOL4, LA4, SOL4, RE5, DO5, // Feliz cumpleaños a ti
SOL4, SOL4, SOL5, MI5, DO5, SI4, LA4, // Feliz cumpleaños
querido/a [Nombre]
FA5, FA5, MI5, DO5, RE5, DO5 // Feliz cumpleaños a ti
};

uint16_t No_Secuencias=sizeof(badRomance); // Número de secuencias a

desplegar para la Torreta
uint16_t No_Tonos=sizeof(badRomance)/4; // // Número de tonos a sonar
para la Sirena (los números flotantes ocupan 4 bytes)
uint16_t i=0; // Indice para las secuencias
para la Torreta
uint16_t j=0; // Indice para las secuencias
para la Sirena
uint16_t Retardo = TICKER_RATE+245; // Contador de mili segundos
uint8_t Pos1; // Posición del Servo Motor
uint8_t buffer_temp=0; // Variable temporal (para
guardar datos temporalmente)
float Lectura; // Lectura del valor del
Potenciometro
/* END Global Variables */
/*
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++
| Definición de Funciones Prototipo y Rutinas de los Vectores de
Interrupción
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++
*/
void Barrido_OnInterrupt(void);
void Setup(void);
void Caratula(void);
void Buzzer_Beep(void);
void Buzzer_SetPeriodMode(float Periodo,bool Estado);
float log2lin(float x, float in_min, float in_max, float out_min,
float out_max ); // Linealiza la Respuesta del Potenciómetro
float Futaba(float duty);
/*
#====================================================================
===========
|
| P R O G R A M A P R I N C I P A L
|
#====================================================================
===========
*/
int main()
{
//+++++++++++++++++++ Secuencia Principal ++++++++++++++++++++++++++
+++++++++++
// Inicialización de variables, puertos, interrupciones y
carátula
Setup();
Caratula();

//+++++++++++++++++++ Lazo Principal ++++++++++++++++++++++++++++++++

+++++++++++
// El Lazo del Programa principal está aquí !!!
while (TRUE)
{
// Lectura = Pot1; //
Lee el Potenciometro
// Lectura = Pot1.read(); //
Lee el Potenciometro
Lectura = log2lin (Pot1,0.0f,1.0f,0.0f,1.0f); //
Lee y linealiza el Potenciometro
// Lectura = log2lin (Pot1.read(),0.0f,1.0f,0.0f,1.0f); //
Lee y linealiza el Potenciometro
PC_Terminal.printf ("\r\t\ttLectura: %f \r",Lectura);
Led_Rojo = Lectura; //
Cambia la Intensidad Luminosa del Led_Rojo
Led_Verde = Lectura; //
Cambia la Intensidad Luminosa del Led_Verde
Led_Azul = Lectura; //
Cambia la Intensidad Luminosa del Led_Azul
// Servo1.write(Futaba(Lectura)); //
Cambia el Ciclo de Trabajo del Servo
// Pos1 = (Servo1-0.025) * 1850; //
Calcula la posición en grados
// Servo1 = (Futaba(Lectura)); //
Cambia el Duty Cycle del Servo

//------Nivel de la Balla de Led's --------------------

if ( Lectura <= 0.05)

{
Barra_Leds = 0x00;
wait_ms(500);
Barra_Leds = 0x01;
wait_ms(500);
}
else if ( (0.050 < Lectura) && (Lectura <= 0.125)) Barra_Leds
= 0x01;
else if ( (0.125 < Lectura) && (Lectura <= 0.250)) Barra_Leds
= 0x03;
else if ( (0.250 < Lectura) && (Lectura <= 0.375)) Barra_Leds
= 0x07;
else if ( (0.375 < Lectura) && (Lectura <= 0.500)) Barra_Leds
= 0x0F;
else if ( (0.500 < Lectura) && (Lectura <= 0.625)) Barra_Leds
= 0x1F;
else if ( (0.625 < Lectura) && (Lectura <= 0.750)) Barra_Leds
= 0x3F;
else if ( (0.750 < Lectura) && (Lectura <= 0.875)) Barra_Leds
= 0x7F;
else if ( (0.875 < Lectura) && (Lectura <= 0.998)) Barra_Leds
= 0xFF;
 else if ( Lectura > 0.998)
{
Barra_Leds = 0x7F;
wait_ms(500);
Barra_Leds = 0xFF;
wait_ms(500);

}
PC_Terminal.printf ("\r\t\t\t\tNivel: %.2f %% \t\t\tPosicion:
%3d \r",(Lectura*100), Pos1);
// PC_Terminal.printf ("\r\t\t\tNivel: %.2f %% \r",
(Lectura*100));
// PC_Terminal.printf ("\r\t\t\t\t\t\tPosicion: %3d\x0d\
r",Pos1);
}
}
/* END main */
/*
+====================================================================
===========
|
| V E C T O R E S D E I N T E R R U P C I O N
|
+====================================================================
===========
*/
/* Rutina de Atención a la Interrupción */
/* Write your code here ... */

/*
###################################################################
** Evento : Barrido_OnInterrupt()
** Proyecto : STM32F103C8_Torreta
** Procesador : STM32F103C8T6
** Herramienta : Mbed
** Compilador : Mbed Online C Compiler
** Version : Mbed-OS 5.15.0
** Compiler : GNU C Compiler
** Date/Time : 18-12-2019, 11:48, # CodeGen: 0
** Abstract :
** This is user's event module.
** Put your event handler code here.
** Settings :
** Contents :
** Cpu_OnNMIINT - void Cpu_OnNMIINT(void);
**
**
###################################################################*/
void Barrido_OnInterrupt()
{
Retardo--; // Decremeta el contador
del Retardo (milisegundos)
if (!Retardo) // Contador es igual a
Cero?
{
buffer_temp=Barra_Leds; // Guarda el valor de la
Barra de Leds
latch_enable=TRUE; // Latch Enable SN74HC573
(Enciende)
Barra_Leds=badRomance[i]; // Escribe la
secuencia de la Torreta
latch_enable=FALSE; // Latch Enable SN74HC573
(Apaga)
Barra_Leds=buffer_temp; // Recupera el valor de
la Barra de Leds
Buzzer_SetPeriodMode(badRomance[j],1); // Suena la Sirena
i++; // Incrementa el índice
de las secuenciasa
j++; // Incrementa el índice
de los tonos
PC_Terminal.printf ("\rSecuencia Numero: %d ",i);
if (i >= No_Secuencias) i=0; // Es la última
secuencia?
if (j >= No_Tonos) j=0; // Es lel último tono?
Retardo = DELAY; // Reinicia retardo
programado
Led_Monitor = !Led_Monitor; // Parpadeo del Led
Monitor
}
}
/* END Events */

/*
____________________________________________________________________
__________
/
_____________________________________________________________________
_________\
|
|
| F U N C I O N E S P R O T O T I P O
|
|
_____________________________________________________________________
_________|
\
_____________________________________________________________________
________/
*/
// Las Funciones Prototipo van aquí !
/*!
*--------------------------------------------------------------------
---
* @code
* Función : Setup()
* @brief
* Descripción : Rutina para inicialización de los puertos y
funciones
* de la Bluepill
* @param
* Parámetros : Ninguno
* @return
* Retorna : Nada
* @endcode
*--------------------------------------------------------------------
---
*/
void Setup()
{
confSysClock(); // Inicialización del Sistema,
PC_Terminal.baud(BAUD_RATE); // Se configura la velocidad de
transmisión
Buzzer_Beep(); // Prueba el Buzzer
PC_Terminal.printf(" System is Wake Up!.\n\r"); // e inicia
la comunicación con la Terminal
Barrido.attach_us(&Barrido_OnInterrupt, TICKER_RATE); // Periodo de
la Interrupción por Timer = 1ms (TICKER_RATE=1000)
}
/*!
*--------------------------------------------------------------------
---
* @code
* Función : Caratula()
* @brief
* Descripción : Imprime la carátula de bienvenida en la
terminal Serial
* @param
* Parámetros : Ninguno
* @return
* Retorna : Nada
* @endcode
*--------------------------------------------------------------------
---
*/
void Caratula()
{
PC_Terminal.printf(" =)\e[2J"); // Clear Screen
PC_Terminal.printf ("\t\e[1;37;41mInstituto Politecnico Nacional\
e[0m\n\r");
PC_Terminal.printf ("\e[1;37;42mESCUELA SUPERIOR DE INGENIERIA
MECANICA Y ELECTRICA\e[0m\n\r\v");
PC_Terminal.printf ("\t\e[1;34mTo\e[1;33mrre\e[1;31mta y \
e[1;37;41mBar\e[1;37;45mras\e[1;37;43m de Le\e[1;37;42md's En\
e[1;37;46mhen\e[1;37;44mced\e[0m\n\r\v\v");
PC_Terminal.printf ("\e[1;37;42mNatan Gamaliel Tafoya Hernandez\
e[0m\n\r\v");
}
/**
*--------------------------------------------------------------------
-----------
* @brief
* Función : float log2lin(x, in_min, in_max, out_min, out_max)
*
* Descripción : Rutina para linealizar una función logaritmica
* @param
* Parámetros : x, in_min, in_max, out_min, out_max
* x = valor leído
* in_min = Valor de Entrada Mínimo
* in_max = Valor de Entrada Máximo
* out_min = Valor de Entrada Mínimo
* out_max = Valor de Entrada Máximo
* @return
* Retorna : float x_lin
* x_lin = Valor Linealizado
* @endcode
*--------------------------------------------------
*/
float log2lin(float x, float in_min, float in_max, float out_min,
float out_max )
{
float x_lin =(x-in_min)*(out_max-out_min)/(in_max-in_min)
+out_min;
return x_lin;
}

/**
*--------------------------------------------------------------------
-----------
* @brief
* Función : float Futaba(float duty)
*
* Descripción : Rutina para limpiar la pantalla de la
Terminal
* @param
* Parámetros : float duty
* duty = PWM Duty Cycle (0.0 - 1.0)
* @return
* Retorna : float posicion
* posicion = Duty Cycle para Posicionar el Servo (5% -
10%)
* @endcode
*--------------------------------------------------------------------
-----------
*/
float Futaba(float duty)
{
float posicion = (duty * 0.1)+0.024;
// float posicion = porcentaje * 0.1;
return posicion;
}
// Local functions
/**
*--------------------------------------------------------------------
-----------
* @brief
* Función : clear_screen()
*
* Descripción : Rutina para limpiar la pantalla de la
Terminal
* @param
* Parámetros : Ninguno
* @return
* Retorna : Nada
* @endcode
*--------------------------------------------------------------------
-----------
*/
void clear_screen()
{
PC_Terminal.printf("\e[2J\e[H");
}

/**
*--------------------------------------------------------------------
-----------
* @brief
* Función : Buzzer_Beep()
*
* Descripción : Rutina para prueba del Buzzer
* @param
* Parámetros : Ninguno
* @return
* Retorna : Nada
* @endcode
*--------------------------------------------------------------------
-----------
*/
void Buzzer_Beep() // Software routine for
Buzzer Beep
{
/
*--------------------------------------------------------------------
| Configuración del Buzzer para Tipo Pasivo
---------------------------------------------------------------------
- */
#if BUZZER_TYPE == 0
PC_Terminal.printf("Testing Pasive Buzzer... \n\r");
Buzzer_SetPeriodMode(0.001,1); //Buzzer = 1KHz
wait_ms(750);
Buzzer_SetPeriodMode(0.001,0); //Apaga el Buzzer
wait_ms(125);
Buzzer_SetPeriodMode(0.001,1); //Buzzer = 1KHz
wait_ms(250);
Buzzer_SetPeriodMode(0.001,0); //Apaga el Buzzer
wait_ms(125);
Buzzer_SetPeriodMode(0.001,1); //Buzzer = 1KHz
wait_ms(500);
Buzzer_SetPeriodMode(0.001,0); //Apaga el Buzzer
#endif
/
*--------------------------------------------------------------------
| Configuración del Buzzer para Tipo Activo
---------------------------------------------------------------------
- */
#if BUZZER_TYPE == 1
PC_Terminal.printf("Testing Active Buzzer... \n\r");
buzzer = BUZZ_ON;
wait_ms(750);
buzzer = BUZZ_OFF;
wait_ms(125);
buzzer = BUZZ_ON;
wait_ms(250);
buzzer = BUZZ_OFF;
wait_ms(125);
buzzer = BUZZ_ON;
wait_ms(500);
buzzer = BUZZ_OFF;
#endif
PC_Terminal.printf("Buzzer OK ! \n\r");
}
/**
|--------------------------------------------------------------------
-----------
*@brief
| Función Buzzer_SetPeriodMode(Periodo, Estado)
|
| Descripción : Rutina para establecer el periodo de PWM
activa/desactiva
| el buzzer piezo eléctrico
*@param
| Parámetros : float (Periodo del canal de PWM asignado)
| bool (Activa o desactiva el buzzer)
|
| Retorna : Nada
*@endcode
|--------------------------------------------------------------------
-----------
**/
void Buzzer_SetPeriodMode(float Periodo,bool Estado)
{
Buzzer.period(Periodo); // Establece la Frecuencia
if (Estado==1)Buzzer=0.5f; // Encience el Buzzer (Dutty =
50%)
if (Estado==0)Buzzer=BUZZ_OFF; // Apaga el Buzzer
}

/* END Functions */
/* END Routines */
/* END program */

/*
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++
*********************************************************************
***********
|
| D O C U M E N T A C I Ó N
|
*********************************************************************
***********
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++
|
| La documentación va aquí!:
|
|--------------------------------------------------------------------
-----------
| IDENTIFICADORES
|--------------------------------------------------------------------
-----------
|
| prefijo significado uso
| v_ variable (var) v_nombre_variable
| c_ constante (const) c_nombre_constante
| a_ arreglo (array) a_nombre_arreglo
| s_ estructura(struct) s_nombre_estructura
| i_ índice (index) i_nombre_indice
| p_ apuntador (pointer) p_nombre_apuntador
| l_ etiqueta (label) l_nombre_etiqueta
| f_ función (function) f_nombre_funcion
| e_ evento (event) e_nombre_evento
| I_ entrada (input) I_nombre_entrada
| O_ salida (output) O_nombre_salida
| R_ registro (register) R_nombre_registro
| W_ alambre (wire) W_nombre_alambre
|
|
| sufijo significado uso
| _v variable (var) nombre_variable_v
| _c constante (const) nombre_constante_c
| _a arreglo (array) nombre_arreglo_a
| _s estructura(struct) nombre_estructura_s
| _i índice (index) nombre_indice_i
| _p apuntador (pointer) nombre_apuntador_p
| _l etiqueta (label) nombre_etiqueta_l
| _f función (function) nombre_funcion_f
| _e evento (event) nombre_evento_e
| _I entrada (input) nombre_entrada_I
| _O salida (output) nombre_salida_O
| _R registro (register) nombre_registro_R
| _W alambre (wire) nombre_alambre_W
|
|--------------------------------------------------------------------
-----------
| CONEXIÓN A LA TERMINAL SERIAL
|--------------------------------------------------------------------
-----------
|
| Los Transeptores recomedados para se pueden conectar a los
siguientes pines
| de las UART's que posee la Bluepill por medio del siguiente
conexionado.
|
| UART1 UART2 UART3 CABLE CP2102 PL2303 CH340G
FT232RL
| PA_9 PA_2 PB_10 Tx ------> Rx 3 2 2
3
| PA_10 PA_3 PB_11 Rx <------ Tx 4 3 3
2
| 3V ------ 3V 5 5 4
1
| GND ------ GND 2 1 1
4
|
|--------------------------------------------------------------------
----------
| Conexionado de los LEDS´s
|--------------------------------------------------------------------
----------
| Los leds se pueden conectar a cualquier pin que se declare como
DigitalOut
| o PwmOut.
| El dispositivo puede drenar hasta 20ma por todas sus salidas a un
voltaje de
| 3.3V, pero se recomienda no exceder de 1mA por salida.
| Esto se logra poniendo una resistencia limitadora de mínimo 330
Ohms.
|
|
| PA_8 PA_9 PA_10 PA_11 PA_12 PA_15 PB_3
PB_4
| O O O O O O O
O
| | | | | | | |
|
| | | | | | | |
|
| / / / / / / /
/
| \ 1K \ 1K \ 1K \ 1K \ 1K \ 1K \
1K \ 1K
| / / / / / / /
/
| \ \ \ \ \ \ \
\
| | | | | | | |
|
| | | | | | | |
|
| ___|___ ___|___ ___|___ ___|___ ___|___ ___|___ ___|
___ ___|___
| \ / \ / \ / \ / \ / \ / \
/ \ /
| \ / \ / \ / \ / \ / \ / \
/ \ /
| \ / \ / \ / \ / \ / \ / \ /
\ /
| __\/__ __\/__ __\/__ __\/__ __\/__ __\/__
__\/__ __\/__
| | | | | | | |
|
| | | | | | | |
|
| | | | | | | |
|
| |_________|_________|_________|_________|_________|_________|
_________|
| |
| |
| ___|___
| _____
| ___
| _
|
| GND
|
|--------------------------------------------------------------------
-----------
| Descripción del Conexionado del Buzzer
|--------------------------------------------------------------------
-----------
|
| 10
| PWM Pin -----/\/\/\/-------|
| |
| | +
| ( )
| ( )
| ( )
| ( )
| ( O ) Buzzer Piezo Eléctrico Pasivo
| ( )
| ( )
| ( )
| ( )
| |
| |
| |
| -----
| ---
| -
|
| Buzzer Piezo Eléctrico Pasivo usando lógica negativa
|
| 3V3
| O
| |
| |
| | +
| ( )
| ( o ) Zumbador o Buzzer Activo
| ( )
| |
| |
| 10 |
| PWM Pin -----/\/\/\/-------|
|
|
|--------------------------------------------------------------------
---------
| Conexión al Led RGB:
|--------------------------------------------------------------------
----------
|
| Los leds se pueden conectar a cualquier pin que se declare como
DigitalOut.
| El dispositivo puede drenar hasta 20ma por todas sus salidas a un
voltaje de
| 3.3V, pero se recomienda no exceder de 1mA por salida.
| Esto se logra poniendo una resistencia limitadora de mínimo 330
Ohms.
|
|
| PIN (Digital Out)
|
| Led ROJO Led VERDE Led AZUL
|
| R GND G B
| O O O O
| | | | |
| | | | |
| / | / /
| \ 1K | \ 2K \ 2.2K
| / | / /
| \ | \ \ UTILIZANDO LED RGB DE
CÁTODO COMÚN
| | | | |
| | | | |
| ___|___ | ___|___ ___|___
| \ / | \ / \ /
| \ / | \ / \ /
| \ / | \ / \ /
| __\/__ | __\/__ __\/__
| | | | |
* | | | |
| |________|_______|________|
|
|
|
| PIN (Digital Out)
|
| Led ROJO Led VERDE Led AZUL
|
| R VCC G B
| O O O O
| | | | |
| | | | |
| / | / /
| \ 2K | \ 1K \ 1K
| / | / /
| \ | \ \ UTILIZANDO LED RGB DE
ÁNODO COMÚN
| | | | |
| | | | |
| ___|___ | ___|___ ___|___
| /\ | /\ /\
| / \ | / \ / \
| / \ | / \ / \
| /______\ | /______\ /______\
| | | | |
| | | | |
| |________|_______|________|
|
|
|
|--------------------------------------------------------------------
---------
| Conexión al Potenciometro:
|--------------------------------------------------------------------
----------
|
| Como recomendación hay que poner un filtro pasa bajas para evitar
que el
| ruido al convertidor analógico/digital.
|
| 3.3V
| O
| |
| |
| | Conexión al Potenciometro
| |
| /
| \ 10K
| / 100
| \ <----/\/\/\/\--------------> PIN (AnalogIn Pin)
| \ |
| / |
| \ ----- 0.1uF
| | -----
| | |
| | |
| | |
| ___|___ ___|___
| _____ _____
| ___ ___
| _ _
|
| GND GND
|
|
+--------------------------------------------------------------------
-----------
| EJERCICIO
|
| 1.- Modificar este programa para:
| a) Linealizar la respuesta del potenciómetro
| b) Realizar el barrido del arreglo de atrás hacia adelante y
repetir
| 2.- Modificar el programa para incluir un arreglo de secuencias de
sonidos
| utilizando el módulo PWM (Sirena).
| Buzzer_SetPeriodMode(Sirena[i],1); // Suena la Sirena linea
281
| corregir el error que genera y ampliar el número de sonidos
generados.
| 3.- Volver a realizar éste programa utilizando apuntadores a los
arreglos.
| 4.- Modificar el programa para que detecte automáticamente el
tamaño del
| arreglo de secuencias.
|
+--------------------------------------------------------------------
-----------
|
| EXAMEN
|
| 1.- Crear programa que emule al juego de "SIMON":
| a) Incluir 4 botones, 4 Led's (Rojo, Ambar, Verde, Azul) y 4
Tonos
| b) Utilizando el generador de números pseudo-aleatorios
generar numeros
| entre 1 y 4 y asociarlos a los Led´s, botones y tonos.
| c) Comparar el número generado con la respuesta del botón
asociado en un
| plazo de 5 segundos.
| d) Si se obtuvo la respuesta correcta, volver a generar un
nuevo número
| pseudo-aleatorio. De lo contario termina el juego y emite
una secuencia
| de sonidos indicando el fin de este y vuelve al inicio del
juego.
| e) Se repite la secuencia desde el principio hasta el nuevo
número generado
| f) Si se aciertan las secuencias los números (dentro de 5
segundos cada
| una), el programa continua hasta un máximo de 16
secuencias.
| g) Si se completan los 16 aciertos de la secuencia se emitirá
una seciencia
| de sonidos indicando que ya ganó, se volver a emitir toda
la secuencia
| y volverá al inicio del juego para volver a comenzar.
|
| Mucha Suerte!
|
|--------------------------------------------------------------------
---------*
|
| Powered by
|
| T H E A N T U L I U ' S T E A M R&D Unltd
|
| Research, Development, Systems, Equipment, Support & Spare Parts.
| (C) Copyright 1989-2019, All Rights Reserved
|
| Welcome to The Beaners Proyect Community!
|--------------------------------------------------------------------
--------*/
/* END documentation */

/* END Mbed */
RESULTADOS:
https://www.youtube.com/watch?v=ZX4wSvNoXnw
CONCLUSIONES:
1. Control de Motores DC con el L293D:
- El programa permite controlar dos motores DC de manera eficiente utilizando el
controlador L293D y la BluePill.
- La dirección de rotación de los motores se maneja mediante pines de control digital, lo
que facilita cambiar entre avance y retroceso para cada motor.
2. Implementación de PWM (Modulación por Ancho de Pulso):
- El uso de la señal PWM para los motores demuestra su efectividad en el control de la
velocidad, ya que permite variar la potencia entregada sin perder precisión.
- La configuración del PWM con la librería `PwmOut` de Mbed es sencilla, permitiendo
ajustar la frecuencia y el ciclo de trabajo para controlar tanto motores como otros
periféricos (como el buzzer).

3. Interfaz de Usuario con la Terminal Serial:

- El programa incluye un sistema de retroalimentación a través del terminal serial,
proporcionando información clara sobre la lectura del potenciómetro y el estado de los
motores. Esto ayuda en la depuración y monitoreo en tiempo real.
4. Control de LEDs como Indicadores Visuales:
- También se implementa una barra de LEDs con un `BusOut`, mostrando diferentes
patrones según la velocidad del motor, lo que puede ser útil como indicador en
aplicaciones reales.
5. Uso de un Buzzer Activo:
- El programa utiliza un buzzer activo para reproducir secuencias de tonos y emitir
señales audibles, lo cual es útil como retroalimentación sonora en el sistema.
- La implementación de tonos musicales con arreglos de frecuencias muestra cómo se
pueden integrar características adicionales (como melodías) en el diseño de un sistema
basado en microcontroladores, añadiendo una dimensión más interactiva.
6. Modularidad y Organización del Código:
- El programa está organizado en varias funciones, lo que mejora la legibilidad y facilita
futuras modificaciones o expansiones.
 - La modularidad es crucial cuando se trabaja con múltiples periféricos, como motores,
LEDs y un buzzer, ya que cada módulo tiene su propio manejo y lógica independiente.

7. Sincronización y Temporización:
- Se utiliza un temporizador `Ticker` para ejecutar ciertas tareas en intervalos regulares,
como el control de la barra de LEDs y la reproducción de tonos. Esto permite que el
sistema maneje múltiples tareas en paralelo sin sobrecargar el flujo principal del
programa.
- El uso de `wait_ms()` para temporizar el encendido y apagado de LEDs o el buzzer
demuestra cómo controlar eventos secuenciales sin necesidad de complejas estructuras
de interrupción o máquinas de estado.