include "mbed.

h"
#include <string>

Serial pc(SERIAL_TX, SERIAL_RX);

DigitalOut indicator(LED1);

string password = "d1g1tals"; //CONTRASENA PRECARGADA

char success, try_counter = 3; //INTENTOS PERMITIDOS

char readPassword(void);
void authentication(char input);
void toBlock(void);

int main()
{
indicator = 0;
pc.printf("LAB 1 , EJERCICIO 2\n");
while(1)
{
success = readPassword();
authentication(success);
}
}
// LEER EL PUERTO SERIAL
char readPassword(void)
{
 char corrects = 0;
for (char i = 0;i<8;i++)
{
pc.printf("Ingrese el caracter %d:",i+1);
if (pc.getc() == password[i])
{
corrects++;
}
pc.printf("*\n");
}
return corrects;
}

// VALIDA EL NUMERO DE ACIERTOS

void authentication(char success)
{
try_counter--;
if (success == 8)
{
pc.printf("contrasena exitosa!\n");
indicator = 1;
toBlock();
}

pc.printf("Password incorrecto\n");
if (try_counter > 0)
 {
pc.printf("Intente nuevamente\n");
}
else
{
pc.printf("Excedio el numero de intentos permitidos\n");
toBlock();
}
}

// BLOQUEAR EL SISTEMA
void toBlock(void)
{
do{}while(1);
}
#include "mbed.h"
#include <string>

Serial pc(USBTX, USBRX);

DigitalOut LEDT(D13);

string operation_display = ""; // Operacion ingresada, aquí vamos

almacenando la operacion para mostrarla al final
int value_input = 0; // valor ingresado lo guardamos como entero
float tmp_value = 0.0; // Valor temporal para hacer calculos
float left_value = 0.0; // Valor almacenado antes de un signo de
adicion o resta
char in_use = true; // Flag informativa si la calculadora esta en
uso
char waiting_operator = true; // Flag para validar el operador
ingresado, cuando se ingresa un valor valido se pone en false
char pending_operation = '+'; // Operacion que me ayuda con la
jerarquía, espera hasta una adicion o resta para ejecutarlas
char actual_operation = '+'; // Operacion ingresada

void getOperator(void); //funcion que recibe operadores

void getValue(void); //funcion que recibe valores
void calculate(void); //calcular
void showResult(void); //muestra el resultado final
void clearAll(void); // reinicar variables y estados

