pULL Request

.vscode/settings.json

@@ -0,0 +1,59 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
+}

UA1/examen/dev_22/ejercicio2/EstadoPlantas.java

@@ -0,0 +1,21 @@
+public class EstadoPlantas extends Thread{
+    private int detector;
+    public EstadoPlantas() {
+        detector = (int) (Math.random() * 5);
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep((long) (Math.random() * 3000 + 1000)); // Esperar un tiempo aleatorio entre 1 y 3 segundos
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        double medicion = Math.random() * 100; // Generar una medición aleatoria entre 0 y 100
+        long tiempo = System.currentTimeMillis(); // Obtener el tiempo actual en milisegundos
+        System.out.printf("Sensor Estado de las plantas nº %d: Medición %.2f, Tiempo: %d%n", detector, medicion, tiempo);
+    }
+
+
+
+}

UA1/examen/dev_22/ejercicio2/Humedad.java

@@ -0,0 +1,20 @@
+public class Humedad extends Thread {
+    private double humedad;
+
+    public Humedad() {
+        this.humedad = Math.random() * 100; // Valor aleatorio recogido por el sensor
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep((long) (Math.random() * 2000) + 1000); // Duerme entre 1 y 3 segundos
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("Sensor de humedad: " + humedad + " % - Lectura realizada en " + System.currentTimeMillis());
+    }
+
+
+}

UA1/examen/dev_22/ejercicio2/Temperatura.java

