/** #############################################################################

** @file
** Archivo : main.c
** 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 0 // Estado para el Led Encendido
#define LED_OFF 1 // Estado para el Led Apagado
#define BUZZ_ON 0 // Estado para Buzzer Encendido
#define BUZZ_OFF 1 // Estado para Buzzer Apagado
#define BUZZ_TYPE 0 // 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)

/*
#===============================================================================
|
| A R E A D E D A T O S
|
#===============================================================================
*/
/*
+-------------------------------------------------------------------------------
| Variables Globales de Usuario
+-------------------------------------------------------------------------------
*/
uint8_t Torreta[]={
0x01, 0x01, 0x80, 0x80, 0x01, 0x01, 0x80, 0x80, // 8
0x01, 0x01, 0x80, 0x80, 0x01, 0x01, 0x80, 0x80, // 16
0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, // 24
0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, // 32
0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x80, 0x80, // 40
0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x80, 0x00, // 48
0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x80, 0x00, // 56
0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x80, 0x00, // 64
0x00, 0x18, 0x3C, 0x7E, 0x00, 0x18, 0x3C, 0x7E, // 72
0x00, 0x18, 0x3C, 0x7E, 0x00, 0x18, 0x3C, 0x7E, // 80
0x00, 0x18, 0x3C, 0x7E, 0x00, 0x18, 0x3C, 0x7E, // 88
0x00, 0x18, 0x3C, 0x7E, 0x00, 0x18, 0x3C, 0x7E, // 96
0x7E, 0x3C, 0x18, 0x00, 0x7E, 0x3C, 0x18, 0x00, // 104
0x7E, 0x3C, 0x18, 0x00, 0x7E, 0x3C, 0x18, 0x00, // 112
0x7E, 0x3C, 0x18, 0x00, 0x7E, 0x3C, 0x18, 0x00, // 120
0x7E, 0x3C, 0x18, 0x00, 0x7E, 0x3C, 0x18, 0x00, // 128
0x18, 0x24, 0x42, 0x81, 0x18, 0x24, 0x42, 0x81, // 136
0x18, 0x24, 0x42, 0x81, 0x18, 0x24, 0x42, 0x81, // 144
0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, // 152
0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, // 160
0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, // 168
0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, // 176
0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01, 0x80, // 184
0x01, 0x18, 0x80, 0x3C, 0x01, 0x24, 0x80, 0x3C, // 192

0x04, 0x08, 0x10, 0x20, 0x04, 0x08, 0x10, 0x20, // 200

0x04, 0x08, 0x10, 0x20, 0x04, 0x08, 0x10, 0x20, // 208
0x20, 0x10, 0x08, 0x04, 0x20, 0x10, 0x08, 0x04, // 216
0x20, 0x10, 0x08, 0x04, 0x20, 0x10, 0x08, 0x04, // 224
0x01, 0x04, 0x01, 0x08, 0x01, 0x10, 0x01, 0x20, // 232
0x01, 0x04, 0x01, 0x08, 0x01, 0x10, 0x01, 0x20, // 240
0x80, 0x20, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, // 248
0x80, 0x20, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04, // 256

0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, // 264

0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, // 272
0x88, 0x44, 0x11, 0x22, 0x88, 0x44, 0x22, 0x11, // 280
0x88, 0x44, 0x11, 0x22, 0x88, 0x44, 0x22, 0x11, // 288
0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88, // 296
0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88, // 304
0x18, 0x24, 0x18, 0x24, 0x18, 0x24, 0x18, 0x24, // 312
0x18, 0x24, 0x18, 0x24, 0x18, 0x24, 0x18, 0x24, // 320
0x18, 0x81, 0x3C, 0xC3, 0x24, 0x42, 0x0F, 0xF0, // 328
0x18, 0x81, 0x3C, 0xC3, 0x24, 0x42, 0x0F, 0xF0, // 336
0x18, 0xC3, 0x24, 0xC3, 0x18, 0xC3, 0x24, 0xC3, // 344
0x18, 0xC3, 0x24, 0xC3, 0x18, 0xC3, 0x24, 0xC3, // 352
0x20, 0x30, 0x10, 0x18, 0x08, 0x0C, 0x04, 0x01, // 360
0x04, 0x0C, 0x08, 0x18, 0x10, 0x30, 0x20, 0x80, // 368
0x20, 0x30, 0x10, 0x18, 0x08, 0x0C, 0x04, 0x01, // 376
0x04, 0x0C, 0x08, 0x18, 0x10, 0x30, 0x20, 0x80, // 384
0x81, 0x81, 0x7E, 0x7E, 0x81, 0x81, 0x7E, 0x7E, // 392
0x81, 0x7E, 0x81, 0x7E, 0x81, 0x7E, 0x7E, 0x81, // 400
0x81, 0x00, 0x81, 0x00, 0x7E, 0x00, 0x7E, 0x00, // 408
0x81, 0x00, 0x81, 0x00, 0x7E, 0x00, 0x7E, 0x00, // 416
0x80, 0x00, 0x01, 0x00, 0x7E, 0x00, 0x7E, 0x00, // 424
0x80, 0x00, 0x01, 0x00, 0x7E, 0x00, 0x7E, 0x00, // 432

0x33, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x33, 0xCC, // 440

0x01, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x80, 0x3C, // 448
0x01, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x80, 0x3C, // 456
0x3C, 0x00, 0xC3, 0x00, 0x3C, 0x00, 0xC3, 0x00, // 464
0x3C, 0x00, 0xC3, 0x00, 0x3C, 0x00, 0xC3, 0x00, // 472
0x3C, 0x3C, 0x00, 0x00, 0x3C, 0x3C, 0x00, 0x00, // 480
0x3C, 0x3C, 0x00, 0x00, 0x3C, 0x3C, 0x00, 0x00, // 488
0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, // 496
0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, // 504
 0xC3, 0x3C, 0xC3, 0x3C, 0xC3, 0x3C, 0xC3, 0x3C, // 512
0xC3, 0x3C, 0xC3, 0x3C, 0xC3, 0x3C, 0xC3, 0x3C, // 520
0x80, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x01, 0x3C, // 528
0x80, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x01, 0x3C, // 536
0x80, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x01, 0x3C, // 544
0x80, 0x3C, 0x01, 0x3C, 0x80, 0x3C, 0x01, 0x3C, // 552
0x00, 0x28, 0x00, 0x14, 0x00, 0x28, 0x00, 0x14, // 560
0x00, 0x28, 0x00, 0x14, 0x00, 0x28, 0x00, 0x14, // 568
0x80, 0xF0, 0x30, 0x0C, 0x0F, 0x80, 0xF0, 0x30, // 576
0x0C, 0x0F, 0x80, 0xF0, 0x30, 0x0C, 0x0F, 0x01, // 584
0x01, 0x0F, 0x0C, 0x30, 0xF0, 0x80, 0x0F, 0x0C, // 592
0x30, 0xF0, 0x80, 0x0F, 0x0C, 0x30, 0xF0, 0x80, // 600
0x00, 0x80, 0xF0, 0x30, 0x3C, 0x0C, 0x0F, 0x01, // 608
0x00, 0x80, 0xF0, 0x30, 0x3C, 0x0C, 0x0F, 0x01, // 616
0x00, 0x01, 0x0F, 0x0C, 0x3C, 0x30, 0xF0, 0x80, // 624
0x00, 0x01, 0x0F, 0x0C, 0x3C, 0x30, 0xF0, 0x80, // 632
0x00, 0x80, 0xF0, 0x30, 0x3C, 0x0C, 0x0F, 0x01, // 640
0x00, 0x80, 0xF0, 0x30, 0x3C, 0x0C, 0x0F, 0x01, // 648
0x00, 0x0F, 0xFF, 0xF0, 0x00, 0x0F, 0xFF, 0xF0, // 656
0x00, 0x0F, 0xFF, 0xF0, 0x00, 0x0F, 0xFF, 0xF0, // 674
0x00, 0xF0, 0x00, 0x0F, 0x00, 0xF0, 0x00, 0x0F, // 682
0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, // 690
0x00, 0x40, 0x60, 0x20, 0x30, 0x10, 0x18, 0x08, // 698
0x0C, 0x04, 0x0C, 0x08, 0x18, 0x10, 0x30, 0x20, // 706
0x80, 0x00, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00}; // 714

float Sirena[]={LA4,LA3,LA4,LA3,LA4,LA3,LA4,LA3, // 8
LA4,LA3,LA4,LA3,LA4,LA3,LA4,LA3, // 16
LA4,LA3,LA4,LA3,LA4,LA3,LA4,LA3, // 24
LA4,LA3,LA4,LA3,LA4,LA3,LA4,LA3, // 32
DO3,RE3,MI3,FA3,SOL3,LA3,SI3,DO4, // 40
DO3,RE3,MI3,FA3,SOL3,LA3,SI3,DO4, // 48
DO3,RE3,MI3,FA3,SOL3,LA3,SI3,DO4, // 56
DO3,RE3,MI3,FA3,SOL3,LA3,SI3,DO4, // 64
DO4,RE4,MI4,FA4,SOL4,LA4,SI4,DO5, // 72
DO4,RE4,MI4,FA4,SOL4,LA4,SI4,DO5, // 80
DO4,RE4,MI4,FA4,SOL4,LA4,SI4,DO5, // 88
DO4,RE4,MI4,FA4,SOL4,LA4,SI4,DO5, // 96
LA5,LA3,LA5,LA3,LA5,LA3,LA5,LA3, // 104
LA5,LA3,LA5,LA3,LA5,LA3,LA5,LA3, // 112
LA5,LA3,LA5,LA3,LA5,LA3,LA5,LA3, // 120
LA5,LA3,LA5,LA3,LA5,LA3,LA5,LA3, // 128
LA6,LA6,LA5,LA5,LA6,LA6,LA5,LA5, // 136
LA6,LA6,LA5,LA5,LA6,LA6,LA5,LA5, // 144
LA6,LA6,LA5,LA5,LA6,LA6,LA5,LA5, // 152
LA6,LA6,LA5,LA5,LA6,LA6,LA5,LA5, // 160
DO2,DO3,DO4,DO5,DO2,DO3,DO4,DO5, // 168
DO2,DO3,DO4,DO5,DO2,DO3,DO4,DO5, // 176
DO3,MI3,SOL3,DO4,MI4,SOL4,DO5,DO7, // 184
DO8,DO7,DO6,DO5,DO4,DO3,DO2,DO8, // 192
SI7,LA7,SOL7,FA7,MI7,RE7,DO7,SI7, // 200
LA7,SOL7,FA7,MI7,RE7,DO7,SI6,LA6, // 208
SOL6,FA6,MI6,RE6,DO6,SI5,LA5,SOL5, // 216
FA5,MI5,RE5,DO5,SI4,LA4,SOL4,FA4, // 224
MI4,RE4,DO4,SI3,LA3,SOL3,FA3,MI3, // 236
RE3,DO3,SI2,LA2,SOL2,FA2,MI2,RE2, // 240
DO2,MI2,SOL2,DO3,MI3,SOL3,DO4,MI4, // 248
SOL4,DO5,MI5,SOL5,DO4,MI4,SOL5,DO6, // 256
MI6,SOL6,DO7,MI7,SOL7,DO8,DO8,DO5, // 264
 DO5,DO5,SOL5,SOL5,FA5,MI5,RE5,DO6, // 272
DO6,SOL5,SOL5,FA5,MI5,RE5,DO6,DO6, // 280
SOL5,SOL5,FA5,MI5,FA5,RE5,RE5,RE6}; // 288

uint16_t No_Secuencias=sizeof(Torreta); // N�mero de secuencias a desplegar para la

Torreta
uint16_t No_Tonos=sizeof(Sirena)/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=Torreta[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(Sirena[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,
Buzzer_Beep(); // Prueba el Buzzer
PC_Terminal.baud(BAUD_RATE); // Se configura la velocidad de transmisi�n
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");
}
/**
*-------------------------------------------------------------------------------
* @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 -----/\/\/\/-------|
|
|
|------------------------------------------------------------------------------
| SN74HC573 3-STATE Octal D-Type Transparent Latch
|------------------------------------------------------------------------------
|
| Vcc
| O
| |
| | 20
| _____|_____
| 2 | | 19
| PA_8 -----| D1 Q1 |----- LED1
| | |
| 3 | | 18
| PA_9 -----| D2 Q2 |----- LED2 Truth Table
| | |
| 4 | | 17 Output Latch Data Output
| PA_10 -----| D3 Q3 |----- LED3 Control Enable
| | | L H H H
| 5 | | 16 L H L L
| PA_11 -----| D4 Q4 |----- LED4 L L X Q0
| | | H X X Z
| 6 | | 15
| PA_12 -----| D5 Q5 |----- LED5
| | |
| 7 | | 14
| PB_15 -----| D6 Q6 |----- LED6
| | |
| 8 | | 13
| PB_3 -----| D7 Q7 |----- LED7
| | |
| 9 | | 12
| PB_4 -----| D8 Q8 |----- LED8
| | |
| 11 | __ | 1
| PA_5 -----| LE OE |------
| |___________| |
| | |
| | |
| ----- -----
| --- ---
| - -
|
+-------------------------------------------------------------------------------
| 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 */