elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado:


  Mostrar Mensajes
Páginas: 1 2 [3] 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ... 229
21  Programación / Programación C/C++ / Re: Adaptar estas variables a C++ en: 29 Julio 2020, 14:43
Muchísimas gracias. Funciona a la primera.

No se el motivo, en C# no me deja ponerlo valores constantes con "const", me aconseja ponerle "readonly".

Diferencia const entre readonly.

Ejemplo tuyo modificado con const en C++ 2019.
Código
  1. #include <iostream>
  2. #include <string>
  3. #include <windows.h> // Para mostrar texto en el título de la ventana.
  4. #include <stdio.h>   // Cambio color de fondo y letras.
  5.  
  6. using namespace std;
  7.  
  8. int main()
  9. {
  10.    // Variables.
  11.    string guardarNombre = ""; // Guardar nombre escrito.
  12.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  13.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  14.    static int index = 0; // Índice.
  15.  
  16.    // Caracteres de este array.
  17.    static char const ALFANUMERICO[] =
  18.    {
  19.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  20.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  21.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  22.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  23.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  24.    };
  25.  
  26.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  27.    static int const INDICE_ARRAY[] =
  28.    {
  29.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  30.    };
  31.  
  32.    // Palabras del array para imprimir en pantalla.
  33.    static string const TEXTO[] = { "ATRÁS", "GUARDAR" };
  34.  
  35.    // Mostrar caracteres correctamente en pantalla y título de la ventana.
  36.    SetConsoleOutputCP(65001);
  37.    wchar_t titulo[128];
  38.    MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
  39.    SetConsoleTitle(titulo);
  40.  
  41.    // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
  42.    SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
  43.    SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
  44.  
  45.    // Cambio color de 8 (gris), color letras 0 (negro).
  46.    system("color 80");
  47.  
  48.    // mostrar contenido de las variables.
  49.    cout << guardarNombre << endl;
  50.    cout << coordenadaX << endl;
  51.    cout << index << endl;
  52.  
  53.    for (int i = 0; i < sizeof(ALFANUMERICO) / sizeof(ALFANUMERICO[0]); i++)
  54.    {
  55.        cout << ALFANUMERICO[i] << endl;
  56.    }
  57.  
  58.    for (int i = 0; i < sizeof(INDICE_ARRAY) / sizeof(INDICE_ARRAY[0]); i++)
  59.    {
  60.        cout << INDICE_ARRAY[i] << endl;
  61.    }
  62.  
  63.    for (int i = 0; i < sizeof(TEXTO) / sizeof(TEXTO[0]); i++)
  64.    {
  65.        cout << TEXTO[i] << endl;
  66.    }
  67.  
  68.    // Esperando pulsar Enter para salir.
  69.    cin.get();
  70.    //getchar();
  71.    return 0;
  72. }

Edito:

