{"id":26460131,"url":"https://github.com/tomaslopera/mbed_project","last_synced_at":"2026-05-18T00:32:58.848Z","repository":{"id":192903940,"uuid":"687703505","full_name":"Tomaslopera/Mbed_Project","owner":"Tomaslopera","description":null,"archived":false,"fork":false,"pushed_at":"2023-11-26T06:03:56.000Z","size":38,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-08-24T13:50:49.083Z","etag":null,"topics":["arduino","keil-studio","mbed"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Tomaslopera.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null}},"created_at":"2023-09-05T20:39:44.000Z","updated_at":"2023-11-26T06:07:24.000Z","dependencies_parsed_at":"2023-11-26T08:19:44.075Z","dependency_job_id":"b460ae5b-83b8-4720-8ff5-50ec171a63fa","html_url":"https://github.com/Tomaslopera/Mbed_Project","commit_stats":null,"previous_names":["tomaslopera/parcial_2023_2","tomaslopera/mbed_project"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Tomaslopera/Mbed_Project","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tomaslopera%2FMbed_Project","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tomaslopera%2FMbed_Project/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tomaslopera%2FMbed_Project/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tomaslopera%2FMbed_Project/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Tomaslopera","download_url":"https://codeload.github.com/Tomaslopera/Mbed_Project/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Tomaslopera%2FMbed_Project/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33160481,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-17T22:39:12.733Z","status":"ssl_error","status_checked_at":"2026-05-17T22:39:10.741Z","response_time":107,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["arduino","keil-studio","mbed"],"created_at":"2025-03-19T02:48:29.707Z","updated_at":"2026-05-18T00:32:58.832Z","avatar_url":"https://github.com/Tomaslopera.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"## Mbed Project\n\nEs un proyecto elaborado en Keil Srudio con C++ para implementar en la tarjeta arduino FRDM-KL25Z, se necesita de un teclado matricial numérico para poder implementar el código.\n\n**INTEGRANTES:**\n\n \u003e Tomás Lopera\n\n \u003e Pedro Sierra\n\n**Librerías Utilizadas**: #include \"mbed.h\": Incluye la librería \"mbed\" que proporciona una abstracción para interactuar con el hardware, en este caso la tarjeta\n\n\n**Matriz de Teclado Numérico:** Se define una matriz de teclado numérico representada por objetos DigitalIn para las filas y DigitalOut para las columnas.\n\n```\n string teclado[][3] = {\n      {\"1\", \"2\", \"3\"},\n      {\"4\", \"5\", \"6\"},\n      {\"7\", \"8\", \"9\"},\n      {\"*\", \"0\", \"#\"}\n  };\n```\n\n**Matriz de Traducción:** Se define una matriz bidimensional de strings llamada teclado que asocia las teclas del teclado numérico con valores numéricos o letras.\n\n**Función escribir():** Esta función verifica qué tecla se ha presionado en la matriz de teclado numérico y \ndevuelve el valor asociado a esa tecla según la matriz de traducción, utiliza dos ciclos For para reconocer segun la fila y la columna \ncual fue la tecla precionada en el teclado \n\n```\nstring escribir() {\n\n    ThisThread::sleep_for(500ms);\n\n    for (int i=0; i\u003c3; i++) {\n        columnas[i] = 0;\n\n        for (int j=0; j\u003c4; j++) {\n            if (filas[j]==0) {\n                columnas[i] = 1;\n                return teclado[j][i];\n            }\n        }\n\n        columnas[i] = 1;\n    }\n\n    return \"\";\n}\n```\n\n**Función colorLed():** Esta función toma un valor hexadecimal ingresado por el usuario y lo convierte en valores de colores para controlar un LED RGB. \u003cbr\u003e\na.     Inicializa tres objetos PwmOut llamados ledR, ledG y ledB para controlar los LEDs rojo, verde y azul, respectivamente. Estos objetos permiten generar señales de modulación por ancho de pulso (PWM) para ajustar la intensidad luminosa de los LEDs.\n\nb.     Establece el período de la señal PWM para cada LED mediante los métodos period().\n\nc. Lee una cadena de entrada de longitud 7 desde la comunicación serie utilizando pc.read(input, sizeof(input));. Esto se hace para recibir comandos de cambio de color en formato hexadecimal (#RRGGBB). \n\nd. Utiliza la función sscanf() para convertir la cadena hexadecimal en tres valores enteros: r (rojo), g (verde) y b (azul). Cada valor se convierte desde su representación hexadecimal de dos dígitos a su valor decimal correspondiente.\n\ng. Ajusta las señales PWM de los LEDs utilizando el método write() en los objetos ledR, ledG y ledB. La inversión (1 - valor) se utiliza porque se leen las señales (binario) al contrario, una señal PWM de 1.0 apaga el LED y una señal de 0.0 lo enciende.\n\n\n```\nvoid colorLed(unsigned int colorValue) {\n    PwmOut ledR(LED1);\n    PwmOut ledG(LED2);\n    PwmOut ledB(LED3);\n\n    ledR.period(0.01);\n    ledG.period(0.01);\n    ledB.period(0.01);\n\n    unsigned char red, green, blue;\n    red = (1 - (float)((colorValue \u003e\u003e 16) \u0026 0xFF) / 255.0f);\n    green = (1 - (float)((colorValue \u003e\u003e 8) \u0026 0xFF) / 255.0f);\n    blue = (1 - (float)(colorValue \u0026 0xFF) / 255.0f);\n\n    ledR = red;\n    ledG = green;\n    ledB = blue;\n}\n```\n\n**Función calculoNota():** Esta función toma una cadena que representa una nota numérica, la convierte en un valor double y luego determina la letra de nota correspondiente según los rangos especificados.\n\n1. **double numero = std::stod(nota);**: Esta línea convierte la cadena nota en un número de punto flotante (double) utilizando std::stod, que es una función que convierte una cadena en su equivalente numérico en punto flotante.\n\n2. **La serie de if-else if statements:** Estas son declaraciones condicionales que evalúan el valor de numero y determinan la calificación correspondiente:\n\n- Si numero está entre 0 y 3 (ambos inclusive), se imprime \"Nota: A\".\n- Si numero está entre 3 (exclusivo) y 4 (inclusive), se imprime \"Nota: B\".\n- Si numero está entre 4 (exclusivo) y 5 (inclusive), se imprime \"Nota: C\".\n- Si numero está entre 5 (exclusivo) y 7 (inclusive), se imprime \"Nota: D\".\n- Si numero está entre 7 (exclusivo) y 9 (exclusivo), se imprime \"Nota: E\".\n- Si numero está entre 9 (inclusive) y 10 (inclusive), se imprime \"Nota: F\".\n- Si ninguna de las condiciones anteriores se cumple, se imprime \"Nota fuera de rango. Debe estar entre 0 y 10.\".\n\n```\nstring calculoNota(string nota){\n\n    double numero = std::stod(nota);\n\n    if (numero \u003e= 0 \u0026\u0026 numero \u003c= 3) {\n        std::cout \u003c\u003c \"Nota: A\" \u003c\u003c std::endl;\n    } else if (numero \u003e 3 \u0026\u0026 numero \u003c= 4) {\n        std::cout \u003c\u003c \"Nota: B\" \u003c\u003c std::endl;\n    } else if ( numero\u003e 4 \u0026\u0026 numero \u003c= 5) {\n        std::cout \u003c\u003c \"Nota: C\" \u003c\u003c std::endl;\n    } else if (numero \u003e 5 \u0026\u0026 numero \u003c= 7) {\n        std::cout \u003c\u003c \"Nota: D\" \u003c\u003c std::endl;\n    } else if (numero \u003e 7 \u0026\u0026 numero \u003c 9) {\n        std::cout \u003c\u003c \"Nota: E\" \u003c\u003c std::endl;\n    } else if (numero \u003e= 9 \u0026\u0026 numero \u003c= 10) {\n        std::cout \u003c\u003c \"Nota: F\" \u003c\u003c std::endl;\n    } else {\n        std::cout \u003c\u003c \"Nota fuera de rango. Debe estar entre 0 y 10.\" \u003c\u003c std::endl;\n    }\n    \n    return \"\";\n}\n```\n\n**Función raices():** Esta función toma los tres coeficientes ingresados por el usuario, los convierte en valores double y calcula las raíces de un polinomio de grado 2 utilizando la fórmula cuadrática. \n\n1. **double a = std::stod(x);, double b = std::stod(y);, double c = std::stod(z);**: Estas líneas convierten las cadenas **x, y** y **z** en números de punto flotante (double) utilizando std::stod, que es una función que convierte una cadena en su equivalente numérico en punto flotante.\n\n2. **double discriminante, raiz1, raiz2;**: Se declaran tres variables de punto flotante: discriminante, raiz1 y raiz2. El discriminante es una parte crucial en la fórmula cuadrática y se utiliza para determinar el tipo de raíces que tiene la ecuación cuadrática.\n\n3. **discriminante = b * b - 4 * a * c;**: Se calcula el discriminante utilizando la fórmula b^2 - 4ac. Esto determina si las raíces son reales o complejas.\n\n4. **if** **(discriminante \u003e= 0) {...} else {...}**: Esta estructura de control if-else se utiliza para manejar dos casos diferentes:\n\n4.1. **Caso 1 (Discriminante no negativo)**: Si el discriminante es mayor o igual a cero, entonces las raíces son reales. En este caso, se calculan las dos raíces utilizando la fórmula cuadrática estándar.\n\n4.2. **Caso 2 (Discriminante negativo):** Si el discriminante es negativo, entonces las raíces son complejas. Se calculan tanto la parte real como la parte imaginaria de las raíces complejas.\n\nEn ambos casos, se imprime el resultado en la consola.\n\n```\nstring raices(string x ,string y, string z){\n\n    double a = std::stod(x);\n    double b = std::stod(y);\n    double c = std::stod(z);\n\n    double discriminante, raiz1, raiz2;\n\n    // Calcular el discriminante\n    discriminante = b * b - 4 * a * c;\n\n    // Calcular las raíces utilizando la fórmula general\n    if (discriminante \u003e= 0) {\n        raiz1 = (-b + sqrt(discriminante)) / (2 * a);\n        raiz2 = (-b - sqrt(discriminante)) / (2 * a);\n\n        std::cout \u003c\u003c \"Las raíces son: \" \u003c\u003c raiz1 \u003c\u003c \" y \" \u003c\u003c raiz2 \u003c\u003c std::endl;\n    } else {\n        double parteReal = -b / (2 * a);\n        double parteImaginaria = sqrt(-discriminante) / (2 * a);\n\n        std::cout \u003c\u003c \"Raíces complejas: \" \u003c\u003c parteReal \u003c\u003c \" + \" \u003c\u003c parteImaginaria \u003c\u003c \"i y \" \u003c\u003c parteReal \u003c\u003c \" - \" \u003c\u003c parteImaginaria \u003c\u003c \"i\" \u003c\u003c std::endl;\n    }\n\n    return \"\";\n}\n```\n\n**MAIN** \n\nSe esta analizando la entrada del teclado (1,2 o 3) segun esto inicializa la funcion determinada, ya sea la de rgb calculo de raices o el de las notas, segun esto lee y guarda en arreglos los valores necesarios que empleará cada método, los coeficientes para el polinomio, el codigo hexadecimal para el RGB o la nota para analizar el rango. Se implementa una bandera para que se repita un while en cada caso según seleccione el usuario para que no se salga y la bandera cambia a false cuando se cumple cierta condición necesaria para que el sistema termine.\n\n1. **string tecla = \"\";**: Declara una cadena tecla y la inicializa como una cadena vacía.\n\n2. **while (true) {...}**: Inicia un bucle infinito, lo que significa que el programa continuará ejecutándose indefinidamente hasta que se interrumpa manualmente.\n\n3. **tecla = escribir();**: Llama a una función escribir() que es esponsable de obtener la entrada del usuario mediante el teclado matricial y asigna el resultado a la variable tecla.\n\n4. **if (tecla != \"\") {...}**: Verifica si la entrada del usuario no es una cadena vacía. Si es así, ejecuta el bloque de código dentro del if.\n\n5. Dentro del bloque if (tecla != \"\") {...}, el programa realiza diferentes acciones según el valor de tecla:\n\n- Si tecla es \"1\", el programa espera recibir tres coeficientes y luego calcula e imprime las raíces de la ecuación cuadrática.\n\n- Si tecla es \"2\", el programa espera recibir una nota y luego calcula e imprime la calificación correspondiente.\n\n- Si tecla es \"3\", el programa espera recibir un número hexadecimal y luego llama a la funcion colorLed que se encarga de encender un led rgb a partir de los datos ingresados por el usuario.\n\n- Si tecla no coincide con ninguna de las opciones anteriores, el programa imprime \"Número no válido\".\n\n6. return 0;: La función main retorna 0, indicando que el programa finalizó correctamente.\n\n```\nint main()\n{\n    string tecla = \"\";\n    while (true) {\n        //     cout \u003c\u003c \"Selecciona una opción: \\n\" \u003c\u003c endl;\n        //     cout \u003c\u003c \"1. Aplicación que calcule las raices del polinomio de grado 2 \\n\" \u003c\u003c endl;\n        //     cout \u003c\u003c \"2. Ingreso de una Nota N con devolución de una letra \\n\" \u003c\u003c endl;\n        //     cout \u003c\u003c \"3. Colores en un LED rgb \\n\" \u003c\u003c endl;\n        tecla = escribir();\n        if (tecla != \"\") {\n            cout \u003c\u003c tecla \u003c\u003c endl;\n            if (tecla == \"1\"){\n                // Ingresa tres coeficientes               \n                std:string coeficientes[3];\n                int i = 0;\n                bool flag = true;\n                while (flag){\n                    coeficientes[i++] = escribir();\n                    if (i == 2){\n                        string x = coeficientes[0];\n                        string y = coeficientes[1];\n                        string z = coeficientes[2];\n                        raices(x, y, z);\n                        if (x != \"\" \u0026\u0026 y != \"\" \u0026\u0026 z != \"\"){\n                            i++;\n                            flag = false;\n                        }\n                    }\n                }                \n            } else if (tecla == \"2\"){\n                // Ingrese una Nota\n                string nota = \"\";\n                bool flag = true;\n                while (flag){\n                    nota = escribir();\n                    if (nota != \"\"){\n                        calculoNota(nota);\n                        flag = false;\n                    }\n                }\n            } else if (tecla == \"3\"){\n                // LED rgb\n                std::string numeroHexadecimal = \"\";\n                int i = 0;\n                bool flag = true;\n                while (flag){\n                    numeroHexadecimal += escribir();\n                    if (numeroHexadecimal != \"\"){\n                        cout \u003c\u003c numeroHexadecimal \u003c\u003c endl;\n                        i++;\n                    }\n                    if (numeroHexadecimal.length() == 6){\n                        char inputHex[7];\n                        numeroHexadecimal.copy(inputHex, numeroHexadecimal.length() + 1);\n                        unsigned int colorValue;\n                        if (sscanf(inputHex, \"%6x\", \u0026colorValue) == 1) {\n                            printf(\"Valor hexadecimal válido \\n\");\n                            colorLed(colorValue); // Controla el LED RGB con el valor hexadecimal almacenado\n                        } else {\n                            printf(\"Valor hexadecimal no válido.\\n\");\n                        }\n                        if (i == 5){\n                            flag = false;\n                        }\n                    }\n                }\n            } else {\n                cout \u003c\u003c \"Número no válido\" \u003c\u003c endl;\n            }\n        }\n    }\n}\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftomaslopera%2Fmbed_project","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftomaslopera%2Fmbed_project","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftomaslopera%2Fmbed_project/lists"}