Mensajes

Creo que tendrías el mismo resultado si escribes cinco veces █ y a continuación 5 espacios.
De hecho si puedes posicionar el cursor para dibujar solo esos 5 espacios finales, estarías haciendo lo que te decía más arriba... una funcion: Desactivar(fila, columna, xCantidad)

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.

Código (cpp) [Seleccionar] Expandir

// 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.

Muchas gracias.

Lo cambié por

Código (csharp) [Seleccionar] Expandir

long Variar_este_valor = Convert.ToInt64(recibidos);

Resulta que si ejecuto el programa lo hace. Si le doy a cerrar y luego ejecutar vuelve aparecer el mismo error.

Tengo que quitar el cable, colocarlo al P y luego ejecutar el programa y se ejecuta. Así no sale el error a pesar que puse también en modo long.

Una vez funcionando. Lo que no entiendo como que parpadea mucho la pantalla, es decir, si me muestra un valor que le llega por cada 100 ms desde el puerto serie, por ejemplo, el valor 454, tiene que verse este valor a:


Luego se pasa a este valor de abajo.


Se va alternando así cada rato. Tiene que estar fijo la pantalla, parece que hace refrezco de imagen cada cierto tiempo. Solo tiene que cambiar de imagen fluido si desde el puerto serie cambia de valor tanto los números como la barra de progreso.

Gracias.