Gracias por la ayuda. Porque en realidad quiero pasar este código completo de C# a C++ nativo. Esto ya es demasiado tiempo, pero lo haré.
Código
  1. using System;
  2. using System.IO;
  3.  
  4. namespace LCD_nombre_archivo_consola_11
  5. {
  6.    class Program
  7.    {
  8.        // Variables.
  9.        static string guardarNombre = ""; // Guardar nombre escrito.
  10.        static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  11.        static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  12.        static int index = 0; // Índice.
  13.  
  14.        // Caracteres de este array.
  15.        static readonly char[] roALFANUMERICO = new char[]
  16.        {
  17.         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  18.         'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  19.         'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  20.         'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  21.         '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
  22.        };
  23.  
  24.        // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  25.        static readonly int[] roINDICE_ARRAY = new int[]
  26.        {
  27.         80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  28.        };
  29.  
  30.        // Palabras del array para imprimir en pantalla.
  31.        static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
  32.  
  33.        static void Main(string[] args)
  34.        {
  35.            // Título de la pantalla.
  36.            Console.Title = "Cambiar nombre";
  37.  
  38.            Inicio();
  39.        }
  40.  
  41.        static void MainMenu()
  42.        {
  43.            Console.Clear(); // Limpiar pantalla.
  44.  
  45.            Console.SetCursorPosition(0, 0);
  46.            Console.Write("Nombre del relé 1:  ");
  47.            Console.SetCursorPosition(0, 1);
  48.  
  49.            // Recorre el índice del array, del 0 hasta donde llegue.
  50.            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  51.            {
  52.                // Imprime los caracteres del array.
  53.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  54.            }
  55.  
  56.            Console.SetCursorPosition(3, 3);
  57.            Console.Write(roTEXTO[0]); // ATRÁS.
  58.            Console.SetCursorPosition(12, 3);
  59.            Console.Write(roTEXTO[1]); // GUARDAR.
  60.        }
  61.  
  62.        #region Inico.
  63.        static void Inicio()
  64.        {
  65.            Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
  66.            Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
  67.            Console.ForegroundColor = ConsoleColor.Black; // Letras negras.
  68.  
  69.            // ¿El archivo Existe?
  70.            if (File.Exists("Archivo.txt"))
  71.            {
  72.                // Sí. Lee el archivo de texto.
  73.                string nombre = File.ReadAllText("Archivo.txt");
  74.                int a, b; // Almacena ídice array.
  75.                for (a = 0; a < nombre.Length; a++)
  76.                {
  77.                    for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
  78.                    {
  79.                        ;
  80.                    }
  81.                    roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
  82.                }
  83.            }
  84.  
  85.            // No. El Archivo.txt no existe. El código continúa por aquí.
  86.  
  87.            MainMenu(); // Dibuja el menú.
  88.  
  89.            while (true)
  90.            {
  91.                Console.CursorVisible = true; // Cursor invisible.
  92.                index = 0;
  93.  
  94.                // Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
  95.                if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
  96.                {
  97.                    MainMenu(); // Dibuja el menú.
  98.                }
  99.  
  100.                // Posiciona cursor.
  101.                Console.SetCursorPosition(coordenadaX, 1);
  102.  
  103.                // Almacena en la variable tecla, la tecla pulsada.
  104.                tecla = Console.ReadKey(true).Key;
  105.  
  106.                // Si coincide una tecla pulsada.
  107.                switch (tecla)
  108.                {
  109.                    case ConsoleKey.RightArrow: // Flecha derecha detectada.
  110.                        // ¿CoordenadaX menor que 15?
  111.                        if (coordenadaX < 15)
  112.                        {
  113.                            coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
  114.                        }
  115.                        // No. Sale de aquí.
  116.                        break;
  117.  
  118.                    case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
  119.                        // ¿coordenadaX es mayor que 0?
  120.                        if (coordenadaX > 0)
  121.                        {
  122.                            coordenadaX--; // Sí. Decremente o quita -1.
  123.                        }
  124.                        // No. Sale de aquí.
  125.                        break;
  126.  
  127.                    case ConsoleKey.UpArrow: // Flecha arriba.
  128.                        roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
  129.                        // ¿El índice del array es mayor o igual que el arra Alfanumérico?
  130.                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  131.                        {
  132.                            roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
  133.                        }
  134.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  135.                        break;
  136.  
  137.                    case ConsoleKey.DownArrow: // Flecha abajo detectado.
  138.                        roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
  139.                        // ¿La coordenadaX del indice del array es menor que 0?
  140.                        if (roINDICE_ARRAY[coordenadaX] < 0)
  141.                        {
  142.                            // Sí. Imprimir el valor alfanumérico.
  143.                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  144.                        }
  145.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  146.                        break;
  147.  
  148.                    case ConsoleKey.Enter: // Detecta la tecla Enter.
  149.                        Console.SetCursorPosition(1, 3); // Posición del cursor.
  150.                        Console.CursorVisible = false; // Se oculta el cursor.
  151.                        Console.Write(">"); // Imprime en pantalla >.
  152.  
  153.                        // ¿La tecla almacenada es distinto a la tecla Enter?
  154.                        while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  155.                        {
  156.                            // Sí.
  157.                            switch (tecla)
  158.                            {
  159.                                case ConsoleKey.RightArrow:
  160.                                    index = 1;
  161.                                    Console.SetCursorPosition(1, 3);
  162.                                    Console.Write(" ");
  163.                                    Console.SetCursorPosition(10, 3);
  164.                                    Console.Write(">");
  165.                                    break;
  166.                                case ConsoleKey.LeftArrow:
  167.                                    Console.SetCursorPosition(10, 3);
  168.                                    Console.Write(" ");
  169.                                    Console.SetCursorPosition(1, 3);
  170.                                    Console.Write(">");
  171.                                    index = 0;
  172.                                    break;
  173.  
  174.                                case ConsoleKey.UpArrow:
  175.                                    Inicio();
  176.                                    break;
  177.  
  178.                                case ConsoleKey.DownArrow:
  179.                                    Inicio();
  180.                                    Console.SetCursorPosition(coordenadaX, 1);
  181.                                    break;
  182.                            }
  183.                        }
  184.  
  185.                        if (index == 0)
  186.                        {
  187.                            Atras();
  188.                        }
  189.                        if (index == 1)
  190.                        {
  191.                            Guardar();
  192.                        }
  193.                        break;
  194.                }
  195.            }
  196.        }
  197.        #endregion
  198.  
  199.        static void Atras()
  200.        {
  201.            Console.Clear();
  202.            Console.SetCursorPosition(0, 1);
  203.            Console.Write("HAS PULSADO ATRÁS   ");
  204.            Console.ReadKey(); // Pulse cualquier tecla para salir.
  205.        }
  206.  
  207.        static void Guardar()
  208.        {
  209.            guardarNombre = "";
  210.            Console.Clear();
  211.  
  212.            // Lee todo el contennido del array y lo guarda en guardarNombre.
  213.            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  214.            {
  215.                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  216.            }
  217.            Console.SetCursorPosition(0, 2);
  218.            Console.Write(guardarNombre); // Imprime el contenido.
  219.  
  220.            // Crear Archivo.txt y el contenido de guardarNombre.
  221.            File.WriteAllText("Archivo.txt", guardarNombre);
  222.  
  223.            Console.SetCursorPosition(0, 1);
  224.            Console.Write("HAS GUARDADO       ");
  225.  
  226.            // Pulsa otra vez tecla.
  227.            Console.ReadKey();
  228.        }
  229.    }
  230. }

Gracias por todo. Si te animas, mejor. Entonces, lo tienes bien puestos.

;)



EI: Juntando mensajes, otra vez.

Me funciona hasta con Arduino.

Código
  1. #include <LiquidCrystal.h>
  2.  
  3. // Inicializa la librería con sus pines indicados.
  4. LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
  5.  
  6. // Pin 10 para saber que es luz de fondo del LCD.
  7. //int LuzFondo = 10;
  8.  
  9.  
  10. // Variables.
  11. String guardarNombre = ""; // Guardar nombre escrito.
  12. int coordenadaX = 0; // Coordenada X del setCursorPisition.
  13. int index = 0; // Índice.
  14. // Caracteres de este array.
  15. char const PROGMEM ALFANUMERICO[] =
  16. {
  17.  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  18.  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  19.  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  20.  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  21.  '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  22. };
  23.  
  24. // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  25. int const PROGMEM INDICE_ARRAY[] =
  26. {
  27.  80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  28. };
  29.  
  30. // Palabras del array para imprimir en pantalla.
  31. String const TEXTO[] = { "ATRÁS", "GUARDAR" };
  32.  
  33. void setup()
  34. {
  35.  // La pantalla es de 16 caracteres y 2 filas.
  36.  lcd.begin(16, 2);
  37.  lcd.print(F("  Probando..."));
  38.  
  39.  // Baudios del puerto serie.
  40.  Serial.begin(115200);
  41.  
  42.  // Indicar luz de fondo como salida.
  43.  // pinMode(LuzFondo, OUTPUT);
  44.  
  45.  Serial.println(guardarNombre);
  46.  Serial.println(coordenadaX);
  47.  Serial.println(index);
  48.  
  49.  for (byte i = 0; i < 80; i++)
  50.  {
  51.    Serial.println(ALFANUMERICO[i]);
  52.  }
  53.  
  54.  for (byte j = 0; j < 16; j++)
  55.  {
  56.    Serial.println(INDICE_ARRAY[j]);
  57.  }
  58.  
  59.  for (byte k = 0; k < 2; k++)
  60.  {
  61.    Serial.println(TEXTO[k]);
  62.  }
  63. }
  64.  
  65. void loop()
  66. {
  67.  //return 0;
  68. }
22  Programación / Programación C/C++ / Adaptar estas variables a C++ en: 29 Julio 2020, 05:18
Hola:

Quiero pasar estas variables de C# a C++ con Visual studio 2019.

A pesar de mirarlo aquí, me da problemas.
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_cadenas_de_texto

Código
  1.    // Variables.
  2.    static string guardarNombre = ""; // Guardar nombre escrito.
  3.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  4.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  5.    static int index = 0; // Índice.
  6.  
  7.    // Caracteres de este array.
  8.    static char[] roALFANUMERICO = new char[]
  9.    {
  10.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  11.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  12.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  13.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  14.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  15.    };
  16.  
  17.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  18.    static int[] roINDICE_ARRAY = new int[]
  19.    {
  20.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  21.    };
  22.  
  23.    // Palabras del array para imprimir en pantalla.
  24.    static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };

Vamos, que me lo acepte C++ nativo o win32.

Saludos.
23  Foros Generales / Dudas Generales / Re: ¿Es posible descargar de golpe estos PDF de una Web? en: 29 Julio 2020, 00:24




¿Dónde pongo el enlace https://www.aguastenerife.org/9_OCAS/pdf/OCAS_InfGeneral_2018_corto.pdf?

¿Qué hago ahora?

Saludos.
24  Foros Generales / Dudas Generales / Re: ¿Es posible descargar de golpe estos PDF de una Web? en: 28 Julio 2020, 22:59
Hola:

Busco todos los PDF de esos enlaces de esta web https://www.aguastenerife.org/9_OCAS/pdf/OCAS_InfGeneral_2018_corto.pdf

Son muchísimos y de momento los descargo uno a uno al disco duro, ya que el de la Web dice que no los tiene todos para descargarlo de golpe.

¿Puedes poner el código fuente del programa que hicieron?

¿Qué consola están habalndo exactamente, de Windows, del navegador web, de Visual Studio?

Tengo instalado Python de Visual studio Community 2019 por si acaso.

Saludos.
25  Informática / Electrónica / Re: Morse en: 28 Julio 2020, 22:55
Morse es analógico.

Se puede hace el truco del binario el estilo como el hombre hace el trabajo. La señal es analógica.
26  Foros Generales / Dudas Generales / Re: ¿Es posible descargar de golpe estos PDF de una Web? en: 28 Julio 2020, 19:52
Sigo sin entender como sacaron todos esos enlaces.

¿No hay otro languaje con cual se pueda hacer?

Ya tengo instalado Python, 2 y 3.

Si se puede hacer con otro lenguaje, estoy dispuesto también.
27  Foros Generales / Dudas Generales / Re: ¿Es posible descargar de golpe estos PDF de una Web? en: 28 Julio 2020, 14:22
Buenas:

No se como lo hiciste, ni se como sacaste ese código de arriba de Java Script, a mi no me sale y si uso Firefox.
Me iamgino qu ehabrás tocado algo así en Firefox.


No se que es un DOM.
No se que consola te refieres, pensé por un monento que puede ser cmd o PowerShell, me imagino que será del navegador Firefox- Desarrollo Web --> Consola del Navegador.
Puse     
Código:
document.querySelectorAll('a[href$=".pdf"]').forEach(function(item) { console.log(item.href); });
Pero nada de nada.

Sigo necesitando ayuda, sabes mucho y no se nada. Por eso necsito pasos, nunca he hecho esto.

Saludos.
28  Informática / Electrónica / Calcular ancho de banda en: 28 Julio 2020, 14:05
Hola:

Sabemos que el ancho de banda de un sistema de transmisión es la diferencia entre la frecuencia más baja y la frecuencia más alta que puede utilizar ese sistema de transmisión.

