Práctica 1. "Predicción en Tiempo (Euler Method)"

bongee_prediction.h

@@ -0,0 +1,187 @@
+//
+//  bongee_prediction.h
+//  
+//
+//  Creado por Rodrigo Garcia y Jesus Enrique Domìnguez el 25 de septiembre del 2020.
+//
+
+#ifndef bongee_prediction_h
+#define bongee_prediction_h
+
+
+/*
+* System headers required by the following declarations
+* (the implementation will import its specific dependencies):
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+* Application specific headers required by the following declarations
+* (the implementation will import its specific dependencies):
+*/
+
+/* Constants declarations. */
+
+/* Set EXTERN macro: */
+
+#ifndef bongee_prediction_IMPORT
+    #define EXTERN
+#else
+    #define EXTERN extern
+#endif
+
+/* Types declarations. */
+
+
+/* Global variables declarations. */
+#define COLUMNS 2
+
+
+/* Function prototypes. */
+
+
+/*
+ *
+ * La funcion vista_Menu proporciona al usuario un menu con la bienvenida y la forma de operar del sistema.
+ * Pedira los datos y las mandara a la siguiente funcion del proceso.
+ *
+ * @params
+ *      void
+
+ * @returns
+        entero que confirma si se repetira el proceso o no
+*/
+
+
+EXTERN int vista_Menu(void);
+
+
+/*
+ *
+ * La funcion vista_Resultados proporciona al usuario los resultados de su prediccion.
+ * Determinara si el proceso desea repetirse.
+ *
+ * @params
+ *      tiempo (double):
+            tiempo en el futuro que se predijo
+ *      muestras (double):
+            muestras que se tomaron en el proceso de inferencia
+ *      tiempo_choque (double):
+            tiempo en el cual se genero el primer choque.
+ *      chocado (int)
+            variable para identificar si hubo un choque.
+
+ * @returns
+        entero con la confirmacion de si se debe repetir o no
+*/
+
+
+EXTERN int vista_Resultados(double tiempo, double muestras, double tiempo_choque, int chocado);
+
+
+/*
+ *
+ * La funcion controlador_Proceso settea las variables y llama a los procesos dependiendo de 
+ * lo que se tenga que hacer ahora.
+ *
+ * @params
+ *     masa (double):
+            valor de la masa recibida del menu
+ *     k_constante (int):
+            valor de la constante k del resorte
+ *     tiempo (double):
+            cantidad de tiempo a predecir en segundos
+ *     muestras (double):
+            cantidad de muestras que se tomaran entre el tiempo dado
+
+ * @returns
+        Estado para repetirse o no
+*/
+
+
+EXTERN int controlador_Proceso(double masa, int k_constante, double tiempo, double muestras);
+
+
+/*
+ *
+ * La funcion modelo_Euler_Method predice la posicion de la persona en el bongee dependiendo de los valores dados
+ * y la regresa al controlador para ser analizada
+ *
+ * @params
+ *     delta_t (double):
+            variable del tiempo entre muestras dentro del periodo de tiempo dado por el usuario
+ *     index (int):
+            indice que calculara el metodo
+ *     masa (double):
+            valor de la masa de la persona proporcionado por el usuario
+ *     k_resorte (int):
+            constante k del resorte proporcionado por el usuario 
+
+ * @returns
+        posicion obtenida de la prediccion en el index determinado
+*/
+
+
+EXTERN double modelo_Euler_Method(double delta_t,int index, double masa, int k_resorte);
+
+/*
+ *
+ * La funcion modelo_Imprime_Archivo imprime una matriz recibida en una archivo CSV
+ *
+ * @params
+ *     Archivo (FILE *):
+            Puntero al archivo donde se imprimira la matriz
+ *     columnas (size_t):
+            Columnas de la matriz
+ *     buffer[][columnas] (double):
+            Matriz recibida para imprimir
+ *     filas (size_t):
+            Filas de la matriz
+
+ * @returns
+        void
+*/
+
+EXTERN void modelo_Imprime_Archivo(FILE * Archivo, size_t columnas, double buffer[] [columnas], size_t filas);
+
+
+/*
+ * La funcion modelo_Nuevo_Archivo instacia un apuntador a un archivo nuevo
+ *
+ * @param
+ *  nombre_archivo (char *):
+        Nombre del archivo
+ *  modo (char *):
+        Modo en que sera abierto el archivo {r, rb, a, ab, w, wb}
+
+ * @return 
+        apuntador al archivo abierto.
+*/
+
+EXTERN FILE * modelo_Nuevo_Archivo(char *nombre_archivo, char *modo);
+
+
+/*
+ *
+ * La funcion modelo_Grafica genera un plot del archivo CSV previamente creado.
+ *
+ * @params
+ *      nombre_archivo (* char):
+            Archivo el cual sera graficado por GNUplot
+
+ * @returns
+        void
+*/
+
+EXTERN void modelo_Grafica (char * nombre_archivo);
+
+
+
+#undef bongee_preditcion_IMPORT
+#undef EXTERN
+
+
+
+#endif /* bongee_prediction_h */

controlador_Proceso.c

