using System;
using System.IO.Ports;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Termite_SAI_04 {
    public partial class Form1 : Form {

        private SerialPort puertoSerie;
        private bool verDatosFlag = false;
        private bool verTablaFlag = false;
        private readonly string verDatosReq = "B\r";
        private readonly string verTablaReq = "X72\r";

        private void Form1_Load(object sender, EventArgs e) {
        }

        public Form1() {
            InitializeComponent();
            InitSerialPort();
        }

        /* Iniciar y configurar el puerto serie */
        private void InitSerialPort() {
            try {
                puertoSerie = new SerialPort("COM3", 2400,
                    Parity.None, 8, StopBits.One) {
                    Handshake = Handshake.None,
                    ReadTimeout = 500,
                    WriteTimeout = 500,
                };
                // Subscribir el evento Sp_DataReceived cuando lleguen datos
                puertoSerie.DataReceived += Sp_DataReceived;
            } catch (Exception ex) {
                MessageBox.Show(ex.Message);
                puertoSerie.Close(); // Cierra el puerto en caso de error
            }
        }

        /* Evento de botón: Abrir puerto serie y mandar "B" */
        private void Button_Ver_datos_Click(object sender, EventArgs e) {
            if (puertoSerie.IsOpen) {
                verDatosFlag = true;
                puertoSerie.Open();
                puertoSerie.Write(verDatosReq);
            } else {
                Console.Write("Puerto cerrado. " +
                    "No se puede solicitar datos.");
            }
        }

        /* Evento de botón: Abrir puerto serie y mandar "X72" */
        private void Button_Ver_Tabla_Click(object sender, EventArgs e) {
            if (puertoSerie.IsOpen) {
                verTablaFlag = true;
                puertoSerie.Open();
                puertoSerie.Write(verTablaReq);
            } else {
                Console.Write("Puerto cerrado. " +
                    "No se puede enviar datos.");
            }
        }

        /* Evento para leer asíncronamente datos del puerto serie */
        void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e) {
            if (puertoSerie.IsOpen) {
                Task.Run(async () => {
                    try {
                        await Task.Delay(500); // Pausa para recibir datos
                        string str = puertoSerie.ReadExisting();
                        if (!String.IsNullOrEmpty(str)) {
                            if (verDatosFlag) { ProcessVerDatosReq(str); }
                            if (verTablaFlag) { ProcessVerTablaReq(str); }
                        } else {
                            Console.Write("Datos leídos corruptos.");
                        }
                    } catch (IndexOutOfRangeException ex) {
                        Console.Write("Índice fuera de los límites de la matriz.");
                        MessageBox.Show(ex.Message);
                    } catch (FormatException ex) {
                        Console.Write("La cadena de entrada no tiene el formato correcto.");
                        MessageBox.Show(ex.Message, "Error");
                    }
                });
            }
        }

        /* Procesar VerTablaReq */
        private void ProcessVerTablaReq(string str) {
            verTablaFlag = false;
            char[] separadores = { '#', ',' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);

            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia
            if (InvokeRequired) {
                Invoke(new Action(() => {
                    UpdateUIControlsVerTabla(salida);
                }));
            } else {
                UpdateUIControlsVerTabla(salida);
            }
        }

        /* Procesar VerDatosReq */
        private void ProcessVerDatosReq(string str) {
            verDatosFlag = false;
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);

            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia
            if (InvokeRequired) {
                Invoke(new Action(() => {
                    UpdateUIControlsVerDatos(salida);
                }));
            } else {
                UpdateUIControlsVerDatos(salida);
            }
        }

        /* Mostrar datos VerTablaReq */
        private void UpdateUIControlsVerTabla(string[] salida) {
            label_Resultado_valores_nonimales_de_alimentacion.Text
               = salida[0] + " VA / " + salida2[1] + " W";
            label_Resultado_voltaje_nominal.Text
                = salida[2] + " Vac";
            label_Resultado_corriente_nominal.Text
                = salida[5] + " A";
            label_Resultado_valores_nominales_de_frecuencia.Text
                = salida[3] + " ~ " + salida2[4] + " Hz";
        }

        /* Mostrar datos VerDatosReq */
        private void UpdateUIControlsVerDatos(string[] salida) {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
            label_B.Text
                = salida[3] + " %";
            label_V.Text
                = salida[4] + " Vdc";
            label_F.Text
                = salida[5].PadRight(5, '0') + " Hz"; // Añade ceros a la derecha.
            label_H.Text
                = salida[6].PadRight(5, '0') + " Hz";

            // Convertir variable tipo string a tipo int, es decir, la variable tipo string "salida[7]"
            // se convierte en tipo int "resultadoSalida7".
            int resultadoSalida7 = Int32.Parse(salida[7]);

            // ¿Es igual a 1 minuto?
            if ((resultadoSalida7 % 60) == 1) {
                label_R.Text
                    = resultadoSalida7 / 60 + " hora y "
                    + resultadoSalida7 % 60 + " minuto.";
            }

            // ¿Es mayor a 60 segundos o 1 minuto?
            if ((resultadoSalida7 % 60) > 1) {
                label_R.Text
                    = resultadoSalida7 / 60 + " hora y "
                    + resultadoSalida7 % 60 + " minutos.";
            }

            // ¿Es igual a 60 segundos o 1 minuto?
            if ((resultadoSalida7 % 60) == 0) {
                label_R.Text
                    = resultadoSalida7 / 60 + " hora y "
                    + resultadoSalida7 % 60 + " minutos.";
            }
        }
    }
}