[System.OverflowException: ']

Hola:

Al ejecutar el programa me sale este error.
System.OverflowException: 'Valor demasiado grande o demasiado pequeño para Int32.'

Con cretamente aquí.

Código [Seleccionar] Expandir

int Variar_este_valor = Convert.ToInt32(Recibidos);

Código del programa.

Código (csharp,101) [Seleccionar] Expandir

using System;
using System.IO.Ports; // No olvidar.
using System.IO;

namespace Porcentaje_Barra_Puerto_Serie_Consola_03
{
    class Program
    {
        public static string recibidos = "";
        public static double Resultado_Porcentaje = 0;
        public static double Resultado_Voltios = 0;
        public static double Mitad_barra = 0;
        public static int Contador = 1;


        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Puerto serie C# - 2019";

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

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

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

            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();

            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
            string COM = "";

            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort serialPort1 = new SerialPort();

            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.

Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();

            serialPort1.PortName = "COM" + COM; // Número del puerto serie.

            // Crear un nuevo objeto SerialPort con la configuración predeterminada.

            // Configuración del puerto serie.
            serialPort1.BaudRate = 9600;            // Baudios o velocidad. 115200
            serialPort1.Parity = Parity.None;       // Sin paridad.
            serialPort1.DataBits = 8;               // 8 Bits de datos.
            serialPort1.StopBits = StopBits.Two;    // Bits de parada.
            serialPort1.Handshake = Handshake.None; // Control de flujo.
            serialPort1.ReadBufferSize = 4096;      // Tamaño del Búffer de lectura en Bytes.
            serialPort1.WriteBufferSize = 2048;     // Tamaño del Búffer de escritura en Bytes.
            serialPort1.ReadTimeout = 500;          // Establecer lectura de espera.
            serialPort1.WriteTimeout = 500;         // Establecer escritura de espera.
            serialPort1.DtrEnable = false;
            serialPort1.RtsEnable = false;


            try
            {
                serialPort1.Open(); // Abrir el puerto serie.
            }

            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + serialPort1.PortName + @" no existe
            o no lo encuentra.");
            }

            serialPort1.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Console.Read();
            serialPort1.Close(); // Cerrar puerto.
        }

        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)

        {

            try
            {
                SerialPort sp = (SerialPort)sender;
                recibidos = sp.ReadExisting();
                //Console.Clear();

                recibidos = recibidos.Replace("\n\r", "");

                int Variar_este_valor = Convert.ToInt32(recibidos);

                Resultado_Porcentaje = Variar_este_valor * (100.00 / 1023.00);
                Resultado_Voltios = Variar_este_valor * (5.00 / 1023.00);


                Console.SetCursorPosition(0, 1);
                Console.Write("Datos recibidos: ");
                Console.SetCursorPosition(17, 1);
                Console.Write("    ");
                Console.SetCursorPosition(17, 1);
                Console.Write(recibidos);

                // Dibujamos la barra del portentaje.
                Console.SetCursorPosition(0, 3);
                Console.Write("0 %                     50 %                   100 %");
                Console.SetCursorPosition(0, 4);
                Console.Write("┌────────────────────────┬───────────────────────┐");
                Console.Write("                                                  ");
                Console.ForegroundColor = ConsoleColor.Yellow;

                // Se dibide por dos la barra del porcentaje para que quepa decuadamente en la pantalla.
                Mitad_barra = Resultado_Porcentaje / 2;

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

                // Console.SetCursorPosition(0, 5);
                ClearCurrentConsoleLine();
                // Barra de progreso.
                for (int i = 1; i <= Mitad_barra; i++)
                {
                    Console.Write("█"); // Muestra ASCII 219 Dec y DB en Hex.
                                        // Console.Write((char)219);
                                        // Console.Write(Encoding.ASCII.GetBytes((char)219));
                }

                // Si sobre pasa 100, muestra # al final de la barra del porcentaje de color rojo.
                if (Resultado_Porcentaje >= 100)
                {
                    Console.SetCursorPosition(50, 5);
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("#");
                }

                Console.ForegroundColor = ConsoleColor.Gray; // Vuelve al color gris.

                // Línea 7.
                Console.SetCursorPosition(0, 7);
                Console.Write("Porcentaje: ");
                Console.SetCursorPosition(12, 7);
                Console.Write("            ");
                Console.SetCursorPosition(12, 7);
                Console.Write(Resultado_Porcentaje.ToString("N0") + " %.");

                // Línea 8.
                Console.SetCursorPosition(0, 8);
                Console.Write("Voltios: ");
                Console.SetCursorPosition(12, 8);
                Console.Write("            ");
                Console.SetCursorPosition(12, 8);
                Console.Write(Resultado_Voltios.ToString("N2") + " V.");

            }

            catch (FormatException)
            {
                // Console.WriteLine("La cadena de entrada no tiene el formato correcto.");
                Console.SetCursorPosition(0, 10);
                Console.Write("                 ");
                Console.SetCursorPosition(0, 10);
                Console.Write("Contador: " + Contador++);
                // return;
            }

        }

        public static void ClearCurrentConsoleLine()
        {
            int currentLineCursor = Console.CursorTop;
            Console.SetCursorPosition(0, Console.CursorTop);
            Console.Write(new string(' ', Console.WindowWidth));
            Console.SetCursorPosition(0, currentLineCursor);
        }
    }
}

Rara vez el programa se ejecuta pero tiene otro comportamiento parpadeante en la pantalla pero muestra los datos un poco incómodo. Voy por partes.

Saludos.

Gracias por la idea, voy a probar a ver. Después comento.

[6 - 5------0 - 0 normal [always use this value]0 - 1 boost one stage1 - 0 boost two stages1 - 1 buck one stag]

Hola:

Este programa consiste en leer bits en ciertos Bytes. En este manual que puedes ver aquí.

Ver manual en pdf.

Página 7 / 21.

Concretamente en el Byte S2 y en los bit 6 y 5 se puede hacer una combinación en 4 estados que tiene que ser así:

6 - 5
------
0 - 0 normal [always use this value]
0 - 1 boost one stage
1 - 0 boost two stages
1 - 1 buck one stag


Rrecordando que los bits 6 y 5 del Byte S2 entre estos dos hay cuatro combinaciones indicado justo arriba.

Por ejemplo, si el Byte S2 tiene la combinación de los bits 6 y 5 de esta manera.

bit 6 igual a 0 y el bit 5 igual a 1, muestra el mensaje boost one stage.

Porque 0 - 1 es el que le corresponde y se muestra en pantalla. Sol me falta completar esta parte.

