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


Tema destacado: Curso de javascript por TickTack


  Mostrar Temas
Páginas: 1 ... 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 [24] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 ... 68
231  Programación / .NET (C#, VB.NET, ASP) / Se me cuelga Windows Form en: 27 Abril 2016, 01:18 am
Hola:

Tengo un programa que recibe datos una y otra vez por el puerto serie. A 0.1 segundos datos del 0 al 1023. Si no hay datos que esté leyendo porque en el otro lado no lo está enviando, puedo cerrar el programa sin problemas. Si hay datos que le llega y lee, al cerrar el programa aunque pongas SerialPort1.Close(); El programa se cuelga.

En el Load de Windwos Form he puesto esto.
Código
  1. Control.CheckForIllegalCrossThreadCalls = false;
https://msdn.microsoft.com/es-es/library/system.windows.forms.control.checkforillegalcrossthreadcalls%28v=vs.100%29.aspx

Se sigue colgando. No ha funcionado.

Por lo que he leído hay que usar hilos y es más complejo, no lo se.

¿Alguna solución?

Saludos.
232  Programación / .NET (C#, VB.NET, ASP) / Recibe datos por el puerto serie en modo consola y lo interpreta en: 21 Abril 2016, 15:11 pm
Hola:

Quiero recibir datos por el puerto serie. He hecho varios ejemplos. Lo más sencillo es este código de abajo, solo tiene que mostrar número en la posición que yo quiera X, Y del 0 al 1023 que recibe todo el rato. El código le llega desde Arduino y su código es.

Código Arduino:
Código
  1. int valorPot=0;
  2.  
  3. void setup(){ Serial.begin(115200); }
  4.  
  5. void loop(){
  6.      valorPot=analogRead(2);
  7.      Serial.println(valorPot);
  8.      delay(100); // 0.1 segundos.
  9. }

Código C#:
Código
  1. using System;
  2. using System.IO.Ports; // No olvidar.
  3. using System.Collections.Generic;
  4.  
  5. namespace Porcentaje_Barra_P_Serie_Consola_2_CS
  6. {
  7.     class Program
  8.     {
  9.         public static string Recibidos = "";
  10.  
  11.         // Como variables de clase
  12.         public static string[] Separador = new string[] { ",", "\r", "\n", "/n" };
  13.         public static List<string> Leo_Dato = new List<string>();
  14.  
  15.         static void Main(string[] args)
  16.         {
  17.             Console.Title = "Serial Port C#";
  18.  
  19.             int Variar_este_valor = 0; // De 0 a 1023.
  20.  
  21.             SerialPort Puerto_serie;
  22.  
  23.             // Crear un nuevo objeto SerialPort con la configuración predeterminada.
  24.             Puerto_serie = new SerialPort();
  25.  
  26.             // Configuración.
  27.             Puerto_serie.PortName = "COM4"; // Número del puerto serie.
  28.             Puerto_serie.BaudRate = 115200; // Baudios.
  29.             Puerto_serie.Parity = Parity.None; // Paridad.
  30.             Puerto_serie.DataBits = 8; // Bits de datos.
  31.             Puerto_serie.StopBits = StopBits.Two; // Bits de parada.
  32.             Puerto_serie.Handshake = Handshake.None; // Control de flujo.
  33.  
  34.             // Establecer la lectura / escritura de los tiempos de espera.
  35.             Puerto_serie.ReadTimeout = 500;
  36.             Puerto_serie.WriteTimeout = 500;
  37.  
  38.             Puerto_serie.Open(); // Abre el puerto serie.
  39.  
  40.             Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
  41.         }
  42.  
  43.         private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
  44.         {
  45.  
  46.             // En el evento.
  47.             Leo_Dato.Clear();
  48.             Leo_Dato.AddRange(Recibidos.Split(Separador, StringSplitOptions.RemoveEmptyEntries));
  49.  
  50.             SerialPort sp = (SerialPort)sender;
  51.             Recibidos = sp.ReadLine();
  52.             Console.SetCursorPosition(5, 10); // Posición X, Y.
  53.             Console.Write(Recibidos);
  54.         }
  55.     }
  56. }
  57.  

Cuando varío el potenciómetro de Arduino, en el puerto serie del PC, en pantalla de C# o modo consola, tiene que aparecer valores que lee el programa, la pantalla se apaga rápido.

¿Alguna idea?

Saludos.
233  Programación / .NET (C#, VB.NET, ASP) / Mostrar estas dos ventanas de Visual studio que no las encuentro. Memoria y Dese en: 6 Marzo 2016, 10:37 am
Hola:

En documento dice.

Las otras ventanas de depuración:
Hay muchas otras ventanas disponibles para la depuración, pero algunas no son realmente útiles
para el desarrollo de aplicaciones con Visual C#. Se reservan más para la prueba de aplicaciones
desarrolladas con otros lenguajes, C++ por ejemplo.
Por ejemplo, es el caso de la ventana de memoria que permite la visualización del contenido de una
zona de memoria de la cual conocemos la dirección.



Sobre todo en la MEmoria, que para ver esto uso programa de editor hexadecimales externos como este.

He estado buscan doe en Visual Stduuio .net Community 2015 y nada. Al menos quiero saber si lo incluye en esta versión.

Saludos.
234  Programación / .NET (C#, VB.NET, ASP) / No muestra visualmente los datos al variar en: 3 Marzo 2016, 16:07 pm
Hola:

Hice un pequeño programa, más bien adaptado del AWP a WPF bajo Visual C# 2015. En AWP me funciona en tiempo real a la hora de recibir datos diferentes, en WPF se queda congelado en el momento de recibir el primer dato. Si cambio los datos, cierro el programa y lo vuelvo abrir, se muestra los nuevos valores y se queda congelado.



El código fuente de C# WPF.
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Windows;
  7. using System.Windows.Controls;
  8. using System.Windows.Data;
  9. using System.Windows.Documents;
  10. using System.Windows.Input;
  11. using System.Windows.Media;
  12. using System.Windows.Media.Imaging;
  13. using System.Windows.Navigation;
  14. using System.Windows.Shapes;
  15.  
  16. using System.IO.Ports; // No olvidar.
  17.  
  18. namespace Arduino_In_Analogico_Prueba_01_WPF
  19. {
  20.     /// <summary>
  21.     /// Lógica de interacción para MainWindow.xaml
  22.     /// </summary>
  23.     public partial class MainWindow : Window
  24.     {
  25.         // Utilizaremos un string como buffer de recepción.
  26.         string Recibidos;
  27.         SerialPort serialPort1 = new SerialPort();
  28.  
  29.         public MainWindow()
  30.         {
  31.             InitializeComponent();
  32.  
  33.             // Configuramos el puerto serie.
  34.             serialPort1.BaudRate = 115200; // Baudios, tiene que ser el mismo que Arduino.
  35.             serialPort1.PortName = "COM4"; // Elegijos el mismo puerto que de Arduino.
  36.             serialPort1.Parity = Parity.None; // Nada de paridad.
  37.             serialPort1.DataBits = 8; // 8 bits.
  38.             serialPort1.StopBits = StopBits.Two; // Recomendado con 2 bits de Stop o parada.
  39.  
  40.             // Abrir y mantener abierto el puerto serie mientras se ejecute la aplicación.
  41.             if (!serialPort1.IsOpen)
  42.             {
  43.                 try
  44.                 {
  45.                     serialPort1.Open();
  46.                 }
  47.                 catch (System.Exception ex)
  48.                 {
  49.                     MessageBox.Show(ex.ToString());
  50.                 }
  51.             }
  52.  
  53.             // Ejecutar la función Recepción por disparo del evento ¡DataReived!
  54.             serialPort1.DataReceived += Recepcion;
  55.         }
  56.  
  57.         private void Recepcion(object sender, SerialDataReceivedEventArgs e)
  58.         {
  59.             // Acumular los caracteres recibidos a nuestro "buffer" (string).
  60.             Recibidos += serialPort1.ReadExisting();
  61.  
  62.             // Invocar o llamar al proceso de tramas.
  63.             this.Dispatcher.Invoke(Actualizar);
  64.         }
  65.  
  66.  
  67.         // Como variables de clase
  68.         private string[] Separador = new string[] { ",", "\r", "\n", "/n" };
  69.         private List<string> Leo_Dato1 = new List<string>();
  70.  
  71.         // Procesar los datos recibidos en el bufer y extraer tramas completas.
  72.         private void Actualizar()
  73.         {
  74.             double Voltaje = 0;
  75.             double Porcentaje = 0;
  76.  
  77.             // En el evento
  78.             Leo_Dato1.Clear();
  79.             Leo_Dato1.AddRange(Recibidos.Split(Separador, StringSplitOptions.RemoveEmptyEntries));
  80.  
  81.             label_Lectura_Potenciometro.Content = Leo_Dato1[0].ToString();
  82.             progressBar.Value = Convert.ToInt32(Leo_Dato1[0].ToString());
  83.  
  84.             double Dato_Voltaje = Convert.ToDouble(Leo_Dato1[0]);
  85.             double Dato_Porcentaje = Convert.ToDouble(Leo_Dato1[0]);
  86.  
  87.             Voltaje = Dato_Voltaje * (5.00 / 1023.00);
  88.             Porcentaje = Dato_Porcentaje * (100.00 / 1023.00);
  89.  
  90.             label_Voltaje.Content = Voltaje.ToString("N2") + " V.";
  91.             label_Portentaje.Content = Porcentaje.ToString("N0") + " %";
  92.         }
  93.     }
  94. }
  95.  

¿Hay alguna solución?

Saludos.
235  Programación / .NET (C#, VB.NET, ASP) / Añadir porcentaje al progressBar en: 27 Febrero 2016, 17:19 pm
Hola:

Estoy haciendo una pequeña prueba. Recibo en el puerto serie / USB datos que recoge Visual C# de 0 a 1023 y lo muestro en un label.



Hasta ahí funciona bien.

Tengo dos label más. El segundo tiene que demostrar el porcentaje del 0 % a 100% según el dato obtenido del 0 a 1023.

En el otro label, el tercero debemostrar número con decimales del 0.00 a 5.00.

A pesar de encontrar la fórmula, no se implementarlo en C#.

El código es este:
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Forms;
  10.  
  11. using System.IO.Ports; // No olvidar.
  12.  
  13. namespace Arduino_In_Analogico_prueba_01
  14. {
  15.     public partial class Form1 : Form
  16.     {
  17.         // Utilizaremos un string como buffer de recepción.
  18.         string Recibidos;
  19.         int Porcentaje;
  20.  
  21.         public Form1()
  22.         {
  23.             InitializeComponent();
  24.  
  25.             if (!serialPort1.IsOpen)
  26.             {
  27.                 try
  28.                 {
  29.                     serialPort1.Open();
  30.                 }
  31.                 catch (System.Exception ex)
  32.                 {
  33.                     MessageBox.Show(ex.ToString());
  34.                 }
  35.             }
  36.  
  37.             serialPort1.DataReceived += new SerialDataReceivedEventHandler(serialPort1_DataReceived);
  38.         }
  39.  
  40.         // Al recibir datos.
  41.         private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
  42.         {
  43.  
  44.             // Acumula los caracteres recibidos a nuestro 'buffer' (string).
  45.             Recibidos = serialPort1.ReadLine();
  46.  
  47.             // Invocar o llamar al proceso de tramas.
  48.             Invoke(new EventHandler(Actualizar));
  49.         }
  50.  
  51.  
  52.         // Como variables de clase
  53.  
  54.         private string[] separador = new string[] { ",", "\r", "\n", "/n" };
  55.         private List<string> leodato1 = new List<string>();
  56.  
  57.  
  58.  
  59.         // Procesar los datos recibidos en el bufer y extraer tramas completas.
  60.         private void Actualizar(object sender, EventArgs e)
  61.         {
  62.             // En el evento
  63.             leodato1.Clear();
  64.             leodato1.AddRange(Recibidos.Split(separador,StringSplitOptions.RemoveEmptyEntries));
  65.  
  66.             label_Lectura_Potenciometro.Text = leodato1[0].ToString();
  67.             progressBar1.Value = Convert.ToInt32(leodato1[0].ToString());
  68.             progressBar1.PerformStep();
  69.         }
  70.     }
  71. }

Saludos.
236  Informática / Electrónica / [TUTORIAL] Lecturas de entradas digitales con Arduino y Visual Studio .net 2015 en: 21 Febrero 2016, 04:11 am


Presento tutorial sobre entrada de datos digitales por puerto serie con Arduino controlado por tu propia interfaz hecho bajo Visual Studio .net

Ver enlace.

Ver vídeos.
Vídeo 1.

Vídeo 2.

Ahora me toca seguir con entradas y salidas analógicas.

Para recordar, ya hubo tutorial sobre controlar un Led.

Más tutoriales que puedes ver aquí.

Saludos.
237  Programación / .NET (C#, VB.NET, ASP) / Imitar ordenador de los cines de antes en cuanto al sonido en: 12 Febrero 2016, 07:44 am
Hola:

Como en las películas de antes, no recuerdo en qué peli sale, un ordenador que al imprimir mensajes, se oye un ruido por cada letra muy rápido.

Hice lo de imprimir cada letra en 10 milisegundos, 0.010 segundos.

Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Threading; // No olvidar.

namespace Texto_consola_CS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WindowWidth = 80;
            Console.WindowHeight = 43;

            Console.Title = "Título del programa en la ventana de la consola.";

            Console.BackgroundColor = ConsoleColor.Black; // Fondo pantalla blanco.
            Console.Clear(); // Limpiar pantalla.
            Console.ForegroundColor = ConsoleColor.Green; // Color texto azul.

            string Cadena = @"El hombre moderno es un viajero que ha olvidado el lugar de donde va, y que 
ha de volver a donde viene para saber a donde va.

No busques al amigo para matar las horas, sino búscale con horas para vivir.

Los amigos se convierten con frecuencia en ladrones de nuestro tiempo.

Es difícil decir quién hace el mayor daño: los enemigos con sus peores intenciones o los amigos con las mejores.

Recorre a menudo la senda que lleva al huerto de tu amigo, no sea que la maleza te impida ver el camino.";

            Console.CursorVisible = true;

            foreach (char Letra in Cadena)
            {
                Console.Write(Letra);
                Thread.Sleep(2); //medio segundo
            }
            Console.Beep();
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
    }
}

Al final de impresión de oye un beep. No encuentro un vídeo de ejemplo por ahora para que vean a lo que me refiero. Cuando el hombre habla con el ordenador en la película y le responde con mesajes que se oye el ruido por cada letra que escriba en pantalla.

Si alguien sabe como se hace, lo explican, no he encontrado nada igual por Internet, lo más parecido es esto.

https://msdn.microsoft.com/es-es/library/4fe3hdb1%28v=vs.110%29.aspx

Pero no es lo mismo.

Cualquier información es de ayuda.

Saludos.
238  Programación / .NET (C#, VB.NET, ASP) / Enviar tramas de bytes en C++/CLR en: 10 Febrero 2016, 17:27 pm
Hola:

En C# para enviar un byte al puerto serie uso esto.

Código:
private void button_t_Click(object sender, EventArgs e)
{
    byte[] mBuffer = new byte[1];
    mBuffer[0] = 0x74; //ASCII letter "t".
    serialPort1.Write(mBuffer, 0, mBuffer.Length);
}

En C++/CLR su código es este.


Para enviar de forma de cadena en C# se hace así:
Código:
private void button_b_Click(object sender, EventArgs e)
{
    byte[] mBuffer = Encoding.ASCII.GetBytes("Hello World");
    serialPort1.Write(mBuffer, 0, mBuffer.Length);
}

¿Cómo se hace en C++/CLR?

Saludos.
239  Programación / .NET (C#, VB.NET, ASP) / Pasar de C# a C++ CLR. en: 8 Febrero 2016, 13:14 pm
Hola:

Tengo el código en C# de esta manera. Este código solo recibe datos por el puerto serie.
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Forms;
  10.  
  11. using System.IO.Ports; // No olvidar.
  12. using System.Threading;
  13.  
  14. namespace Entrada_Arduino_AWF_1_CS
  15. {
  16.     public partial class Form1 : Form
  17.     {
  18.         // Utilizaremos un string como buffer de recepción.
  19.         string Recibidos;
  20.  
  21.         public Form1()
  22.         {
  23.             InitializeComponent();
  24.  
  25.             if (!serialPort1.IsOpen)
  26.             {
  27.                 try
  28.                 {
  29.                     serialPort1.Open();
  30.                 }
  31.                 catch (System.Exception ex)
  32.                 {
  33.                     MessageBox.Show(ex.ToString());
  34.                 }
  35.  
  36.                 serialPort1.DataReceived += new SerialDataReceivedEventHandler(Recepcion);
  37.             }
  38.         }
  39.  
  40.         // Al recibir datos.
  41.         private void Recepcion(object sender, SerialDataReceivedEventArgs e)
  42.         {
  43.             // Acumula los caracteres recibidos a nuestro 'buffer' (string).
  44.             Recibidos += serialPort1.ReadExisting();
  45.  
  46.             // Invocar o llamar al proceso de tramas.
  47.             Invoke(new EventHandler(Actualizar));
  48.         }
  49.  
  50.         // Procesar los datos recibidos en el bufer y extraer tramas completas.
  51.         private void Actualizar(object sender, EventArgs e)
  52.         {
  53.  
  54.             switch (Recibidos)
  55.             {
  56.                 case "ON":
  57.                     panel1.BackColor = Color.Green;
  58.                     label_Lectura.Text = "Activado";
  59.                     pictureBox_Dibujo.Image = Properties.Resources.Led_rojo_encendido;
  60.                     Recibidos = "";
  61.                     break;
  62.  
  63.                 case "OFF":
  64.                     panel1.BackColor = Color.Red;
  65.                     label_Lectura.Text = "Desactivado";
  66.                     pictureBox_Dibujo.Image = Properties.Resources.Led_rojo_apagado;
  67.                     Recibidos = "";
  68.                     break;
  69.             }
  70.         }
  71.  
  72.         // Cuando cierre la aplicación.
  73.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  74.         {
  75.             if (serialPort1.IsOpen) // ¿El puerto está abierto?
  76.             {
  77.                 serialPort1.Close(); // Cerrar puerto.
  78.             }
  79.         }
  80.     }
  81. }

He intentado imigar el código de C# a C++/CLR. Pero que va.
Código
  1. #pragma once
  2.  
  3. namespace Entrada_Arduino_CPP_CLR_1 {
  4.  
  5. 	using namespace System;
  6. 	using namespace System::ComponentModel;
  7. 	using namespace System::Collections;
  8. 	using namespace System::Windows::Forms;
  9. 	using namespace System::Data;
  10. 	using namespace System::Drawing;
  11.  
  12. 	using namespace System::IO::Ports; // No olvidar.
  13.  
  14. 	/// <summary>
  15. 	/// Resumen de Form_Principal
  16. 	/// </summary>
  17. 	public ref class Form_Principal : public System::Windows::Forms::Form
  18. 	{
  19. 		// Utilizaremos un string como buffer de recepción.
  20. 		String^ Recibidos;
  21.  
  22. 	public:
  23. 		Form_Principal(void)
  24. 		{
  25. 			InitializeComponent();
  26. 			//
  27. 			//TODO: agregar código de constructor aquí
  28. 			//
  29.  
  30. 			if (!serialPort1->IsOpen)
  31. 			{
  32. 				try
  33. 				{
  34. 					serialPort1->Open();
  35. 				}
  36. 				catch (Exception ^ex)
  37. 				{
  38. 					MessageBox::Show(ex->ToString());
  39. 				}
  40.  
  41. 				serialPort1->DataReceived += new SerialDataReceivedEventHandler(Recepcion);
  42. 			}
  43. 		}
  44.  
  45. 		// Al recibir datos.
  46. 		private void Recepcion(object sender, SerialDataReceivedEventArgs e)
  47. 		{
  48. 			// Acumula los caracteres recibidos a nuestro 'buffer' (string).
  49. 			Recibidos += serialPort1->ReadExisting();
  50.  
  51. 			// Invocar o llamar al proceso de tramas.
  52. 			Invoke(new EventHandler(Actualizar));
  53. 		}
  54.  
  55. 		// Procesar los datos recibidos en el bufer y extraer tramas completas.
  56. 		private void Actualizar(object sender, EventArgs e)
  57. 		{
  58.  
  59. 			switch (Recibidos)
  60. 			{
  61. 			case "ON":
  62. 				panel1->BackColor = Color::Green;
  63. 				label_Lectura->Text = "Activado";
  64. 				pictureBox_Dibujo->Image = Properties::Resources::Led_rojo_encendido;
  65. 				Recibidos = "";
  66. 				break;
  67.  
  68. 			case "OFF":
  69. 				panel1->BackColor = Color::Red;
  70. 				label_Lectura->Text = "Desactivado";
  71. 				pictureBox_Dibujo->Image = Properties::Resources::Led_rojo_apagado;
  72. 				Recibidos = "";
  73. 				break;
  74. 			}
  75. 		}
  76.  
  77. 	protected:
  78. 		/// <summary>
  79. 		/// Limpiar los recursos que se estén usando.
  80. 		/// </summary>
  81. 		~Form_Principal()
  82. 		{
  83. 			if (components)
  84. 			{
  85. 				delete components;
  86. 			}
  87. 		}
  88. 	private: System::Windows::Forms::Label^  label_titulo;
  89. 	protected:
  90. 	private: System::Windows::Forms::Panel^  panel1;
  91. 	private: System::Windows::Forms::Label^  label_Lectura;
  92. 	private: System::Windows::Forms::PictureBox^  pictureBox_Dibujo;
  93. 	private: System::IO::Ports::SerialPort^  serialPort1;
  94. 	private: System::Windows::Forms::Label^  label1;
  95. 	private: System::ComponentModel::IContainer^  components;
  96.  
  97. 	private:
  98. 		/// <summary>
  99. 		/// Variable del diseñador necesaria.
  100. 		/// </summary>
  101.  
  102.  
  103. #pragma region Windows Form Designer generated code
  104. 		/// <summary>
  105. 		/// Método necesario para admitir el Diseñador. No se puede modificar
  106. 		/// el contenido de este método con el editor de código.
  107. 		/// </summary>
  108. 		void InitializeComponent(void)
  109. 		{
  110. 			this->components = (gcnew System::ComponentModel::Container());
  111. 			System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(Form_Principal::typeid));
  112. 			this->label_titulo = (gcnew System::Windows::Forms::Label());
  113. 			this->panel1 = (gcnew System::Windows::Forms::Panel());
  114. 			this->label_Lectura = (gcnew System::Windows::Forms::Label());
  115. 			this->pictureBox_Dibujo = (gcnew System::Windows::Forms::PictureBox());
  116. 			this->serialPort1 = (gcnew System::IO::Ports::SerialPort(this->components));
  117. 			this->label1 = (gcnew System::Windows::Forms::Label());
  118. 			(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->pictureBox_Dibujo))->BeginInit();
  119. 			this->SuspendLayout();
  120. 			// 
  121. 			// label_titulo
  122. 			// 
  123. 			this->label_titulo->AutoSize = true;
  124. 			this->label_titulo->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 36, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point,
  125. 				static_cast<System::Byte>(0)));
  126. 			this->label_titulo->Location = System::Drawing::Point(29, 26);
  127. 			this->label_titulo->Name = L"label_titulo";
  128. 			this->label_titulo->Size = System::Drawing::Size(382, 55);
  129. 			this->label_titulo->TabIndex = 0;
  130. 			this->label_titulo->Text = L"Visual C++ CLR";
  131. 			// 
  132. 			// panel1
  133. 			// 
  134. 			this->panel1->BorderStyle = System::Windows::Forms::BorderStyle::FixedSingle;
  135. 			this->panel1->Location = System::Drawing::Point(23, 97);
  136. 			this->panel1->Name = L"panel1";
  137. 			this->panel1->Size = System::Drawing::Size(100, 100);
  138. 			this->panel1->TabIndex = 1;
  139. 			// 
  140. 			// label_Lectura
  141. 			// 
  142. 			this->label_Lectura->AutoSize = true;
  143. 			this->label_Lectura->Location = System::Drawing::Point(183, 138);
  144. 			this->label_Lectura->Name = L"label_Lectura";
  145. 			this->label_Lectura->Size = System::Drawing::Size(48, 13);
  146. 			this->label_Lectura->TabIndex = 2;
  147. 			this->label_Lectura->Text = L"Leyendo";
  148. 			// 
  149. 			// pictureBox_Dibujo
  150. 			// 
  151. 			this->pictureBox_Dibujo->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"pictureBox_Dibujo.Image")));
  152. 			this->pictureBox_Dibujo->Location = System::Drawing::Point(311, 97);
  153. 			this->pictureBox_Dibujo->Name = L"pictureBox_Dibujo";
  154. 			this->pictureBox_Dibujo->Size = System::Drawing::Size(100, 100);
  155. 			this->pictureBox_Dibujo->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage;
  156. 			this->pictureBox_Dibujo->TabIndex = 3;
  157. 			this->pictureBox_Dibujo->TabStop = false;
  158. 			// 
  159. 			// serialPort1
  160. 			// 
  161. 			this->serialPort1->BaudRate = 115200;
  162. 			this->serialPort1->PortName = L"COM4";
  163. 			this->serialPort1->StopBits = System::IO::Ports::StopBits::Two;
  164. 			// 
  165. 			// label1
  166. 			// 
  167. 			this->label1->AutoSize = true;
  168. 			this->label1->Location = System::Drawing::Point(349, 200);
  169. 			this->label1->Name = L"label1";
  170. 			this->label1->Size = System::Drawing::Size(25, 13);
  171. 			this->label1->TabIndex = 4;
  172. 			this->label1->Text = L"Led";
  173. 			// 
  174. 			// Form_Principal
  175. 			// 
  176. 			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
  177. 			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
  178. 			this->ClientSize = System::Drawing::Size(436, 262);
  179. 			this->Controls->Add(this->label1);
  180. 			this->Controls->Add(this->pictureBox_Dibujo);
  181. 			this->Controls->Add(this->label_Lectura);
  182. 			this->Controls->Add(this->panel1);
  183. 			this->Controls->Add(this->label_titulo);
  184. 			this->Name = L"Form_Principal";
  185. 			this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen;
  186. 			this->Text = L"Electrónica PIC - C++ 2015";
  187. 			(cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->pictureBox_Dibujo))->EndInit();
  188. 			this->ResumeLayout(false);
  189. 			this->PerformLayout();
  190.  
  191. 		}
  192. #pragma endregion
  193. 	};
  194. }

¿Alguna ayuda?

Muchas gracias.
240  Programación / Programación C/C++ / Cambiar título de consola en: 4 Febrero 2016, 22:51 pm
Hola:

Usando el Dev C++ con un hola mundo. En el título de la ventana quiero que me diga el nombre del programa. El programa es hecho en modo consola.

He buscado por google y me dice cambiar el color, pero eso es dentro del programa, no quiero cambiar colores, solo el nombre o título.

Espero que se entienda lo que quiero decir. También hay que ver si en consola es posible hacerlo en Dev C++, en C# se hace así:

Código
  1. Console.title = "Título o nombre del programa";

Estamos en C++ Win32 en modo consola.

Saludos.
Páginas: 1 ... 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 [24] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 ... 68
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines