Mensajes

Hola:

Al final el código Morse es analogicamente analógico. Lo que no sabía, que todavía se usa hoy en día, a pesar que ya tiene unos 175 años de su historia.

Hasta hay códigos en C# con morse. La gente se abure.

[youtube=640,360]https://www.youtube.com/watch?v=Hxn_791rgyg[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=8FGslme1Vng[/youtube]

Saludos.

Buenas:

Tengo un programa hecho a medias. Está hecho con la consola C#.

Al pulsar la X de la ventana, quiero que haga estas cosas.
Pregunta si realmente quiero salir, si salgo, pone esto.

Código (csharp) [Seleccionar] Expandir

                            Si pulso X con el ratón
                            {
                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
                                Puerto_serie.Close(); // Cierra el puerto serie.
                                Environment.Exit(0); // Cerrar aplicación.
                            }

Arriaba está mal planteado.

Primero pregunta si quiero salir, con un Sí y un No, si pulso No, el programa sigue su curso, si pongo Si, cierra el programa y me envía estos datos al puerto serie antes de que cierre del todo.

Código (csharp) [Seleccionar] Expandir

                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
                                Puerto_serie.Close(); // Cierra el puerto serie.
                                Environment.Exit(0); // Cerrar aplicación.

Código ejemplo casi completo.

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO.Ports;

namespace Introducir_datos_puerto_serie_consola_01
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Enviar datos al puerto serie";

            // Tamaño de la ventana, x, y.
            Console.SetWindowSize(70, 25);

            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Yellow;

            // Limpiar pantalla y dejarlo todo gris.
            Console.Clear();

            // Visible el cursor.
            Console.CursorVisible = true;

            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort("COM3");

            Puerto_serie.BaudRate = 115200;
            Puerto_serie.Parity = Parity.None;
            Puerto_serie.StopBits = StopBits.One;
            Puerto_serie.DataBits = 8;
            Puerto_serie.Handshake = Handshake.None;
            Puerto_serie.RtsEnable = true;

            // Establecer los tiempos de espera de lectura / escritura.
            Puerto_serie.ReadTimeout = 500; // Milisegundos.
            Puerto_serie.WriteTimeout = 500;

            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Puerto_serie.Open(); // Abrir puerto.

            //Console.CursorSize = 1;

            do
            {
                Console.Write("Introduzca un texto: ");
                string texto;
                texto = Console.ReadLine();
                Console.WriteLine("El texto introducido es: " + texto);

                //texto = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                Puerto_serie.Write(texto); // Envía los datos del string todo su contenido.
                Console.WriteLine("Comando {0} enviado.", texto); // Muestra en pantalla comandos enviado.
                Console.WriteLine();

                // ################ Pregunta aquí si quieres salir.   ################
                            //Si pulso X con el ratón
                            //{
                            //    Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
                            //    Puerto_serie.Close(); // Cierra el puerto serie.
                            //    Environment.Exit(0); // Cerrar aplicación.
                            //}
                // #####################################################################

            } while (true);


        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.WriteLine("Datos recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
        }
    }
}


Gracias camaradas.

Saludos.

[EI: Juntando mensajes, otra vez.]

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 (cpp) [Seleccionar] Expandir

#include <iostream>
#include <string>
#include <windows.h> // Para mostrar texto en el título de la ventana.
#include <stdio.h>   // Cambio color de fondo y letras.

using namespace std;

int main()
{
   // Variables.
   string guardarNombre = ""; // Guardar nombre escrito.
   static int coordenadaX = 0; // Coordenada X del setCursorPisition.
   //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
   static int index = 0; // Índice.

   // Caracteres de este array.
   static char const ALFANUMERICO[] =
   {
       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
       'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
       'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
       'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
       '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
   };

   // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
   static int const INDICE_ARRAY[] =
   {
       80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
   };

   // Palabras del array para imprimir en pantalla.
   static string const TEXTO[] = { "ATRÁS", "GUARDAR" };

   // Mostrar caracteres correctamente en pantalla y título de la ventana.
   SetConsoleOutputCP(65001);
   wchar_t titulo[128];
   MultiByteToWideChar(CP_UTF8, 0, "Título de la ventana. Win32 C++ 2019.", -1, titulo, 128);
   SetConsoleTitle(titulo);

   // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
   SMALL_RECT r = { 0, 0, 49, 9 }; // X = 49, Y = 9.
   SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);

   // Cambio color de 8 (gris), color letras 0 (negro).
   system("color 80");

   // mostrar contenido de las variables.
   cout << guardarNombre << endl;
   cout << coordenadaX << endl;
   cout << index << endl;

   for (int i = 0; i < sizeof(ALFANUMERICO) / sizeof(ALFANUMERICO[0]); i++)
   {
       cout << ALFANUMERICO[i] << endl;
   }

   for (int i = 0; i < sizeof(INDICE_ARRAY) / sizeof(INDICE_ARRAY[0]); i++)
   {
       cout << INDICE_ARRAY[i] << endl;
   }

   for (int i = 0; i < sizeof(TEXTO) / sizeof(TEXTO[0]); i++)
   {
       cout << TEXTO[i] << endl;
   }

   // Esperando pulsar Enter para salir.
   cin.get();
   //getchar();
   return 0;
}

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 (csharp) [Seleccionar] Expandir