Dejo el código completo .

Código (csharp) [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Delimitador_consola_03
{
    class Program
    {
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Probando manipulación de cadena";

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

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

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

            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();

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

            // Cree una codificación ISO-8859-1.
            Encoding ISO_8859_1 = Encoding.GetEncoding("ISO-8859-1");

            #region Variables.
            // Partir a trocitos estos caracteres.
            char[] delimitadorComandoB = { '#', ',', 'O', 'I', 'L', 'B', 'V', 'F', 'H', 'R', 'S', };

            // Es la cadena de caracteres que me llegó desde el puerto serie.
            // En este ejemplo lo dejo en la varible directamente.
            // Una cadena completa empieza con # y termina en <cr>, o lo que es lo mismo, /r.
            string respuestaB = "#I223.3O224.0L000B100V26.4F50.2H50.2R0080S,,€€,,À"; // Comando B.

            // Se guarga en este array tipo string los datos ya partidos a tozos.
            string[] palabrasB = respuestaB.Split(delimitadorComandoB);

            // Tabla S1 descripción.
            string[] DESCRIPCION_S1 =
            {
                "Indica que este byte está disponible y es válido. [Siempre 1]",             // Posición [0].
                "Indica falla de energía de la red pública; ver detalles en S2.0 y S2.1.",
                "Indica que la capacidad de la batería es menor que el umbral de apagado.",
                "Indica que el zumbador está en estado de pitido.",
                "Indica que la prueba de batería se está procesando.",
                "Indica que el apagado programado está pendiente.",
                "Indica que la restauración programada está pendiente.",
                "Indica falla de hardware; ver detalles sobre el comando X71."               // Posición [7].
            };

            string[] DESCRIPCION_S2 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "--",
                "XX",
                "Indica sobretemperatura del inversor.",
                "Indica que el inversor tiene una falla.",
                "Indica que el inversor está apagado.",
                "Indica que la frecuencia de la utilidad está fuera de rango.",
                "Indica que el voltaje de la red pública está fuera de rango."
            };

            string[] DESCRIPCION_S3 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que la batería está completamente cargada.",
                "Indica que la capacidad de la batería aún es menor que el umbral restaurado del UPS cuando la energía de la red pública restaurado.",
                "Indica que la batería se está cargando.",
                "Indica que la batería se está descargando.",
                "Indica que la capacidad de la batería es inferior al 80 por ciento.",
                "Reservado, debe ser 0.",
                "Indica que la batería no está presente."
            };

            string[] DESCRIPCION_S4 =
{
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que el bypass es una sobrecarga.",
                "Indica que la derivación está activa.",
                "Indica que la salida sufre un cortocircuito.",
                "Indica que la salida tiene carga.",
                "Indica que la salida está sobrecargada.",
                "Indica que la frecuencia de salida está fuera de rango en bypass.",
                "Indica que el voltaje de salida está fuera de rango en derivación."
            };

            string[] DESCRIPCION_S5 =
{
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que no hay salida.",
                "Para indicar que el tiempo de ejecución restante es inferior al umbral.",
                "Para indicar que el zumbador está silenciado (no permanente) en este momento.",
                "Para indicar falla de cableado.",
                "Para indicar SAI en modo ECO.",
                "Para indicar UPS en Bypass manual.",
                "Arreglar 0."
            };

            string[] DESCRIPCION_S6 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica UPS encendido.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0."
            };

            bool boolS1 = true;
            bool boolS2 = false;
            bool boolS3 = false;
            bool boolS4 = false;
            bool boolS5 = false;
            bool boolS6 = false;
            bool boolContador = true;
            bool boolContador2 = false;
            #endregion

            // Comando B.
            Console.WriteLine();

            // Muestra los resultados en pantalla.
            Console.WriteLine();
            Console.WriteLine("El voltaje de la utilidad es de {0} voltios. ", palabrasB[2]); // I.
            Console.WriteLine("El voltaje de salida del UPS es de {0} voltios. ", palabrasB[3]); // O.
            Console.WriteLine("La carga actual de UPS es del {0} por ciento. ", palabrasB[4]); // L.
            Console.WriteLine("La capacidad de la batería es del {0} por ciento. ", palabrasB[5]); // B.
            Console.WriteLine("El voltaje de la batería es de {0} voltios. ", palabrasB[6]); // V.
            //Console.WriteLine("La temperatura del gabinete del UPS es de {0} grados centígrados. ", palabrasB[7]); // T. No hay T. en mi versión.
            Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[7]); // F.
            Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[8]); // H.
            Console.WriteLine("El tiempo de funcionamiento restante de la batería es de {0} minutos. ", palabrasB[9]);
            //Console.WriteLine(@"Estos son los bits de estados que no se entiende.S:
            //Aquí hay que leer cada bits como cuando se leyeron cada Byte arriba: ", (char)palabrasB[10]);

            char[] bits = palabrasB[10].ToCharArray();

            //int byteS1 = (byte)bits[0];
            //int byteS2 = (byte)bits[1];
            //int byteS3 = (byte)bits[2];
            //int byteS4 = (byte)bits[3];
            //int byteS5 = (byte)bits[4];
            //int byteS6 = (byte)bits[5];

            //Console.WriteLine("Byte S1: {0}", byteS1.ToString());
            //Console.WriteLine("Byte S2: {0}", byteS2.ToString());
            //Console.WriteLine("Byte S3: {0}", byteS3.ToString());
            //Console.WriteLine("Byte S4: {0}", byteS4.ToString());
            //Console.WriteLine("Byte S5: {0}", byteS5.ToString());
            //Console.WriteLine("Byte S6: {0}", byteS6.ToString());


            //Console.WriteLine();
            //Console.WriteLine(((byteS1 & 128) == 128) ? "ACTIVADO" : "DESACTIVADO");
            //Console.WriteLine(((byteS1 & 128) == 128) ? "1" : "0");
            //Console.WriteLine();

            Tabla();
            int contador = 0;
            for (int b = 0; b < bits.Length; b++)
            {
                for (int a = 7; a >= 0; a--)
                {

                    Console.Write((((byte)bits[b]) & (1 << a)) >> a);
                    Console.Write(" | ");

                    if ((contador <= 7) && (boolS1 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S1[contador]);

                        if (contador == 7)
                        {
                            boolS1 = false;
                            boolS2 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS2 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S2[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS2 = false;
                            boolS3 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS3 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S3[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS3 = false;
                            boolS4 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS4 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S4[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS4 = false;
                            boolS5 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS5 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S5[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS5 = false;
                            boolS6 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS6 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S6[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS6 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }

                    if (boolContador == true)
                    {
                        contador++;

                        if (boolContador2 == true)
                        {
                            contador = 0;
                        }
                    }
                    //Console.WriteLine();
                }
                Console.WriteLine();
            }


            #region Tabla.
            void Tabla()
            {
                Console.WriteLine();
                Console.WriteLine("Byte | Bit | Estado | Descripción");
                Console.WriteLine("-----+-----+-----------------------------------------------------------------------");
            }
            #endregion

            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

¿Cómo se soluciona este problema?

Saludos.

Hola:

¿Es posible configurar la ventana de la consola mediante C#?

En mi caso, quiero configurar el tamaño de la fuente mediante códigos C#. Lo puedo hacer de otra manera cambiando propiedades como indica cen la iamgen de abajo.


Las demás configuraciones si las puedo cambiar a códigos C# menos la fuente de la pantalla.

Un ejemplo.

Código [Seleccionar] Expandir

// Título de la ventana.
            Console.Title = "Configuración ventana consola C#";

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

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

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

            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();

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

Saludos.

Código (csharp) [Seleccionar] Expandir

long suma =0;

DirectoryInfo di = new DirectoryInfo("c:\\temp");

foreach (FileInfo info in di.GetFiles("*", SearchOption.AllDirectories))

{

   suma+=info.Length;

}