@@ -0,0 +1,23 @@
+public class Temperatura extends Thread {
+    private String sensor;
+
+    public Temperatura(String sensor) {
+        this.sensor = sensor;
+
+    }
+
+    @Override
+    public void run() {
+        while (true) {
+            double temperatura = (Math.random() * 50) + 1;
+            try {
+                Thread.sleep((long) (Math.random() * 3000 + 1000)); // Esperar un tiempo aleatorio entre 1 y 3 segundos
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            System.out.printf("%s de temperatura: %.2f grados Celsius, leída en %d ms%n", sensor, temperatura, System.currentTimeMillis());
+        }
+    }
+
+}

UA1/examen/dev_22/ejercicio2/ua1ex1p2.java

@@ -0,0 +1,58 @@
+/*
+PARTE PRÁCTICA 2/2
+
+Se ha decidido implantar un huerto en un centro público, y se han instalado varios sensores ESP32 para monitorizar la temperatura, la humedad del suelo y el estado de las plantas en distintas áreas del huerto. Se requiere un sistema en Java que simule la lectura de estos sensores de manera concurrente para obtener los datos en tiempo real.
+
+Tu tarea es diseñar una solución que simule el monitoreo de estos sensores usando hilos en Java. El sistema debe realizar lo siguiente:
+
+Crear tres hilos para simular los sensores: uno para la temperatura, otro para la humedad del suelo y otro para el estado de las plantas.
+
+Cada sensor (hilo) debe:
+
+Generar un valor aleatorio para la medición correspondiente.
+Dormir durante un tiempo aleatorio entre 1 y 3 segundos para simular la espera entre lecturas.
+Imprimir el valor generado con un mensaje que indique qué sensor hizo la lectura y en qué momento (puedes usar System.currentTimeMillis() para esto).
+Los datos de los sensores deben ser leídos de manera concurrente.
+
+El programa debe ejecutarse durante 10 ciclos de medición (10 iteraciones por sensor).
+
+Mejora opcional: Implementa una forma de detener todos los sensores después de que hayan hecho las 10 lecturas.
+
+Funcionalidades Requeridas (FR):
+FR1 (2 puntos): Crear un hilo para cada sensor (temperatura, humedad y estado de las plantas).
+FR2 (2 puntos): Generar valores aleatorios para cada medición de sensor.
+FR3 (2 puntos): Simular la espera de tiempo entre lecturas con Thread.sleep().
+FR4 (2 puntos): Mostrar las lecturas de cada sensor con su correspondiente marca de tiempo.
+FR5 (2 puntos): Ejecutar correctamente los 10 ciclos de medición por cada sensor.
+
+*/
+
+
+
+public class ua1ex1p2 {
+    public static void main(String[] args) {
+
+        for (int i = 0; i < 10; i++) { // Bucle para que realice 10 ciclos
+
+            Temperatura sensor1 = new Temperatura("Sensor 1");
+            sensor1.start();
+
+
+            Humedad humedadThread = new Humedad();
+            humedadThread.start();
+
+            EstadoPlantas detector1 = new EstadoPlantas();
+            detector1.start();
+
+
+            try {
+                Thread.sleep(5000); // Obligo a que cuando finalice un ciclo, espere 5 segundos hasta inciar otro
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        System.out.println("Todos los sensores han finalizado.");
+
+    }
+}

UA1/examen/dev_22/ua1ex1_teoria.txt

@@ -0,0 +1,50 @@
+PARTE TEÓRICA
+
+a) Definición de proceso. Ilustra tu solución con un ejemplo. 1 punto.  
+
+    Un proceso es una unidad de ejecución que se ejecuta en un sistema operativo. Y este se ejecuta de una manera determinada, ejemplo de ello sería: 
+    - Abrir un navegador y buscar algo en internet.
+
+
+b) Utilizando tus propias palabras, indica la relación entre hilos y procesos. Ilustra tu solución con un ejemplo. 3 puntos.
+
+    Los procesos son como un paquete de mayor tamaño que en su interior se incluyen los hilos. Por ejemplo: Imaginemos una caja de una mudanza, pues el contenido de su interior 
+    serían los  hilos y la caja propiamente dicha, serían los procesos.
+
+
+c) Utilizando tus propias palabras, indica las características de la programación concurrente y sus ámbitos de aplicación. 3 puntos.
+
+    Características:
+        - Interacción: Los procesos se comunican entre si, e intercambian datos y señales.
+        - Sincronización: Todos los procesos tienen que actuar de forma coordinada, sin solaparse entre ellos.
+        - Multitarea: Esto nos permite ejecutar varias tareas al mismo tiempo, sin frenar la ejecución de ninguna de ellas. 
+
+    Ámbitos de aplicación:
+        - Desarrollo de SO: Permite gestionar varios procesos y recursos eficientemente.
+        - Aplicaciones Web y servidores: Si tenemos una web como por ejemplo un E-Commerce, requerimos de que nuestros clientes se registren, pues para poder llevar a cabo esta tarea 
+          sin complicaciones, de que al recibir distintas peticiones al mismo tiempo, nuestro sistema colapse... pues para esto sirve la programación concurrente.
+        - Juegos y simulaciones: Al igual que el anterior, permite la la ejecución de múltiples elementos en paralelo.
+
+
+
+
+d) Utilizando tus propias palabras, indica las diferencias entre programación paralela y programación distribuida, sus ventajas e inconvenientes. 3 puntos.
+
+    La programación paralela está  enfocada en la ejecución de tareas en el mismo equipo, mientras que la programación  distribuida se enfoca en la ejecución de tareas en diferentes equipos. 
+
+    Ventajas:
+        - Ejecución simultanea y menos tiempo de espera en la ejecución (programación paralela).
+        - Posibilidad de compartir datos y recursos, además de una mayor flexibilidad y disponibilidad (programación distribuida).
+
+    Desventajas:
+        - Compiladores y sistemas complejos, mayor consumo de energía y complejidad en los accesos a datos (programación paralela).
+        - Problemas de comunicación entre equipos, y problemas de seguridad (programación distribuida).
+
+
+
+
+Notas:
+
+El nombre del fichero .txt a entregar debe ser:	examen\dev_X\ua1ex1_teoria.txt , es decir, el fichero ua1ex1_teoria.txt debe estar ubicado en tu carpeta examen\dev_X\
+
+No entregues tu solución, hasta que no se indique por parte del profesorado.

UA1/examen/dev_22/ua1ex1p1c.c

@@ -0,0 +1,66 @@
+/*
+PARTE PRÁCTICA 1/2
+
+FR1: Haz un programa en C que genere una estructura de procesos con un PADRE y 3 HIJOS, del mismo padre se entiende - 2 puntos
+FR2: Visualiza por cada hijo su identificador (si es el hijo 1, 2 ó 3), su PID y el del padre, utilizando para ello una función definida por ti a la que llamen los procesos hijos - 2 puntos
+FR3: Justo antes de finalizar el programa PADRE, se debe imprimir por pantalla el PID del padre de todos una única vez. Debe hacerlo el programa PADRE - 2 puntos
+FR4: Implementa el control de errores - 2 puntos
+FR5: Documenta y estructura el código - 2 puntos
+
+
+Para evitar complicaciones con máquinas virtuales, si lo prefieres puedes utilizar el compilador online: https://www.onlinegdb.com/online_c_compiler
+
+Notas:
+
+Los comentarios (descriptivos y concisos) en el código ... siempre son bien.
+Los nombres de las variables autodescriptivos ... siempre son bien.
+Las impresión por pantalla, correctamente indentada y verticalmente espaciada ... siempre es bien.
+Los warnings del presente ... son los errores del futuro.
+El nombre del fichero .c a entregar debe ser: examen\dev_X\ua1ex1p1.c , es decir, el fichero ua1ex1.cdebe estar ubicado en tu carpeta dev_X\
+
+No entregues tu solución, hasta que no se indique por parte del profesorado.
+*/
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+
+
+void hijos (int id) {
+        pid_t Padre_pid = getppid();
+        pid_t pid = getpid();
+        hijos(id);
+        printf("Hijo %d = \n Pid padre %d: Pid hijo %d: \n ", id, Padre_pid, pid);
+    }
+
+int main()
+{
+    int pid1, pid2, pid3;
+
+    pid1 = fork();
+
+    if (pid1 == 0)
+    {
+        hijos(1);
+        exit(0);
+    }
+
+    pid2 = fork();
+
+    if (pid2 == 0)
+    {
+        hijos(2);
+        exit(0);
+    }
+
+    pid3 = fork();
+
+    if (pid3 == 0)
+    {
+        hijos(3);
+        exit(0);
+    }
+
+    return 0;
+}
+

UA1/tareas/dev_22/UA1tarea1/ua1tarea1.c

@@ -0,0 +1,34 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+int main()
+{
+  pid_t pid, Padre_pid;
+  int nota;    //Nota es el numero que pediremos despues al usuario
+    printf ("Introduce un numero\n");
+      scanf ("%d", &nota);  //Pedimos el numero con el que trabajaremos mas tarde
+
+  pid = fork();
+  //Designamos ambos procesos y el fork creara ambos y hara de pid el proceso padre
+
+  if (pid == -1)        //Ha ocurrido un error creando el proceso padre
+    {
+      printf ("No se ha podido crear el proceso PADRE");
+      exit (-1);
+    }
+
+      if (pid == 0)           //Nos encontramos en el Proceso padre 
+    {
+      nota-=5;//El proceso padre debe restar 5 y mostrar el resultado
+      printf("Soy el proceso PADRE:\n\t Mi valor habiendo restando 5 es de %d.\n",
+     nota);
+    }
+  else  //Nos encontramos en el proceso hijo
+      {
+      wait (NULL); //espera de la finalizacion del proceso padre
+      nota+=4;            //El proceso hijo suma 4
+      printf("Soy el proceso HIJO \n\t Mi valor habiendo sumado 4 es de %d.\n",
+     nota);
+      }
+  return(0);
+}

UA1/tareas/dev_22/UA1tarea1/ua1tarea1.test.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+int main() {
+    return 0;
+}
+
+void test_handle_input_zero() {
+    int pipefd[2];
+    pipe(pipefd);
+    pid_t pid = fork();
+
+    if (pid == 0) {
+        // Child process
+        close(pipefd[0]); // Close unused read end
+        dup2(pipefd[1], STDOUT_FILENO); // Redirect stdout to pipe
+        close(pipefd[1]); // Close write end after redirect
+
+        // Simulate input value 0
+        FILE *input = fopen("input.txt", "w");
+        fprintf(input, "0\n");
+        fclose(input);
+        freopen("input.txt", "r", stdin);
+
+        execl("./ua1tarea1", "./ua1tarea1", NULL);
+        exit(0);
+    } else {
+        // Parent process
+        close(pipefd[1]); // Close unused write end
+        wait(NULL); // Wait for child process to finish
+
+        char buffer[128];
+        read(pipefd[0], buffer, sizeof(buffer));
+        close(pipefd[0]);
+
+        // Check output for both parent and child processes
+        if (strstr(buffer, "Soy el proceso PADRE:\n\t Mi valor habiendo restando 5 es de -5.\n") &&
+            strstr(buffer, "Soy el proceso HIJO \n\t Mi valor habiendo sumado 4 es de -1.\n")) {
+            printf("Test passed: Correctly handled input value of 0\n");
+        } else {
+            printf("Test failed: Incorrect handling of input value of 0\n");
+        }
+    }
+}