using System;
using System.IO;

namespace LCD_nombre_archivo_consola_11
{
   class Program
   {
       // Variables.
       static string guardarNombre = ""; // Guardar nombre escrito.
       static int coordenadaX = 0; // Coordenada X del setCursorPisition.
       static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
       static int index = 0; // Índice.

       // Caracteres de este array.
       static readonly char[] roALFANUMERICO = new char[]
       {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
        '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '
       };

       // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
       static readonly int[] roINDICE_ARRAY = new int[]
       {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
       };

       // Palabras del array para imprimir en pantalla.
       static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };

       static void Main(string[] args)
       {
           // Título de la pantalla.
           Console.Title = "Cambiar nombre";

           Inicio();
       }

       static void MainMenu()
       {
           Console.Clear(); // Limpiar pantalla.

           Console.SetCursorPosition(0, 0);
           Console.Write("Nombre del relé 1:  ");
           Console.SetCursorPosition(0, 1);

           // Recorre el índice del array, del 0 hasta donde llegue.
           for (int i = 0; i < roINDICE_ARRAY.Length; i++)
           {
               // Imprime los caracteres del array.
               Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
           }

           Console.SetCursorPosition(3, 3);
           Console.Write(roTEXTO[0]); // ATRÁS.
           Console.SetCursorPosition(12, 3);
           Console.Write(roTEXTO[1]); // GUARDAR.
       }

       #region Inico.
       static void Inicio()
       {
           Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
           Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
           Console.ForegroundColor = ConsoleColor.Black; // Letras negras.

           // ¿El archivo Existe?
           if (File.Exists("Archivo.txt"))
           {
               // Sí. Lee el archivo de texto.
               string nombre = File.ReadAllText("Archivo.txt");
               int a, b; // Almacena ídice array.
               for (a = 0; a < nombre.Length; a++)
               {
                   for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
                   {
                       ;
                   }
                   roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
               }
           }

           // No. El Archivo.txt no existe. El código continúa por aquí.

           MainMenu(); // Dibuja el menú.

           while (true)
           {
               Console.CursorVisible = true; // Cursor invisible.
               index = 0;

               // Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
               if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
               {
                   MainMenu(); // Dibuja el menú.
               }

               // Posiciona cursor.
               Console.SetCursorPosition(coordenadaX, 1);

               // Almacena en la variable tecla, la tecla pulsada.
               tecla = Console.ReadKey(true).Key;

               // Si coincide una tecla pulsada.
               switch (tecla)
               {
                   case ConsoleKey.RightArrow: // Flecha derecha detectada.
                       // ¿CoordenadaX menor que 15?
                       if (coordenadaX < 15)
                       {
                           coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
                       }
                       // No. Sale de aquí.
                       break;

                   case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
                       // ¿coordenadaX es mayor que 0?
                       if (coordenadaX > 0)
                       {
                           coordenadaX--; // Sí. Decremente o quita -1.
                       }
                       // No. Sale de aquí.
                       break;

                   case ConsoleKey.UpArrow: // Flecha arriba.
                       roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
                       // ¿El índice del array es mayor o igual que el arra Alfanumérico?
                       if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                       {
                           roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
                       }
                       Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                       break;

                   case ConsoleKey.DownArrow: // Flecha abajo detectado.
                       roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
                       // ¿La coordenadaX del indice del array es menor que 0?
                       if (roINDICE_ARRAY[coordenadaX] < 0)
                       {
                           // Sí. Imprimir el valor alfanumérico.
                           roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                       }
                       Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                       break;

                   case ConsoleKey.Enter: // Detecta la tecla Enter.
                       Console.SetCursorPosition(1, 3); // Posición del cursor.
                       Console.CursorVisible = false; // Se oculta el cursor.
                       Console.Write(">"); // Imprime en pantalla >.

                       // ¿La tecla almacenada es distinto a la tecla Enter?
                       while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
                       {
                           // Sí.
                           switch (tecla)
                           {
                               case ConsoleKey.RightArrow:
                                   index = 1;
                                   Console.SetCursorPosition(1, 3);
                                   Console.Write(" ");
                                   Console.SetCursorPosition(10, 3);
                                   Console.Write(">");
                                   break;
                               case ConsoleKey.LeftArrow:
                                   Console.SetCursorPosition(10, 3);
                                   Console.Write(" ");
                                   Console.SetCursorPosition(1, 3);
                                   Console.Write(">");
                                   index = 0;
                                   break;

                               case ConsoleKey.UpArrow:
                                   Inicio();
                                   break;

                               case ConsoleKey.DownArrow:
                                   Inicio();
                                   Console.SetCursorPosition(coordenadaX, 1);
                                   break;
                           }
                       }

                       if (index == 0)
                       {
                           Atras();
                       }
                       if (index == 1)
                       {
                           Guardar();
                       }
                       break;
               }
           }
       }
       #endregion

       static void Atras()
       {
           Console.Clear();
           Console.SetCursorPosition(0, 1);
           Console.Write("HAS PULSADO ATRÁS   ");
           Console.ReadKey(); // Pulse cualquier tecla para salir.
       }

       static void Guardar()
       {
           guardarNombre = "";
           Console.Clear();

           // Lee todo el contennido del array y lo guarda en guardarNombre.
           for (int a = 0; a < roINDICE_ARRAY.Length; a++)
           {
               guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
           }
           Console.SetCursorPosition(0, 2);
           Console.Write(guardarNombre); // Imprime el contenido.

           // Crear Archivo.txt y el contenido de guardarNombre.
           File.WriteAllText("Archivo.txt", guardarNombre);

           Console.SetCursorPosition(0, 1);
           Console.Write("HAS GUARDADO       ");

           // Pulsa otra vez tecla.
           Console.ReadKey();
       }
   }
}

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





EI: Juntando mensajes, otra vez.

Me funciona hasta con Arduino.

Código (cpp) [Seleccionar] Expandir

#include <LiquidCrystal.h>

// Inicializa la librería con sus pines indicados.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo del LCD.
//int LuzFondo = 10;


// Variables.
String guardarNombre = ""; // Guardar nombre escrito.
int coordenadaX = 0; // Coordenada X del setCursorPisition.
int index = 0; // Índice.
// Caracteres de este array.
char const PROGMEM ALFANUMERICO[] =
{
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
};

// Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
int const PROGMEM INDICE_ARRAY[] =
{
  80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
};

// Palabras del array para imprimir en pantalla.
String const TEXTO[] = { "ATRÁS", "GUARDAR" };

void setup()
{
  // La pantalla es de 16 caracteres y 2 filas.
  lcd.begin(16, 2);
  lcd.print(F("  Probando..."));

  // Baudios del puerto serie.
  Serial.begin(115200);

  // Indicar luz de fondo como salida.
  // pinMode(LuzFondo, OUTPUT);

  Serial.println(guardarNombre);
  Serial.println(coordenadaX);
  Serial.println(index);

  for (byte i = 0; i < 80; i++)
  {
    Serial.println(ALFANUMERICO[i]);
  }

  for (byte j = 0; j < 16; j++)
  {
    Serial.println(INDICE_ARRAY[j]);
  }

  for (byte k = 0; k < 2; k++)
  {
    Serial.println(TEXTO[k]);
  }
}

void loop()
{
  //return 0;
}

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 (csharp) [Seleccionar] Expandir

    // Variables.
    static string guardarNombre = ""; // Guardar nombre escrito.
    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
    static int index = 0; // Índice.

    // Caracteres de este array.
    static char[] roALFANUMERICO = new char[]
    {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
    };

    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
    static int[] roINDICE_ARRAY = new int[]
    {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
    };

    // Palabras del array para imprimir en pantalla.
    static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };

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

Saludos.

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

¿Qué hago ahora?

Saludos.

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.

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.

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.

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 [Seleccionar] Expandir

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.

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.