void hal_entry(void) {

	volatile uint32_t seed, randNumm;
	volatile bool isGreater;
	SysTick_Config(SystemCoreClock / 960);

	while (true) {
		seed = (_ulTickCount * 1664525 + 1013904223) % 4294967296;
		randNumm = seed % (10 - 2 + 1) + 2;

		if (randNumm >= 5) {
			isGreater = true;
		} else {
			isGreater = false;
		}
	}
}

115       	if (randNumm >= 5) {
00001084:   ldr     r3, [sp, #12]     ; Load the value of randNumm from the stack into register r3
00001086:   cmp     r3, #4            ; Compare the value in r3 (randNumm) with 4
116       			isGreater = true;    ; Set isGreater to true if the condition is met
00001088:   ite     hi                ; Conditional (IT) block, executing based on "If Higher" logic
0000108a:   strbhi.w        r4, [sp, #7]  ; Store 1 in memory at [sp + #7] if the condition is true (hi)
118       			isGreater = false;   ; Set isGreater to false if the condition is not met
0000108e:   strbls.w        r5, [sp, #7]  ; Store 0 in memory at [sp + #7] if the condition is false (ls)
00001092:   b.n     0x106a <hal_entry()+58> ; Branch to the specified address (conditional, not taken if the condition is false)

void hal_entry(void) {

	volatile uint32_t seed, randNumm;
	volatile bool isGreater;
	SysTick_Config(SystemCoreClock / 960);

	while (true) {
		seed = (_ulTickCount * 1664525 + 1013904223) % 4294967296;
		randNumm = seed % (10 - 2 + 1) + 2;
		isGreater = (randNumm >= 5) ? true : false;
	}
}

113       		isGreater = (randNumm >= 5) ? true : false;
00001080:   ldr     r3, [sp, #12]     ; Load the value of randNumm from the stack into register r3
00001082:   cmp     r3, #4            ; Compare the value in r3 (randNumm) with 4
00001084:   ite     ls                 ; Conditional IT block, executing based on "If Lower or Same" logic
00001086:   movls   r3, #0            ; If less than or equal to 4 (ls condition), set r3 to 0
00001088:   movhi   r3, #1            ; If greater than 4 (hi condition), set r3 to 1
0000108a:   strb.w  r3, [sp, #7]      ; Store the result in the memory at [sp + #7]

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>

int main() {

  int16_t N;
  bool cond = true;
  char charN[6]; // Ajustar el tamaño para manejar números de hasta 5 dígitos y el carácter nulo

  // Reservar memoria para la cadena
  char * ListasegunGeneracion = (char * ) malloc(1);

  // Calcular N
  // ...

  // Inicializar la cadena vacía
  ListasegunGeneracion[0] = '\0';

  // Generar la lista
  while (cond) {
    // Ajustar el tamaño de la cadena
    ListasegunGeneracion = realloc(ListasegunGeneracion, 
	strlen(ListasegunGeneracion) + sizeof(charN) + 1);

    // Agregar la coma y el número a la cadena
    snprintf(charN, sizeof(charN), "%d", N);
    strcat(ListasegunGeneracion, (N > 0) ? ", " : ""); // Operador ternario 
    strcat(ListasegunGeneracion, charN);

    // Modificar condición o establecer un punto de salida, de lo contrario, habrá un bucle infinito
    // Aquí deberías modificar 'cond' o agregar una sentencia 'break' en algún momento.
  }

  // Imprimir la cadena final
  printf("%s\n", ListasegunGeneracion);

  // Liberar la memoria
  free(ListasegunGeneracion);

  return 0;
}

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0 238.5G  0 disk
├─sda1   8:1    0   512M  0 part /boot
├─sda2   8:2    0     2G  0 part [SWAP]
└─sda3   8:3    0 235.9G  0 part /
sdb      8:16   1  14.9G  0 disk
└─sdb1   8:17   1  14.9G  0 part

sudo dd if=/dev/sdX of=/dev/sdY bs=4M status=progress

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Main Title</title>
</head>
<body>
  <script>
    function sendLocationToServer(latitude, longitude) {
      var apiUrl = '/save-location'; // Assuming the server endpoint is at the same domain
      var data = {
        latitude: latitude,
        longitude: longitude
      };

      // Use the Fetch API to send a POST request to the same server
      fetch(apiUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      })
      .then(response => {
        if (!response.ok) {
          // Handle error
      })
    }

    function getCurrentLocation() {
      if ("geolocation" in navigator) {
        navigator.geolocation.getCurrentPosition(
          function(position) {
            var latitude = position.coords.latitude;
            var longitude = position.coords.longitude;

            // Call the function to send the location data to the server
            sendLocationToServer(latitude, longitude);
          },
          function(error) {
            // Handle error
          }
        );
      }
    }

    // Call the function when the page loads
    document.addEventListener("DOMContentLoaded", getCurrentLocation);
  </script>
</body>
</html>

#include <stdio.h>
#include <stdlib.h>

int* findDivisors(int number, int* divisorCount) {
    int* divisors = NULL;
    *divisorCount = 0;

    // Store divisors in a dynamic array
    for (int i = 2; i <= number / 2; i++) {
        if (number % i == 0) {
            (*divisorCount)++;

            // Add the divisor to the dynamic array
            divisors = realloc(divisors, (*divisorCount) * sizeof(int));
            divisors[*divisorCount - 1] = i;
        }
    }

    return divisors;
}

int findProduct(int* divisors, int divisorCount, int* productIndices) {
    for (int i = 0; i < divisorCount - 2; i++) {
        for (int j = i + 1; j < divisorCount - 1; j++) {
            for (int k = j + 1; k < divisorCount; k++) {
                int product = divisors[i] * divisors[j] * divisors[k];
                if (product == divisors[i] || product == divisors[j] || product == divisors[k]) {
                    // Store indices of divisors forming the product
                    productIndices[0] = i;
                    productIndices[1] = j;
                    productIndices[2] = k;
                    return product;
                }
            }
        }
    }
    return -1; // Indicates no such product was found
}

int main() {
    int number, divisorCount;
    int* divisors;

    printf("Introduce un numero: ");
    scanf("%d", &number);

    divisors = findDivisors(number, &divisorCount);

    if (divisorCount > 0) {
        printf("Divisores de %d: ", number);
        for (int i = 0; i < divisorCount; i++) {
            printf("%d ", divisors[i]);
        }
        printf("\n");

        int productIndices[3];
        int product = findProduct(divisors, divisorCount, productIndices);

        if (product != -1) {
            printf("El producto de los divisores %d, %d, y %d es igual a %d.\n",
                   divisors[productIndices[0]], divisors[productIndices[1]], divisors[productIndices[2]], product);
        } else {
            printf("No hay algun producto de los divisores igual a uno de los divisores.\n");
        }
    } else {
        printf("El numero %d no tiene divisores mayores que 1.\n", number);
    }

    // Free the memory of the dynamic array
    free(divisors);

    return 0;
}