@@ -0,0 +1,69 @@
+#include"bongee_prediction.h"
+
+#define COLUMNAS 2
+#define INDEX 0
+#define POSICION 1
+
+#define ARCHIVO "BONGEE.CSV"
+
+int controlador_Proceso(double masa, int k_constante,double tiempo, double muestras)
+{
+  int muestras_entero,index, chocado=0, muestra_choque, repetir;
+  double delta_t, posicion_en_index, inicio = 10;
+  long int gramos;
+
+  FILE * Archivo = NULL;
+
+
+  muestras_entero = (int) muestras;
+
+  double matriz_datos[muestras_entero][COLUMNAS];
+
+  Archivo = modelo_Nuevo_Archivo(ARCHIVO,"w");
+
+
+  delta_t = tiempo/muestras;
+  gramos = masa*1000;
+
+
+  system("clear");
+
+  //printf("%d kg\t%d N/m\t%.3lf delta t\n\n",masa, k_constante,delta_t);
+
+  for(index = 0;index < muestras_entero;index++)
+  {
+    posicion_en_index = modelo_Euler_Method(delta_t,index,masa,k_constante);
+
+    //printf("\n\nPosicion en muestra %d = %.3lf",index,posicion_en_index);
+
+    matriz_datos[index][INDEX] = index;
+    matriz_datos[index][POSICION] = posicion_en_index;
+
+    if(posicion_en_index < inicio && index != 0)
+    {
+      chocado = 1;
+      muestra_choque = index;
+    }
+  }
+
+  modelo_Imprime_Archivo(Archivo,COLUMNAS,matriz_datos,muestras);
+
+  fclose(Archivo);
+
+
+  //Llamada a la funcion que genera el plot
+  modelo_Grafica(ARCHIVO);
+
+  repetir = vista_Resultados(tiempo,muestras,muestra_choque*delta_t,chocado);
+
+  if(repetir == 1)
+  {
+    return 1;
+  }
+
+  else
+  {
+    return 0;
+  }
+
+}

modelo_Euler_Method.c

@@ -0,0 +1,22 @@
+#include<math.h>
+#include"bongee_prediction.h"
+
+#define G 9.81
+
+double modelo_Euler_Method(double delta_t,int index, double masa, int k_resorte)
+{
+  int count;
+  double pos1 = 10, pos2 = 10, temp, m = 60;
+  float bt = 10;
+
+  for(count = 0;count < index;count++)
+  {
+    temp = (-pos1)*(((-bt*delta_t)/m) + 1 +((k_resorte*(pow(delta_t,2)))/m)) - (2*(-bt*delta_t)/m)*pos2 + (pow(delta_t,2))*G;
+
+    pos1 = pos2;
+    pos2 = temp;
+  }
+
+  return pos2;
+
+}

modelo_Grafica.c

@@ -0,0 +1,20 @@
+#include"bongee_prediction.h"
+
+#define NUM_COMMANDS 2
+
+void modelo_Grafica (char * nombre_archivo)
+{
+  char * commandsForGnuplot[] = {"set title \"Prediccion de bongee\"","plot 'BONGEE.CSV' using 1:2 t 'Trayectoria' with lines"};
+  FILE * gnuplotPipe = NULL;
+
+  gnuplotPipe = popen("gnuplot -persistent","w");
+
+  //Para general el plot
+  for(int i = 0;i < NUM_COMMANDS;i++)
+  {
+    fprintf(gnuplotPipe,"%s \n",commandsForGnuplot[i]);
+  }
+
+  pclose(gnuplotPipe);
+
+}

modelo_Manejo_Archivos.c

@@ -0,0 +1,26 @@
+#include"bongee_prediction.h"
+
+FILE * modelo_Nuevo_Archivo(char * nombre_archivo, char * modo)
+{
+  FILE * file;
+
+  file = fopen(nombre_archivo,modo);
+
+  return file;
+}
+
+void modelo_Imprime_Archivo(FILE * Archivo, size_t columnas, double buffer[] [columnas], size_t filas)
+{
+  int count_rows,count_columns=0;
+
+  for(count_rows = 0;count_rows < filas;count_rows++)
+  {
+    fprintf(Archivo,"%.0lf ",buffer[count_rows][count_columns]);
+    count_columns++;
+    fprintf(Archivo,"%.3lf",buffer[count_rows][count_columns]);
+
+    count_columns=0;
+
+    fprintf(Archivo,"\n");
+  }
+}

prediction_method.c

@@ -0,0 +1,24 @@
+//
+//  prediction_method.c
+//  
+//
+//  Creado por Rodrigo Garcia el 25 de septiembre del 2020
+//
+
+#include "bongee_prediction.h"
+
+int main(void)
+{
+  int ciclo = 1;
+
+  while(ciclo == 1)
+  {
+    ciclo = vista_Menu();
+  }
+
+  printf("\n\nHasta luego!!\n\n");
+
+  return 0;
+}
+
+

vista_Menu.c

@@ -0,0 +1,41 @@
+#include"bongee_prediction.h"
+
+int vista_Menu(void)
+{
+  int k_resorte, repetir;
+  double tiempo_a_calcular,muestras,masa;
+
+  system("clear");
+
+  printf("\n\n\tMetodo de Euler para inferencia de salto en bongee\n\n");
+  printf("\n\nEl sistema le permitira determinar si es seguro saltar prediciendo la trayectoria de oscilacion del resorte\nmediante el metodo de Euler\n\nSi en algun momento la persona atada golpea el suelo, se avisara en pantalla.");
+  printf("\n\nPresiona ENTER para continuar...");
+  __fpurge(stdin);
+  getchar();
+
+  system("clear");
+
+  printf("\n\nIngrese la masa de la persona (kg):");
+  scanf("%lf",&masa);
+
+  printf("\n\nIngrese la constante 'k' del resorte (N/m):");
+  scanf("%d",&k_resorte);
+
+  printf("\n\nIngrese cuanto tiempo en el futuro desea predecir (seg):");
+  scanf("%lf",&tiempo_a_calcular);
+
+  printf("\n\nIngrese la cantidad de muestras que desea tomar en ese intervalo de tiempo:");
+  scanf("%lf",&muestras);
+
+  repetir = controlador_Proceso(masa,k_resorte,tiempo_a_calcular,muestras);
+
+  if(repetir == 1)
+  {
+    return 1;
+  }
+
+  else
+  {
+    return 0;
+  }
+}