Universidad

Tecnológica
de Puebla

Técnico Superior Universitario en Mecatrónica área

Automatización

LENGUAJE DE PROGRAMACIÓN
Portafolio de evidencias

Alumno:
Nava Mendoza Maximiliano Raúl

Profesor
Jose Ignacio Loaiza Reyes

4A

03/12/2023
Universidad Tecnología de Puebla

División de mecatrónica

Área automatización

Lenguaje de programación

Practicas de la primera unidad

Nava Mendoza Maximiliano Raúl

Loaiza Reyes José Ignacio

4°A

Septiembre – Diciembre 2023

Instrucciones: Resolver los siguientes casos planteados en los módulos del cap. 2 con la
finalidad de profundizar en los conocimientos del Lenguaje de programación en un documento
Word, con su portada.

Realizar un mapa mental del capitulo 2 del Libro Diseño de Algoritmos y su

Codificación en Lenguaje C. Con la herramienta Mindmeiste

Link del mapa mental:

https://www.mindmeister.com/app/map/2980384814?t=MjHewNwVUd

1) Ejercicio 1. Realice un algoritmo para indicar las actividades que efectúa el día martes.
PAG. 22

# Lista de actividades secuenciales para un día típico

actividades_diarias = [

"Despertar a las 5 am",

"Bañarme",

"Vestirme",

"Ir a la escuela",

"Tomar clases",

"Regresar a casa",

"Pasear a mi perro",

"Comer",

"Hacer tareas",

"Dormir",

# Imprimir las actividades en orden secuencial

print("Actividades para un día típico:")

for actividad in actividades_diarias:

print(actividad)
 2) Ejercicio 2. Escriba válido o inválido en cada identificador para el pseudocódigo y responda
¿por qué? PAG. 23

● area - Válido: Es un identificador válido ya que consiste en letras minúsculas y no contiene

caracteres especiales.
●
● área - Inválido: No es un identificador válido en muchos lenguajes de programación, ya que
contiene un carácter especial (á) que no es una letra o un número.
●
● dato 1 - Inválido: No es un identificador válido, ya que contiene un espacio en blanco, lo
cual no está permitido.
●
● dato_1 - Válido: Es un identificador válido ya que consiste en letras minúsculas y/o
números, y puede incluir guiones bajos.
●
● 1radio - Inválido: No es un identificador válido ya que comienza con un número, lo cual no
está permitido. Los identificadores suelen comenzar con una letra o un guión bajo.
●
● radio1 - Válido: Es un identificador válido ya que comienza con una letra y contiene letras y
números.
3) Ejercicio 5. Calcule las siguientes expresiones en pseudocódigo y escriba el resultado
respectivo. PAG. 24

● 9+3*16/ 2**3-5/2

9 + 3 * 16 / 8 - 5 / 2

9 + 48 / 8 - 5 / 2

9 + 6 - 2.5

9 + 6 - 2.5 = 12.5

● 15/3+4*3^2-5*6

15 / 3 + 4 * 9 - 5 * 6

5 + 36 - 30

5 + 36 - 30 = 11

● (6*3+8-9/3+2∧4)/2

(18 + 8 - 9 / 3 + 16) / 2

(18 + 8 - 3 + 16) / 2

(18 + 8 - 3 + 16) / 2 = 39 / 2 = 19.5

Ejercicios complementarios de los datos y operaciones básicas en lenguaje C PAG.

24

4) Responda las siguientes preguntas:

 ● ¿Qué es un identificador?

Es una secuencia de caracteres alfanuméricos y guión bajo utilizados para nombrar variables,
constantes, tipos de dato y funciones en lenguajes de programación

● ¿Cuáles son las reglas para nombrar un identificador?

En el lenguaje C, los identificadores deben comenzar con una letra mayúscula o minúscula, o el
carácter "_" (guión bajo) como primer carácter, y no pueden contener espacios en blanco. Es
importante recordar que el C distingue entre mayúsculas y minúsculas debido a sus diferentes
códigos ASCII. Después del primer carácter, se permiten letras, dígitos y el guión bajo. No está
permitido tener dos identificadores iguales en un programa, lo que significa que dos elementos no
pueden compartir el mismo nombre. Sin embargo, es posible que un mismo identificador aparezca
en diferentes partes del programa. No se pueden utilizar palabras reservadas del lenguaje C como
identificadores, aunque los identificadores estándar pueden ser redefinidos en ciertos casos.
Además, en C, es posible tener identificadores que contengan puntos, como
"persona.apellidoPaterno".

● ¿Qué es un tipo de dato? Mencione tres tipos de datos en el lenguaje C y sus

características

Es una categoría que define qué tipo de valores pueden almacenarse en una variable y qué
operaciones se pueden realizar con esos valores. Los tipos son:

- Enteros (int): En C, los enteros son utilizados para representar números enteros sin parte
decimal. Pueden ser positivos o negativos, y su tamaño en memoria depende de la
arquitectura de la computadora, generalmente ocupando 2 o 4 bytes.
- Flotantes (float): Los flotantes se emplean para representar números con parte decimal en
el lenguaje C. Estos números pueden ser positivos o negativos y siguen el estándar IEEE
754 para representación en coma flotante.
- Caracteres (char): En C, los caracteres representan un solo carácter alfanumérico o un
símbolo. Estos se almacenan como números enteros en la tabla ASCII, ocupando 1 byte
en memoria.
● ¿Qué es una variable?

