El mejor IDE que he visto es Visual Studio y Eclipse.

Hola:

¿Exactamente qué te refieres?

¿Adaptar código de Python a C#?

¿Añadir código de Python de un archivo externo o un trozo de código directamente etiquetado incrustado en C# por medio?

¿Una dll hecho con Python (que yo sepa no se puede) y lo lee C#?

Saludos.

Buenas:

Quiero enviar un email en modo consola que supere los 255 caracteres tal como se hace en cualquier navegador.

¿Es posible hacerlo?

Aquí dejo un ejemplo con  Ggail.

Felices fiestas camaradas.

Hola:

Ver respuestas.

Saludos.

Muchas gracias y los consejos mi muy distinguido amigo.

Buenas:

Ya no falla. Lo corregí arriba y dejé una descripción.



Lo que hace el programa.
1. Solo se usa las flechas del teclado y la tecla Enter.
2. Te pide que introduzcas un nombre, que puedes manejar con la flecha del teclado.
3. Cuando termines de introducir un nombre, pulsas Enter, el cursor > irá en ATRÁS como puedes ver abajo.


4. Pulsas las teclas derecha o izquierda para elegir con el cursor > en GUARDAR y pulse Enter, guardará el nombre de un archivo de texto plano con la extensión .txt. Se llama Archivo.txt.
5. Si haz pulsado la tecla Enter en > Guardar, te muestra el mensaje de abajo.


6. Se pulsa Enter otra vez y se cierra el programa.
7. Al ejecutar el programa de nuevo, lee el Archivo.txt su contenido y lo muestra en pantalla.

Hasta aquí llega.

Ya que la estructura del programa indicas que lo tengo estilo chapuza, pues intentar hacerlo la mejor manera posible.

Una vez que domine esta parte. Debo hacer un mini menú de elegir 8 relés en el cual elijo uno a uno y escribo más guardo el nombre de cada uno de ellos.

Saludos.

Hola gente del foro:

¿Cómo están?

Tengo un programa que al ejecutarlo, con el teclado Enter y las flechas puedo escribir. Pulso Enter y le doy en Guardar con Enter otra vez.

Cierro el programa, lo vuelvo abrir.

Si ejecuto y cierro el programa, misteriosamente el archivo .txt está todo borrado, sobre todo si lo hago rápido.

¿Por qué ocurre esto?

¿Hay alguna forma de solucionarlo?

Código completo C#:

using System;
using System.IO;
 
namespace LCD_nombre_archivo_consola_12
{
    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 83 presenta al espacio ' ' del array roALFANUMERICO indicado justo arriba.
        // Hay un total de 85 caracteres. Se cuenta desde el 0 al 84.
        static readonly int[] roINDICE_ARRAY = new int[]
        {
         84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84
        };
 
        // 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 Inicio.
        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.
            else
            {
                // Crea un archivo nuevo, escribe el contenido en el archivo y, a continuación, lo cierra.
                // Si el archivo de destino ya existe, se sobrescribe.
                File.WriteAllText("Archivo.txt", guardarNombre);
            }
 
            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 array 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(); // Limpia la pantalla.
 
            // 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();
        }
    }
}

Saludos camaradas.

Edito:
Ya funciona. Tenía que poner el else despuués del if, para que no se ejecute siempre, que lo tenía en el aire. Aún así voy a leer atentamente tus consejos.

Mejor tu método para la barra.

El problema que es en toda la pantalla.

El redibujado de una barra lo que se suele hacer al menos en las LCD para microcontroladores es que si funciona hasta aquí que son 10 veces █. "Alt + 219" en ASCII.

██████████

Si luego quiero poner 5 █, no se borra, tienes que borrarlo todo con 10 espacios y redibujar luego hasta cinco veces █.

En cada parte la pantalla de la consola, si solo se actualiza números, letras o dibujos como estos █, solo se tiene que modificar en esas áreas ya indicando las coordenadas de la pantalla a redeibujar o modificar valores.

Parece ser que se refrezca la pantalla completa.

Saludos.

Buenas:

El dispositivo es Arduino UNO r3 y este es su código.

// Include el código de la librería.
#include <LiquidCrystal.h>
 
unsigned int valorPot1 = 0;
 
// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
//LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// Pin 10 para saber que es luz de fondo.
//const byte LuzFondo = 10;
 
void setup()
{
 
  Serial.begin(9600); // 115200
  // La pantalla es de 16 caracteres y 2 filas.
  lcd.begin(16, 2);
 
  // Indicar luz de fondo como salida.
  // pinMode(LuzFondo, OUTPUT);
 
  pinMode(A1, INPUT);
}
 
void loop()
{
  valorPot1 = analogRead(A1);
  lcd.setCursor(0, 0);
  lcd.print(F("Pot. A1: "));
  lcd.setCursor(9, 0);
  lcd.print(F("    "));
  lcd.setCursor(9, 0);
  lcd.print(valorPot1);
  Serial.print(valorPot1);
  delay(100); // 1000 mili segundos o 1 segundo.
}

Me da que el código C# en vez de actualizar solo números y por supuesto, la barra de progreso. Refrezca todo la pantalla en completo, por eso hace cosas raras.

Saludos.