Si un sistema de transmisión posee un ancho de banda de 10Mhz significa que la diferencia entre la frecuencia más baja y la más alta de este sistema es de 10Mhz.

Pregunta: Si tengo un sistema de transmisión donde la frecuencia más baja es de 10 Khz y la frecuencia más alta es de 100Mhz, ¿cuál será el ancho de banda de este sistema de transmisión?

100 MHz = 100000 KHz.

Nota: Ambas frecuencias deben estar en el mismo orden de magnitud para realizar la diferencia.

Saludos.
 
29  Foros Generales / Dudas Generales / ¿Es posible descargar de golpe estos PDF de una Web? en: 28 Julio 2020, 10:27
Buenas:

En este enlace.

Se puede ver que cada uno de ellos que pinches, lees un PDF, los quería descargar uno a uno, pero me da pereza, a parte de ponerles sus nombres para orientarme.

Quiero saber si hay alguna forma de descargar toda esa documentación en PDF de alguna forma o es imposible. Quiero evitarlo hacerlo de uno en uno.

Saludos.
30  Programación / Programación General / Cálculo a realizar en: 28 Julio 2020, 09:58
Hola:

Quiero hacer un programa en Arduino en el cual te pide cuatro valores. Esos valores son números a introducir por el monitor Serie de Arduino IDE.

Hice un ejemplo en C# modo consola para que se entienda lo que quiero decir.

 Estos son los datos que te piden, solo cuatro y nada más.


Desde que pulse Enter con todo lo que indica arriba, en C# lo muestra como indica abajo. Lo que indica en laimagen de abajo, es el resultado que tiene que dar el monitor Serie.

Esto ya parece un reto.


Códido C#:
Código:
using System;
using System.Speech.Recognition; // No olvidar. Micro.
using System.Speech.Synthesis; // No olvidar. Altavoz.

// No olvidar añadir en "Referencias" Speech en el "Explorador de soluciones".