Una variable es un dato cuyo valor puede cambiar durante la ejecución del programa

● ¿Qué es una constante?

Las constantes son datos que no cambian durante el desarrollo del algoritmo o la ejecución del
programa

● ¿Qué es una expresión?

Una expresión es el resultado de combinar operandos mediante operadores

● ¿Qué es un operador?

Los operadores son símbolos que se utilizan para relacionar dos datos en una expresión y evaluar
el resultado de la operación

● Mencione tres tipos de operadores de lenguaje C.

- Aritméticos
- Incremento y decremento
- Relacionales
● ¿Qué es el orden de prioridad?
El orden de prioridad de los operadores determina el orden en el que se evalúan y ejecutan las
operaciones en una expresión. Los operadores con mayor prioridad se evalúan antes que los de
menor prioridad.

● ¿Cuál es el orden de prioridad de los operadores aritméticos?

- Paréntesis ()
- Incremento/Decremento (++, --)
- Multiplicación, División, y Módulo (*, /, %)
- Suma y Resta (+, -)
● ¿Cuándo se deben utilizar los paréntesis en una expresión? Mencione un ejemplo.

Los paréntesis se utilizan en una expresión para cambiar el orden de evaluación de los operadores
y para agrupar subexpresiones. Por ejemplo:

int resultado = (2 + 3) * 4;

● ¿Qué diferencia existe entre los operadores = y == en lenguaje C?

= se usa para asignar valores a variables, mientras que == se usa para comparar si dos valores
son iguales en una expresión condicional o de comparación.

● ¿Qué es una palabra reservada?

Las palabras reservadas son palabras específicas del lenguaje de programación que tienen un uso
definido.

● ¿Qué es un comentario y cómo se representa en lenguaje C?

Es un fragmento de texto que se utiliza para proporcionar información adicional o explicaciones

dentro del código fuente de un programa. Se pueden representar en una sola línea con “//” o en
varias líneas con “/*”

5) Ejercicio 1. Tache los identificadores que no son válidos para lenguaje C

_numero

número

año

home

dinero$

base_1

2variables

el punto

scanf

end

6) Ejercicio 2. Escriba las siguientes expresiones matemáticas como expresiones de C.

(x + y) / (x - 3) + 2 * x
(x + y / (x / 5 - 3 / y)) + 2 * x

(2 + 5 * y / (x - 3)) + 4 * x - pow(7 - y, 1.0 / 3.0)

(2 * x * y + 5 * y / (x - 3)) - ((4 * x - x * y) / pow(7 - y / (4 + x), 1.0 / 3.0))

 Universidad Tecnología de Puebla

División de mecatrónica

Área automatización

Lenguaje de programación

Productos y actividades de la primera unidad

Nava Mendoza Maximiliano Raúl

Loaiza Reyes José Ignacio

4°A

Septiembre – Diciembre 2023

 ACTIVIDADES Y PRODUCTO DE LA UNIDAD I

Actividad de apertura.

Actividad 1.1 El alumno deberá realizar un programa que incluya el uso de

los tipos de datos y variables de tipo global y local.

Para el desarrollo de este programa, se ha realizado un código que simula

una calculadora simple, la cual realiza operaciones aritméticas básicas
(suma, resta, multiplicación, división) así como operaciones lógicas.

#include <iostream>

using namespace std;

int resultadoGlobal = 0;

int operacionAritmetica(int num1, int num2, char operador) {

int resultadoLocal = 0;

if (operador == '+') {

resultadoLocal = num1 + num2;

} else if (operador == '-') {

resultadoLocal = num1 - num2;

} else if (operador == '*') {

resultadoLocal = num1 * num2;

} else if (operador == '/') {

if (num2 != 0) {
 resultadoLocal = num1 / num2;

} else {

cout << "Error: Division por cero." << endl;

} else {

cout << "Operador no valido." << endl;

return resultadoLocal;

bool operacionLogica(bool valor1, bool valor2, char operador) {

bool resultadoLocal = false;

if (operador == '&') {

resultadoLocal = valor1 && valor2;

} else if (operador == '|') {

resultadoLocal = valor1 || valor2;

} else {

cout << "Operador logico no valido." << endl;

return resultadoLocal;

void mostrarMensaje() {
 cout << "Estas ocupando una calculadora basica desarrollada en c++." <<
endl;

int main() {

int num1, num2;

char operador;

bool valor1, valor2;

char tipoOperacion;

cout << "Calculadora Simple" << endl;

cout << "Elija el tipo de operación (a para aritmetica, l para logica): ";

cin >> tipoOperacion;

if (tipoOperacion == 'a') {

cout << "Ingrese el primer numero: ";

cin >> num1;

cout << "Ingrese el operador (+, -, *, /): ";

cin >> operador;

cout << "Ingrese el segundo numero: ";

cin >> num2;

resultadoGlobal = operacionAritmetica(num1, num2, operador);

cout << "Resultado global: " << resultadoGlobal << endl;

} else if (tipoOperacion == 'l') {

cout << "Ingrese el primer valor logico (0 o 1): ";

 cin >> valor1;

cout << "Ingrese el operador logico (&, |): ";

cin >> operador;

cout << "Ingrese el segundo valor logico (0 o 1): ";

cin >> valor2;

bool resultadoLocal = operacionLogica(valor1, valor2, operador);

cout << "Resultado local: " << resultadoLocal << endl;

} else {

cout << "Tipo de operación no valida." << endl;

mostrarMensaje();

return 0;

Este código cumple con los requisitos solicitado ya que incluye las
variables globales y locales, asi como los tipos de datos de la siguiente
manera:

1. Variables globales: En el programa, la variable “resultadoGlobal” se

declara como una variable global al principio del código, fuera de
cualquier función. Una variable global es accesible desde cualquier
parte del programa y conserva su valor incluso después de que se
haya salido de una función. En este caso, se utiliza para almacenar el
resultado de una operación y se muestra al final del programa. Es
una variable global porque se declara fuera de cualquier función y,
por lo tanto, es visible en todo el programa.
 2. Variables locales: En las funciones “operacionAritmetica” y
“operacionLogica”, se utilizan variables locales, como
“resultadoLocal”. Estas variables son declaradas dentro de las
funciones y solo son visibles y accesibles dentro de esas funciones
específicas. Cada vez que se llama a una de estas funciones, se crea
una nueva variable local “resultadoLocal” para realizar cálculos
específicos dentro de la función.
3. Tipos de datos:

● Numéricos: Se utilizan variables de tipo “int” para almacenar

números enteros, como “num1”, “num2”, “resultadoGlobal” y
“resultadoLocal”.
● Lógicos: Se utilizan variables de tipo “bool” para representar valores
lógicos (verdadero o falso), como “valor1”, “valor2” y
“resultadoLocal”.
● Caracteres: Se utilizan variables de tipo “char” para almacenar
operadores aritméticos y lógicos, como “operador” y “tipoOperacion”.
● Void: En el programa, el tipo de dato void se utiliza para definir una
función que no devuelve ningún valor.

De esta manera, el programa es capaz de realizar cálculos aritméticos y

lógicos, permitiendo al usuario elegir entre diferentes tipos de operaciones
y proporcionando resultados basados en las entradas del usuario.
Actividad de desarrollo.

Actividad 1.2 El alumno deberá realizar un programa que utilice los

diferentes tipos de operadores.
Para el desarrollo de esta actividad se ha realizado un programa que
calcula el índice de masa corporal (IMC) de una persona y, en función del
resultado, muestre un mensaje de diagnóstico.

#include <iostream>

using namespace std;

int main() {

double peso, altura, imc;

cout << "Calculadora de IMC (Indice de Masa Corporal)" << endl;

cout << "Ingrese su peso en kilogramos: ";

cin >> peso;

cout << "Ingrese su altura en metros: ";

cin >> altura;

imc = peso / (altura * altura);

cout << "Su IMC es: " << imc << endl;

if (imc < 18.5) {

cout << "Bajo peso. Consulte a un medico.";

} else if (imc < 25) {

cout << "Peso normal. ¡Estas saludable!";

} else if (imc < 30) {

cout << "Sobrepeso. Consulte a un medico.";

} else {

cout << "Obesidad. Consulte a un medico.";

int contador = 5;

cout << "Ejemplo de operadores de incremento y decremento:" << endl;

cout << "Contador inicial: " << contador << endl;

contador++;

cout << "Contador después de incremento: " << contador << endl;

contador--;

cout << "Contador después de decremento: " << contador << endl;

bool haceEjercicio, sigueDieta;

cout << "¿Hace ejercicio regularmente? (1 para Si, 0 para No): ";

cin >> haceEjercicio;

cout << "¿Sigue una dieta saludable? (1 para Si, 0 para No): ";

cin >> sigueDieta;

if (haceEjercicio && sigueDieta) {

cout << "Tiene un estilo de vida saludable. ¡Siga asi!" << endl;

} else if (haceEjercicio || sigueDieta) {

cout << "Tiene hábitos saludables, pero puede mejorar." << endl;

} else {
 cout << "Considere hacer ejercicio y mejorar su dieta para mantenerse
saludable." << endl;

return 0;

Este programa incluye todos los tipos de operadores de la siguiente

manera::

Operadores aritméticos: En el programa, utilizamos la división (/) para

calcular el índice de masa corporal (IMC). Esta operación matemática es un
ejemplo de un operador aritmético.

Operadores de asignación: Utilizamos el operador de asignación (=) para

asignar valores a las variables “peso", “altura" e “imc”.

Operadores relacionales: En las sentencias “if”, comparamos el IMC con

valores numéricos utilizando operadores relacionales, como “<”, lo que nos
permite evaluar condiciones.

Operadores lógicos: Utilizamos los operadores lógicos && (AND) y || (OR)

para evaluar si el usuario hace ejercicio regularmente y si sigue una dieta
saludable. Dependiendo de las respuestas del usuario, se proporciona una
evaluación de su estilo de vida en términos de salud.

Operadores de incremento y decremento: En la sección adicional al final del

programa, se muestra un ejemplo de operadores de incremento (++) y
decremento (--) en la variable “contador”. Estos operadores se utilizan para
aumentar o disminuir el valor de una variable en una unidad.

Operadores condicionales: Las sentencias “if”, “else if", y “else” permiten

que el programa tome decisiones basadas en condiciones especificadas.
Actividad de cierre.

Actividad 1.3 El alumno deberá realizar un programa básico de control con

el manejo de las diferentes estructuras de programación.
Para esta actividad se ha desarrollado un programa interactivo que permite
al usuario elegir entre tres opciones diferentes, cada una de las cuales
demuestra una estructura de programación específica:

#include <iostream>

using namespace std;

int main() {

int opcion;

int suma = 0;

cout << "Elija una opcion:\n";

cout << "1. Estructura condicional (if-else)\n";

cout << "2. Estructura de bucle (for)\n";

cout << "3. Estructura de seleccion multiple (switch)\n";

cin >> opcion;

switch (opcion) {

case 1: {

int numero;

cout << "Ingrese un numero: ";

cin >> numero;

if (numero % 2 == 0) {

cout << "El numero es par." << endl;

} else {

cout << "El numero es impar." << endl;

 }

break;

case 2: {

for (int i = 1; i <= 10; i++) {

suma += i;

cout << "La suma de los numeros del 1 al 10 es: " << suma << endl;

break;

case 3: {

int numeroMes;

cout << "Ingrese el numero del mes (1-12): ";

cin >> numeroMes;

switch (numeroMes) {

case 1:

cout << "Enero" << endl;

break;

case 2:

cout << "Febrero" << endl;

break;

case 3:

cout << "Marzo" << endl;

 break;

case 4:

cout << "Abril" << endl;

break;

case 5:

cout << "Mayo" << endl;

break;

case 6:

cout << "Junio" << endl;

break;

case 7:

cout << "Julio" << endl;

break;

case 8:

cout << "Agosto" << endl;

break;

case 9:

cout << "Septiembre" << endl;

break;

case 10:

cout << "Octubre" << endl;

break;

case 11:

cout << "Noviembre" << endl;

break;
 case 12:

cout << "Diciembre" << endl;

break;

default:

cout << "Numero de mes no valido." << endl;

break;

default:

cout << "Opcion no valida." << endl;

return 0;

Dicho codigo contiene las siguientes estructuras:

1. Estructura condicional (if-else):

● Cuando el usuario elige la opción 1, el programa le pide ingresar un
número.
● Luego, utiliza una estructura condicional `if-else` para determinar si
el número es par o impar.
● Si el número es divisible entre 2 (es decir, el residuo es 0), el
programa muestra "El número es par"; de lo contrario, muestra "El
número es impar".
2. Estructura de bucle (for):
● Cuando el usuario elige la opción 2, el programa utiliza una
estructura de bucle `for` para calcular la suma de los números del 1
al 10.
● Inicializa una variable llamada “suma" en 0.
● Luego, ejecuta un bucle que itera desde 1 hasta 10, sumando cada
número al valor de “suma”.
● Finalmente, muestra el resultado, que es la suma de los números del
1 al 10.
3. Estructura de selección múltiple (switch):
● Cuando el usuario elige la opción 3, el programa le pide ingresar un
número de mes (1 al 12).
● Utiliza una estructura de selección múltiple “switch" para determinar
el nombre del mes correspondiente al número ingresado.
● Dependiendo del número de mes ingresado, el programa muestra el
nombre del mes utilizando los casos del “switch”.
● Si se ingresa un número que no corresponde a ningún mes, se
muestra un mensaje por defecto.
Producto de la Unidad I

Elaborará un programa básico de monitoreo de una variable en lenguaje C

(Algoritmo y diagrama de flujo).

Este programa en lenguaje C solicita al usuario que ingrese un valor numérico, el cual
se almacena en una variable llamada `variableMonitor`. Luego, muestra ese valor en
la pantalla acompañado de un mensaje descriptivo. Es un programa básico de
monitoreo de una variable, diseñado para demostrar la captura de entrada del usuario
y la salida de datos en C

#include <stdio.h>

int main() {

int variableMonitor;

printf("Ingrese un valor: ");

scanf("%d", &variableMonitor);

printf("El valor ingresado es: %d\n", variableMonitor);

 return 0;

}
.
Adicionalmente, se implementó un programa que permite al usuario
ingresar dos números y luego realiza diversas operaciones matemáticas,
incluyendo suma, resta, multiplicación, división, potencia, raíz cuadrada,
residuo, seno, coseno y tangente sobre estos números.

#include <iostream>

#include <cmath>

using namespace std;

int main() {

double numero1, numero2;

cout << "Ingrese dos numeros: ";

cin >> numero1 >> numero2;

double suma = numero1 + numero2;

double resta = numero1 - numero2;

double multiplicacion = numero1 * numero2;

double division = numero1 / numero2;

double potencia = pow(numero1, numero2);

double raizCuadrada = sqrt(numero1);

double residuo = fmod(numero1, numero2);

double seno = sin(numero1);

double coseno = cos(numero1);

double tangente = tan(numero1);

 cout << "Suma: " << suma << endl;

cout << "Resta: " << resta << endl;

cout << "Multiplicacion: " << multiplicacion << endl;

cout << "Division: " << division << endl;

cout << "Potencia: " << potencia << endl;

cout << "Raiz cuadrada de numero1: " << raizCuadrada << endl;

cout << "Residuo: " << residuo << endl;

cout << "Seno de numero1: " << seno << endl;

cout << "Coseno de numero1: " << coseno << endl;

cout << "Tangente de numero1: " << tangente << endl;

return 0;

}
 Universidad Tecnología de Puebla

División de mecatrónica

Área automatización

Lenguaje de programación

Productos y actividad de la segunda unidad

Nava Mendoza Maximiliano Raúl

Loaiza Reyes José Ignacio

4°A

Septiembre – Diciembre 2023

1
Índice
Practica. Suma y resta de matrices cuadradas de 2*2. ........................................................ 3
Instrucciones ............................................................................................................................... 3
Código ........................................................................................................................................... 3
Funcionamiento .......................................................................................................................... 5
Compilación ................................................................................................................................. 5
Ejecución ...................................................................................................................................... 5
Diagrama de bloques ................................................................................................................ 7
Producto. Monitoreo básico de una variable cona arreglos y construcción de
bloques ............................................................................................................................................. 9
Instrucciones ............................................................................................................................... 9
Código ........................................................................................................................................... 9
Funcionamiento ........................................................................................................................ 13
Compilación ............................................................................................................................... 14
Ejecución .................................................................................................................................... 15
Diagrama de bloques .............................................................................................................. 18
Lista de cotejo ............................................................................................................................... 18

2
Practica. Suma y resta de matrices cuadradas de 2*2.

Instrucciones

Generar un programa en código de C, que realice la suma y resta de matrices

cuadradas de 2*2.

Código

#include <stdio.h>

int main() {

int matrizA[2][2];

int matrizB[2][2];

int suma[2][2];

int resta[2][2];

int i, j;

printf("Ingrese los elementos de la matriz A:\n");

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

printf("Ingrese el elemento A[%d][%d]: ", i + 1, j + 1);

scanf("%d", &matrizA[i][j]);

printf("Ingrese los elementos de la matriz B:\n");

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

printf("Ingrese el elemento B[%d][%d]: ", i + 1, j + 1);

3
 scanf("%d", &matrizB[i][j]);

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

suma[i][j] = matrizA[i][j] + matrizB[i][j];

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

resta[i][j] = matrizA[i][j] - matrizB[i][j];

printf("Matriz A + Matriz B =\n");

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

printf("%d\t", suma[i][j]);

printf("\n");

printf("Matriz A - Matriz B =\n");

for (i = 0; i < 2; i++) {

for (j = 0; j < 2; j++) {

printf("%d\t", resta[i][j]);

4
 printf("\n");

return 0;

Funcionamiento

Este código realiza la suma y resta de dos matrices cuadradas de 2x2. Para esto,
en primer lugar, se solicita que se ingrese los elementos de las matrices A y B.
Luego, utiliza bucles “for” para calcular la suma y la resta de las matrices,
almacenando los resultados en las matrices suma y resta. Finalmente, el código
muestra las matrices resultantes en la consola.

Compilación

Ejecución

5
6
Diagrama de bloques

7
8
Producto. Monitoreo básico de una variable cona arreglos
y construcción de bloques

Instrucciones

Elaborar un programa básico de monitoreo de una variable en lenguaje C que

contenga:

• Arreglos unidimensionales y multidimensionales con punteros para recorrer

y acceder a arreglos de n bits
• Construcción de bloques de funciones que integren el programa de
monitoreo de una variable física considerando arreglos, punteros y
sentencias de control

Código

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define MAX_VARIABLES 10

#define MAX_ROWS 10

#define MAX_COLS 10

struct Variable {

char name[50];

float values[MAX_ROWS][MAX_COLS];

int rowCount;

int colCount;

};

9
void printVariable(struct Variable *variable) {

int i, j;

printf("Variable: %s\n", variable->name);

printf("Valores:\n");

for (i = 0; i < variable->rowCount; i++) {

for (j = 0; j < variable->colCount; j++) {

printf("%.2f\t", variable->values[i][j]);

printf("\n");

void updateVariable(struct Variable *variable, int row, int col, float newValue) {

if (row >= 0 && row < MAX_ROWS && col >= 0 && col < MAX_COLS) {

variable->values[row][col] = newValue;

if (row >= variable->rowCount) {

variable->rowCount = row + 1;

if (col >= variable->colCount) {

variable->colCount = col + 1;

} else {

printf("Coordenadas no validas.\n");

int main() {

struct Variable variables[MAX_VARIABLES];

10
int variableCount = 0;

int choice;

int i;

do {

printf("1. Agregar variable\n");

printf("2. Actualizar variable\n");

printf("3. Mostrar estado de variable\n");

printf("4. Salir\n");

printf("Opcion: ");

scanf("%d", &choice);

fflush(stdin);

switch (choice) {

case 1:

if (variableCount < MAX_VARIABLES) {

printf("Introduzca el nombre de la variable: ");

scanf("%s", variables[variableCount].name);

variables[variableCount].rowCount = 0;

variables[variableCount].colCount = 0;

variableCount++;

} else {

printf("Se alcanzo el limite de variables.\n");

break;

case 2:

if (variableCount > 0) {

printf("Seleccione la variable a actualizar:\n");

for (i = 0; i < variableCount; i++) {

11
 printf("%d. %s\n", i + 1, variables[i].name);

int selectedVariable;

scanf("%d", &selectedVariable);

fflush(stdin);

if (selectedVariable >= 1 && selectedVariable <= variableCount) {

int row, col;

float newValue;

printf("Introduzca la fila: ");

scanf("%d", &row);

printf("Introduzca la columna: ");

scanf("%d", &col);

printf("Introduzca el nuevo valor: ");

scanf("%f", &newValue);

fflush(stdin);

updateVariable(&variables[selectedVariable - 1], row, col, newValue);

} else {

printf("Opcion no valida.\n");

} else {

printf("No hay variables para actualizar.\n");

break;

case 3:

if (variableCount > 0) {

printf("Seleccione la variable a mostrar:\n");

for (i = 0; i < variableCount; i++) {

12
 printf("%d. %s\n", i + 1, variables[i].name);

int selectedVariable;

scanf("%d", &selectedVariable);

fflush(stdin);

if (selectedVariable >= 1 && selectedVariable <= variableCount) {

printVariable(&variables[selectedVariable - 1]);

} else {

printf("Opcion no valida.\n");

} else {

printf("No hay variables para mostrar.\n");

break;

case 4:

printf("Saliendo del programa.\n");

break;

default:

printf("Opcion no valida. Intente de nuevo.\n");

} while (choice != 4);

return 0;

Funcionamiento

El código permite gestionar variables con valores en una matriz bidimensional. El

programa permite agregar nuevas variables, actualizar los valores en las variables

13
existentes y mostrar el estado de las variables. Funciona a través de un menú
interactivo donde el usuario puede seleccionar las acciones deseadas. Las variables
y sus valores se almacenan en una estructura, lo que facilita la gestión de datos. El
programa puede servir para llevar un registro y análisis de múltiples variables en
una matriz, como datos de sensores o mediciones en un sistema de monitoreo
físico.

Así mismo, el programa cumple con los siguientes requisitos:

• Arreglos unidimensionales y multidimensionales con punteros: Cumple con

este requisito al utilizar matrices bidimensionales para almacenar los valores
de las variables. La estructura Variable contiene una matriz “values” que
almacena los valores de cada variable. Además, no utiliza punteros
explícitos, sino que trabaja directamente con matrices multidimensionales.
• Construcción de bloques de funciones: Cumple con esta función ya que el
programa está organizado en funciones distintas para realizar tareas
específicas. La función “printVariable” se encarga de mostrar el estado de
una variable, y la función “updateVariable” se encarga de actualizar los
valores en una variable.

Compilación

14
Ejecución

15
16
17
Diagrama de bloques

Lista de cotejo

18
 UNIVERSIDAD TECNOLÓGICA DE PUEBLA
DIVISIÓN DE MECATRÓNICA
Asignatura: Lenguaje de Programación
LISTA DE COTEJO: REPORTE DE PRÁCTICA (PRODUCTO 2)
Nombre del alumno: Nava Mendoza Maximiliano Raúl Periodo: Septiembre - Diciembre 2021
Cuatrimestre: 4° Grupo: A Fecha: 03/11/23
Programa educativo TSU en Mecatrónica: Área Automatización
El alumno elaborará a partir de un caso propuesto, un programa en Lenguaje de Programación C++ de
Especificaciones de elaboración:
monitoreo de una variable.

Criterio de evaluación SI NO Puntaje

1) Entrega en tiempo y forma en plataforma de Classroom (1 pto.)

2) Formato adecuado (1 pto.)

3) El programa funciona correctamente (1 pto.)

4)Utilizo sangría, espacios e interlineado que dé mayor claridad (1

pto.)

5) Define las etapas de elaboración del código (6 pts.)

6.a) Algoritmo y diagrama de flujo (2 ptos.)

6.b) Manejo de declaraciones, expresiones y prioridades

matemáticas (1 pto.)

6.c) Estructuras de control. (1 pto.)

6.d) Manejo de Interfaz visual (1 pto.)

6.e) Compila correctamente el código (1pto.)

Calificación

Observaciones del profesor:

Profesor de la asignatura
 Universidad
Tecnológica
de Puebla

Técnico Superior Universitario en Mecatrónica área

Automatización

LENGUAJE DE PROGRAMACIÓN
Producto 3

Alumno:
Nava Mendoza Maximiliano Raúl

Profesor
Jose Ignacio Loaiza Reyes

4A

03/12/2023
PROGRAMA DE ENCENDIDO Y APAGADO DE UN LED CON ARDUINO..........................3
Simulación del circuito........................................................................................................3
Led encendido..............................................................................................................4
Led apagado................................................................................................................ 5
Circuito de señalización y adquisición con Arduino........................................................... 5
Creación del proyecto........................................................................................................ 6
Corrida del programa y prueba del circuito........................................................................ 7
BIESTABLE............................................................................................................................. 8
Simulación del circuito........................................................................................................8
Led apagado................................................................................................................ 9
Led encendido..............................................................................................................9
Circuito de señalización y adquisición con Arduino........................................................... 9
Creación del proyecto...................................................................................................... 10
Corrida del programa y prueba del circuito...................................................................... 11
NIVEL DE LÍQUIDO CON DETECCIÓN DE SUCIEDAD EN EL SENSOR DE FONDO...... 12
Circuito de adquisición y señalización..............................................................................13
Creación del proyecto...................................................................................................... 15
Corrida del programa y prueba del circuito...................................................................... 16
PROGRAMA DE ENCENDIDO Y APAGADO DE
UN LED CON ARDUINO

Esta actividad consta de un programa simple en lenguaje de programación Arduino

que utiliza un led conectado a la placa para encenderlo y apagarlo alternativamente
con un intervalo de tiempo de 5 segundos para cada estado (encendido y apagado).
Para este proyecto se utilizaron los siguientes componentes:
● 1 diodo led.
● 1 resistencia de 270 Ω
● Jumpers macho - macho
● 1 protoboard
● 1 placa arduino

Simulación del circuito.

En el marco de un proyecto de desarrollo de sistemas de control con Arduino, se

realizó una simulación utilizando el software Tinkercad Circuits. Esta plataforma
virtual ofrece herramientas avanzadas para diseñar y simular circuitos electrónicos
de manera interactiva y educativa.
El objetivo principal fue implementar un circuito de señalización y adquisición
utilizando una placa Arduino UNO simulada junto con un LED, con el propósito de
encender y apagar el LED en intervalos específicos para mostrar visualmente una
señalización básica.
Led encendido
Led apagado

Circuito de señalización y adquisición con Arduino

Código son señalizaciones:

// Pin al que está conectado el LED

const int ledPin = 13;

void setup() {
// Inicializar el pin del LED como salida
pinMode(ledPin, OUTPUT);
}

void loop() {
// Encender el LED
digitalWrite(ledPin, HIGH);
delay(5000); // Esperar 5 segundos

// Apagar el LED
digitalWrite(ledPin, LOW);
delay(5000); // Esperar 5 segundos
}
Creación del proyecto
Una vez que se comprobó el funcionamiento del código en la simulación se
desarrolló un proyecto en el entorno de desarrollo integrado (IDE) de Arduino para
controlar el encendido y apagado de un LED.

El objetivo principal del proyecto era utilizar el IDE de Arduino para escribir y cargar
un programa simple que permitiera controlar el estado de un LED conectado a una
placa Arduino UNO.
Corrida del programa y prueba del circuito

Video de evidencia:
https://drive.google.com/file/d/1F1-54UcCB-eUVkaCSXvX-5muPrYz62fW/view?usp=sharing
BIESTABLE
Un circuito biestable se refiere a un circuito que puede mantener dos estados
estables diferentes sin la necesidad de una señal de reloj externa. Esto se puede
lograr utilizando un botón o interruptor para cambiar manualmente entre estos dos
estados.
Cuando se implementa un circuito biestable con un LED y un botón en Arduino, se
pueden utilizar dos estados estables para encender y apagar el LED, y el botón
sirve como el medio para cambiar entre estos dos estados. Para este proyecto se
utilizaron los siguientes componentes:
● 1 diodo led.
● 1 push button
● 1 resistencia de 270 Ω
● 1 resistencia de 10kΩ
● Jumpers macho - macho
● 1 protoboard
● 1 placa arduino

Simulación del circuito

En un primer momento se hizo la simulación del proyecto en la plataforma de

tinkercad, el objetivo central fue implementar un circuito de señalización y control
utilizando una placa simulada Arduino UNO junto con un LED y un botón, con la
finalidad de demostrar visualmente el encendido y apagado del LED en intervalos
específicos, así como el control mediante la interacción con un botón simulado.
El código escrito para esta simulación se centró en el uso de una resistencia
pull-down para detectar el estado de un botón simulado, permitiendo que el LED se
mantenga encendido después de presionar el botón y se apague únicamente
cuando se presione nuevamente.
Led apagado

Led encendido

Circuito de señalización y adquisición con Arduino

const int ledPin = 13;
const int buttonPin = 2;
int buttonState;
bool ledState = LOW; // Estado inicial del LED

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT); // No se necesita INPUT_PULLUP, ya que
utilizaremos una resistencia pull-down externa
}

void loop() {
buttonState = digitalRead(buttonPin);

if (buttonState == HIGH) {
// Si el botón no está presionado (lectura en HIGH por la resistencia pull-down)
digitalWrite(ledPin, ledState); // Mantener el LED en su estado actual
} else {
// Si se presiona el botón (lectura en LOW debido a la resistencia pull-down)
ledState = !ledState; // Cambiar el estado del LED
digitalWrite(ledPin, ledState); // Aplicar el nuevo estado al LED
while (digitalRead(buttonPin) == LOW) {
// Esperar hasta que el botón se suelte para evitar cambios rápidos
}
delay(50); // Pequeña pausa para evitar rebotes del botón
}
}

Creación del proyecto

Una vez confirmado el correcto funcionamiento del código en la simulación, se
procedió al desarrollo de un proyecto en el entorno de desarrollo integrado (IDE) de
Arduino para controlar el encendido y apagado de un LED.
El propósito principal de este proyecto fue utilizar el IDE de Arduino para escribir y
cargar un programa simple que permitiera gestionar el estado de un LED conectado
a una placa Arduino UNO.
El código desarrollado en el IDE de Arduino se enfocó en el uso de las funciones
digitalWrite() y delay() para controlar el estado de un LED conectado a un pin digital
de la placa.

Corrida del programa y prueba del circuito

Video de evidencia:
https://drive.google.com/file/d/1GNi5gvH9j6GqeL8v5T01-bkFSLeP_WPh/view?usp=
sharing

NIVEL DE LÍQUIDO CON DETECCIÓN DE

SUCIEDAD EN EL SENSOR DE FONDO

Este proyecto se centra en la implementación de un sistema de monitoreo y

detección utilizando un Arduino y sensores específicos. Entre ellos se encuentran el
sensor de agua y el sensor ultrasónico.
El sensor de agua opera mediante la variación de su resistencia eléctrica al detectar
la presencia de agua. Utiliza dos electrodos para detectar si hay conductividad
eléctrica entre ellos. Cuando el líquido hace contacto con los electrodos, se cierra el
circuito, permitiendo la circulación de corriente y, por ende, detectando la presencia
de agua.
El sensor ultrasónico se basa en la emisión de ondas ultrasónicas que rebotan en la
superficie del líquido dentro del tanque. Mide el tiempo que tarda en regresar el eco
y, a partir de esa información, calcula la distancia.
El sistema diseñado en este proyecto proporciona información en tiempo real sobre
el nivel del líquido en el tanque, indicando niveles bajos, medios, altos o muy altos, y
detectando la presencia de suciedad en el fondo del tanque. La información se
visualiza mediante luces LED y se comunica a través de un monitor serial para su
fácil interpretación y control. Para este circuito se ocupo:
● 1 protoboard
● 4 leds
● 4 resistencias de 270 Ω
● 1 sensor de agua
● 1 sensor ultrasónico
● Jumpers macho - macho
● Jumpers macho - hembra
● 1 placa arduino

Circuito de adquisición y señalización

const int sensorPin = A0;
const int ledLow = 2;
const int ledMedium = 3;
const int ledHigh = 4;
const int dirtyLed = 7; // Pin del LED para la detección de suciedad
const int trigPin = 5; // Pin del trigger del sensor ultrasónico
const int echoPin = 6; // Pin del echo del sensor ultrasónico

const int numReadings = 10;

int sensorReadings[numReadings];
int index = 0;
int total = 0;

void setup() {
pinMode(ledLow, OUTPUT);
pinMode(ledMedium, OUTPUT);
pinMode(ledHigh, OUTPUT);
pinMode(dirtyLed, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(sensorPin, INPUT);
 Serial.begin(9600);
}

void loop() {
total -= sensorReadings[index];
sensorReadings[index] = analogRead(sensorPin);
total += sensorReadings[index];
index = (index + 1) % numReadings;

int average = total / numReadings;

int lowThreshold = 300;

int mediumThreshold = 600;
int highThreshold = 900;

if (average < lowThreshold) {

digitalWrite(ledLow, HIGH);
digitalWrite(ledMedium, LOW);
digitalWrite(ledHigh, LOW);
Serial.println("Nivel bajo");
} else if (average < mediumThreshold) {
digitalWrite(ledLow, LOW);
digitalWrite(ledMedium, HIGH);
digitalWrite(ledHigh, LOW);
Serial.println("Nivel medio");
} else if (average < highThreshold) {
digitalWrite(ledLow, LOW);
digitalWrite(ledMedium, LOW);
digitalWrite(ledHigh, HIGH);
Serial.println("Nivel alto");
} else {
digitalWrite(ledLow, LOW);
digitalWrite(ledMedium, LOW);
digitalWrite(ledHigh, LOW);
Serial.println("Nivel muy alto");
}

// Detección de suciedad usando el sensor ultrasónico

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

long duration = pulseIn(echoPin, HIGH);

float distance = (duration * 0.0343) / 2; // Convertir el tiempo a distancia en centímetros
 if (distance < 10) { // Ajusta este valor según la distancia desde el sensor al fondo del
tanque
digitalWrite(dirtyLed, HIGH); // Encender el LED si la distancia es menor a 10 cm (o ajusta
según la distancia)
Serial.println("Fondo del tanque sucio");
} else {
digitalWrite(dirtyLed, LOW); // Apagar el LED si la distancia es mayor a 10 cm (o ajusta
según la distancia)
}

delay(100);
}

Creación del proyecto

Una vez confirmado el correcto funcionamiento del código en la simulación, se
procedió al desarrollo de un proyecto en el entorno de desarrollo integrado (IDE) de
Arduino para medir el nivel de liquido y detectar suciedad en el fondo.
El propósito principal de este proyecto fue utilizar el IDE de Arduino para escribir y
cargar un programa simple que permitiera gestionar el estado de un tanque de agua
con líquido mediante sensores.
El código controla el funcionamiento de estos elementos mediante un bucle principal
(loop()) donde se adquieren lecturas analógicas del sensor, se calcula un promedio
de lecturas pasadas, se determina el nivel según umbrales predefinidos y se realiza
la detección de suciedad mediante el sensor ultrasónico.
El sensor ultrasónico emite pulsos a través del pin de activación (trigPin) y mide el
tiempo de eco (echoPin) para calcular la distancia al objeto más cercano. Si la
distancia medida es menor a 10 cm, el LED de detección de suciedad se encenderá,
indicando que el fondo del tanque puede requerir limpieza.

Corrida del programa y prueba del circuito

Video de evidencia:
https://drive.google.com/file/d/1H61DnHa-aihw57Gw98HnZfA33CzGYrgT/view?usp=
sharing