int main() {

while (1) {

clearAll();
pc.printf("Bienvenido, para el uso de esta herramienta usted
debe\n");
pc.printf("ingresar un valor y luego un operador hasta que quiera\n");
pc.printf("conocer el resultado para lo cual debe digitar el signo
'='\n");
// esperamos el primer valor numerico
getValue();
 // Almacenamos el primer valor ingresado
tmp_value = value_input;
while (in_use) {
// esperamos hasta que se ingrese un operador valido
waiting_operator = true;
do {
pc.printf("Ingrese la operacion que desea realizar\n");
pc.printf("'+', '-', '*', '/' o si quiere obtener el resultado\n");
pc.printf("digite el signo '='\n");
getOperator();
}while(waiting_operator);

// Validamos si en la operación se obtuvo el resultado,

// entonces no necesitamos pedir mas valores
if (in_use){
getValue();
//realiza el calculo
calculate();
}
}

}
}

void getValue(void) {
// En esta funcion obtenemos el valor ingresado, lo pasamos a entero y
lo guardamos para mostrar al final
 pc.printf("Digite un valor numerico\n");
char buffer_value [10]; //se crea el buffer de entrada
pc.gets(buffer_value, 10); //se lee el puerto y se almacena
value_input = atoi(buffer_value); //se convierte a entero
sprintf(buffer_value, "%d", value_input); //se convierte en texto el
valor numerico
operation_display += buffer_value; //se concatena con la
operacion a mostrar
pc.abort_read(); //abortamos la lectura para que no
almacene en el buffer valores posteriores inesperadamente
pc.printf("%s\n",buffer_value); //imprimimos el valor ingresado
despues de la conversion a entero
}

void getOperator(void) {
// En esta funcion obtenemos la operacion a realizar, en caso de que no
sea valida vuelve a pedirla por el bucle en donde es llamada
char o = pc.getc();
if (o == '+' || o == '-' || o == '*' || o == '/' || o == '='){
waiting_operator = false; //como el operador es valida entonces
no esperamos mas
actual_operation = o; //guardamos el operador
operation_display += actual_operation; //lo guardamos para mostrar
al final
pc.printf("%c\n",o); //mostramos que es lo que ingreso el
usuario
if (o == '=') { //si el usuario quiere el resultado llamamos a la
funcion encargada
showResult();
 }
} else {
pc.printf("La opcion ingresada no es valida\n");
}
}

void calculate(void) {
//esta funcion realiza los calculos segun el operador actual
switch(actual_operation){
// La multiplicacion y la division se realizan directamente (por temas
de jerarquia matematica)
case '*':
tmp_value = tmp_value * value_input;
break;
case '/':
tmp_value = tmp_value / value_input;
break;

// La suma y la resta cargan un acumulador 'left_value' porque no

sabemos si lo que continue a esta operacion pueda tener operaciones * o
/ lo cual debe ejecutarse primero antes que + o -
case '+':
// Validamos la operacion pendiente y cargamos un nuevo valor
acumulado
if (pending_operation == '+') {
left_value += tmp_value;
} else {
left_value -= tmp_value;
 }
// Como la suma no se puede realizar inmediatamente, se almacena
esta operacion
pending_operation = '+';
tmp_value = value_input;
break;
case '-':
// Validamos la operacion pendiente y cargamos un nuevo valor
acumulado
if (pending_operation == '+') {
left_value += tmp_value;
} else {
left_value -= tmp_value;
}
// Como la resta no se puede realizar inmediatamente, se almacena
esta operacion
pending_operation = '-';
tmp_value = value_input;
break;
}
}

void showResult(void) {
//en esta funcion se muestra el resultado final
// primero validamos que el valor acumulado no sea cero para no hacer
operaciones innecesarias
if (left_value != 0){
 //por jerarquia la suma y la resta se deben hacer despues de las otras
operaciones por lo que miramos lo que esta pendiente y procedemos a
operar
if (pending_operation == '+') {
tmp_value = left_value + tmp_value;
} else {
tmp_value = left_value - tmp_value;
}
}
//al final solo imprimimos la operacion ingresada y el resultado
obtenido
pc.printf("La operacion realizada fue %s \n", operation_display.c_str());
pc.printf("y el resultado obtenido es = %5.3f \n", tmp_value);
//ademas le informamos al programa que ya no esta en uso para que
pueda reiniciar todo
in_use = false;
}

void clearAll(void) {
//cuando es llamada esta funcion, ponemos todas las variables de tal
forma que se pueda realizar una nueva operacion
value_input = tmp_value = left_value = 0;
in_use = true;
pending_operation = '+';
operation_display = "";
}#include "mbed.h"

PwmOut notas(PB_3);
DigitalIn salida(salidaaudio);
float
frec[12]={659,554,659,554,440,494,554,587,494,659,554,440};

int main() {

while(1)
{
mypwm.write(0);
while(salida)
{}
while(!salida)
{}

notas.period(1/(frec[0]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[1]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[2]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[3]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[4]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[5]));
notas.write(0.5);
wait(0.25);

notas.period(1/(frec[6]));
notas.write(0.5);
wait(0.25);

notas.period(1/(frec[7]));
mypwm.write(0.5);
 wait(0.5);

notas.period(1/(frec[8]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[9]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[10]));
notas.write(0.5);
wait(0.5);

notas.period(1/(frec[11]));
notas.write(0.5);
wait(1);

}
}