namespace Calculo_cilindro_voz_consola_02_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Mostrar título de la ventana.
            Console.Title = "Cálculo litros de un depósito - By Meta. Electrónica PIC";

            // Tamaño de la ventna. 55 X y 16 Y.
            Console.SetWindowSize(55, 16);

            #region Variables.
            // Variables.
            const double Pi = 3.14;
            float PI = Convert.ToSingle(Pi);
            float radio, altura, volumen, litros, nivelAgua, resultadoPorcentaje,
                resultadoLitros, volumenLitros, mitadBarra, cantidadTubosLitros,
                totalLitros;
            float cantidadTubos;
            #endregion

            do
            {
                try
                {
                    // Inicializar una nueva instancia de SpeechSynthesizer.
                    using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
                    {
                        #region Introducción de datos en la pantalla.
                        // Configure la salida de audio.
                        altavoz.SetOutputToDefaultAudioDevice();

                        // Velocidad de la voz.
                        altavoz.Rate = -2; // Valores entre -10 a 10.

                        // Volumen de la voz.
                        altavoz.Volume = 100; // Valores entre 0 y 100.

                        // Limpiar pantalla.
                        Console.Clear();

                        // Cursor visible.
                        Console.CursorVisible = true;
                        // Introducción de datos.
                        Console.Write("Introduce el radio en m.: ");
                        altavoz.Speak("Introduce el radio en metros.");
                        radio = float.Parse(Console.ReadLine());
                        Console.Write("Introduce la altura del tubo en m.: ");
                        altavoz.Speak("Introduce la altura del tubo en metros.");
                        altura = float.Parse(Console.ReadLine());
                        Console.Write("Introduce altura del agua. Máximo es de {0} m.: ", altura);
                        altavoz.Speak("Introduce altura del agua. Máximo es de " + altura + "metros.");
                        nivelAgua = float.Parse(Console.ReadLine());
                        Console.Write("Introduce cantidad de tubos: ");
                        altavoz.Speak("Introduce cantidad de tubos.");
                        cantidadTubos = int.Parse(Console.ReadLine());
                        #endregion

                        #region Cálculos.
                        // Cálculo volumen.
                        volumen = PI * (radio * radio) * altura;

                        // Cálculo litros.
                        litros = volumen * 1000;

                        // Cálculo porcentaje en % del litro de agua.
                        resultadoPorcentaje = nivelAgua * (100 / altura);

                        // Cálculo litros de agua.
                        volumenLitros = PI * (radio * radio) * nivelAgua;
                        resultadoLitros = volumenLitros * 1000;

                        // Cálculo litros por cantidad de tubos
                        cantidadTubosLitros = cantidadTubos * resultadoLitros;

                        // Cálculo cantidad de litros con total de tubos.
                        totalLitros = litros * cantidadTubos;
                        #endregion

                        #region Dibujado barra de progreso.

                        // Posición.
                        Console.SetCursorPosition(0, 4);

                        // Dibujo de la barra.
                        Console.WriteLine();
                        Console.WriteLine("0 %                     50 %                   100 %");
                        Console.WriteLine("┌────────────────────────┬───────────────────────┐");

                        // Mitad de la barra para que no sea muy grande en la pantalla.
                        mitadBarra = resultadoPorcentaje / 2;

                        if (resultadoPorcentaje <= 15)
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                        }
                        else if (resultadoPorcentaje <= 40)
                        {
                            Console.ForegroundColor = ConsoleColor.Yellow;
                        }
                        else if (resultadoPorcentaje <= 100)
                        {
                            Console.ForegroundColor = ConsoleColor.Green;
                        }

                        if (mitadBarra > 50)
                        {
                            mitadBarra = 50;
                        }

                        Console.SetCursorPosition(0, 7);
                        // Rellenar la barra.
                        for (int i = 1; i <= mitadBarra; i++)
                        {
                            Console.Write("█");
                        }

                        Console.ForegroundColor = ConsoleColor.Gray;

                        // Si llega a 100 se pone el # en rojo.
                        if (resultadoPorcentaje > 100)
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.Write("#");
                            Console.ForegroundColor = ConsoleColor.Gray;
                        }
                        #endregion

                        #region Mostrar textos en pantalla.
                        // Cursor invisible.
                        Console.CursorVisible = false;

                        // Pisición del texto a mostrar.
                        Console.SetCursorPosition(0, 9);

                        // Muestra porcentaje del depósito.
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.Write("\nPorcentaje: ");
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.WriteLine(resultadoPorcentaje.ToString("N2") + " %.");
                        altavoz.Speak("Cantidad de agua que hay en el depósito es de " +
                            //resultadoPorcentaje.ToString("N2") + "%.");
                            resultadoPorcentaje + "%.");

                        // Muestra cantidad de agua que hay actualmente y el total.
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.Write("\nLitros de agua: ");
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.Write(resultadoLitros.ToString("N2"));
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine(" / " + litros.ToString("N2") + " L. total de un tubo.");
                        altavoz.Speak("Cantidad de litros de agua en un tubo de " +
                            resultadoLitros.ToString("N2") + "de " +
                            litros.ToString("N2") + " litros total de un tubo.");

                        // Cantidad de tubos sin contar la base conectada, solo tubos independiente.
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.Write("\nCantidad de Litros total por " + cantidadTubos + " tubos: ");
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.Write(cantidadTubosLitros.ToString("N2"));
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine(" / " + totalLitros.ToString("N2") + " L.");
                        altavoz.Speak("Cantidad de litros en total por " + cantidadTubos.ToString("N2") +
                            " tubos: " + cantidadTubosLitros.ToString("N2") +
                            " de " + totalLitros.ToString("N2") + " litros.");
                        #endregion
                    }
                }

                catch (FormatException)
                {
                    Console.BackgroundColor = ConsoleColor.Gray;
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Clear();
                    Console.SetCursorPosition(8, 5);
                    Console.Write(@"La cadena de entrada no tiene el
        formato correcto.

        Solo debes introducir números y comas.");
                    Console.CursorVisible = false;
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }

                // Pulse cualquier tecla para continuar.
                Console.ReadKey();
            } while (true);
        }
    }
}

En resumen, quiero hacer lo mismo de C#, sin voz y lo más sencillo posible en Arduino IDE.

Saludos.
Páginas: 1 2 [3] 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ... 229
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines